Wie benutzt man Morgan Logger?

Ich kann mich nicht bei Morgan anmelden. Es werden keine Informationen in der Konsole protokolliert. Die Dokumentation sagt nicht, wie man es benutzt.

Ich möchte sehen, was eine Variable ist. Dies ist ein Code aus der response.jsDatei des ExpressJS-Frameworks:

var logger = require("morgan");

res.render = function(view, options, fn){
  options = options || {};
  var self = this;
  var req = this.req;
  var app = req.app;

  // support callback function as second arg
  if ('function' == typeof options) {
    fn = options, options = {};
  }

  // merge res.locals
  options._locals = self.locals;

  // default callback to respond
  fn = fn || function(err, str){
    if (err) return req.next(err);
    self.send(str);
  };

  // Here I want to see what fn is
  // But it doesn't show me anything in console
  // How to use it?
  logger(fn);

  // render
  app.render(view, options, fn);
};

Wie benutzt man Morgan?

Sie scheinen auch mit der gleichen Sache verwirrt zu sein wie ich, der Grund, warum ich auf diese Frage gestoßen bin. Ich denke, wir verbinden die Protokollierung mit der manuellen Protokollierung, wie wir es in Java mit log4j tun würden (wenn Sie Java kennen), wo wir einen Logger instanziieren und log 'this' sagen.

Dann habe ich Morgan-Code eingegraben und festgestellt, dass es sich nicht um einen solchen Logger handelt, sondern um die automatische Protokollierung von Anfragen, Antworten und zugehörigen Daten. Beim Hinzufügen als Middleware zu einer Express / Connect-App sollten standardmäßig Anweisungen in stdout protokolliert werden, die Details zu folgenden Elementen anzeigen: Remote-IP, Anforderungsmethode, http-Version, Antwortstatus, Benutzeragent usw. Sie können das Protokoll mithilfe von Token oder ändern Fügen Sie ihnen Farbe hinzu, indem Sie 'dev' definieren oder sich sogar bei einem Ausgabestream wie einer Datei abmelden.

Für den Zweck, den wir dachten, wir können es verwenden, wie in diesem Fall müssen wir noch verwenden:

console.log(..);

Oder wenn Sie die Ausgabe für Objekte hübsch gestalten möchten:

var util = require("util");
console.log(util.inspect(..));

Ich glaube, ich habe einen Weg, auf dem Sie möglicherweise nicht genau das bekommen, was Sie wollen, aber Sie können Morgans Protokollierung in log4js integrieren - mit anderen Worten, alle Ihre Protokollierungsaktivitäten können an denselben Ort gehen. Ich hoffe, dieser Digest von einem Express-Server ist mehr oder weniger selbsterklärend:

var express = require("express");
var log4js = require("log4js");
var morgan = require("morgan");
...
var theAppLog = log4js.getLogger();
var theHTTPLog = morgan({
  "format": "default",
  "stream": {
    write: function(str) { theAppLog.debug(str); }
  }
});
....
var theServer = express();
theServer.use(theHTTPLog);

Jetzt können Sie schreiben, was Sie wollen, und Morgan schreibt, was es will, an den gleichen Ort, mit den gleichen Appendern usw. usw. Natürlich können Sie info () oder was auch immer Sie im Stream-Wrapper aufrufen, anstatt debug (). - Dies spiegelt nur die Protokollierungsstufe wider, die Sie für Morgans Anforderungs- / Res-Protokollierung angeben möchten.

Morgan sollte nicht verwendet werden, um sich so anzumelden, wie Sie es beschreiben. Morgan wurde entwickelt, um die Protokollierung so durchzuführen, dass Server wie Apache und Nginx im error_log oder access_log protokollieren. Als Referenz verwenden Sie Morgan folgendermaßen:

var express     = require('express'),
    app         = express(),
    morgan      = require('morgan'); // Require morgan before use

// You can set morgan to log differently depending on your environment
if (app.get('env') == 'production') {
  app.use(morgan('common', { skip: function(req, res) { return res.statusCode < 400 }, stream: __dirname + '/../morgan.log' }));
} else {
  app.use(morgan('dev'));
}

Beachten Sie die Produktionslinie, in der Morgan mit einem Options-Hash aufgerufen wird {skip: ..., stream: __dirname + '/../morgan.log'}

Die streamEigenschaft dieses Objekts bestimmt, wo der Logger ausgibt. Standardmäßig ist es STDOUT (Ihre Konsole, genau wie Sie möchten), aber es werden nur Anforderungsdaten protokolliert. Es wird nicht tun, was console.log()tut.

Wenn Sie Dinge im Handumdrehen überprüfen möchten, verwenden Sie die integrierte utilBibliothek:

var util = require('util');
console.log(util.inspect(anyObject)); // Will give you more details than console.log

Die Antwort auf Ihre Frage lautet also, dass Sie die falsche Frage stellen. Wenn Sie Morgan dennoch zum Protokollieren von Anfragen verwenden möchten, können Sie loslegen.

Ich hatte vor dem gleichen Problem und stattdessen habe ich Winston verwendet. Wie oben erwähnt, dient Morgan der automatisierten Protokollierung von Anfragen / Antworten. Winston kann fast genauso konfiguriert werden wie log4Net / log4J, hat Schweregrade, verschiedene Streams, bei denen Sie sich anmelden können usw.

Beispielsweise:

npm install winston

Wenn Sie dann den folgenden Code irgendwo in Ihrer Anwendungsinitialisierung aufrufen:

var winston = require('winston');

// setup default logger (no category)
winston.loggers.add('default', {
    console: {
        colorize: 'true',
        handleExceptions: true,
        json: false,
        level: 'silly',
        label: 'default',
    },
    file: {
        filename: 'some/path/where/the/log/file/reside/default.log',
        level: 'silly',
        json: false,
        handleExceptions: true,
    },
});

//
// setup logger for category `usersessions`
// you can define as many looggers as you like
//
winston.loggers.add('usersessions', {
    console: {
        level: 'silly',
        colorize: 'true',
        label: 'usersessions',
        json: false,
        handleExceptions: true,
    },
    file: {
        filename: 'some/path/where/the/log/file/reside/usersessions.log',
        level: 'silly',
        json: false,
        handleExceptions: true,
    },
});

Hinweis: Vor dem Aufrufen des obigen Codes ist winston.loggers leer, dh Sie haben noch keine Logger konfiguriert. Ähnlich wie bei den Log4Net / J XmlConfigure-Methoden müssen Sie sie zuerst aufrufen, um die Protokollierung zu starten.

Dann, später, wo immer Sie in Ihrem Anwendungsserver Code tun können:

var winston = require('winston');
// log instances as defined in first snippet
var defaultLog = winston.loggers.get('default'); 
var userSessionsLog = winston.loggers.get('usersessions');

defaultLog.info('this goes to file default.log');
userSessionsLog.debug('this goes to file usersessions.log')

Hoffentlich hilft das.

Weitere Informationen zur Dokumentation finden Sie unter: https://www.npmjs.com/package/winston

Morgan: - Morgan ist eine Middleware, mit deren Hilfe wir die Kunden identifizieren können, die auf unsere Anwendung zugreifen. Grundsätzlich ein Logger.

Um Morgan zu verwenden, müssen wir die folgenden Schritte ausführen: -

1. Installieren Sie den Morgan mit dem folgenden Befehl:

npm install --save morgan

Dadurch wird der Datei json.package Morgan hinzugefügt

2. Nehmen Sie den Morgan in Ihr Projekt auf

var morgan = require('morgan');

3> // Schreibstrom erstellen (im Anhänge-Modus)

var accessLogStream = fs.createWriteStream(
      path.join(__dirname, 'access.log'), {flags: 'a'}
 );
// setup the logger 
app.use(morgan('combined', {stream: accessLogStream}));

Hinweis: Stellen Sie sicher, dass Sie nicht blind über dem Lot liegen. Stellen Sie sicher, dass Sie alle Bedingungen haben, die Sie benötigen.

Oben wird automatisch eine access.log-Datei für Ihr Stammverzeichnis erstellt, sobald der Benutzer auf Ihre App zugreift.

var express = require('express');

var fs = require('fs');

var morgan = require('morgan')

var app = express();

// create a write stream (in append mode)
var accessLogStream = fs.createWriteStream(__dirname + '/access.log',{flags: 'a'});


// setup the logger
app.use(morgan('combined', {stream: accessLogStream}))


app.get('/', function (req, res) {
  res.send('hello, world!')
});

Beispiel nodejs + express + morgan

In meinem Fall:

-console.log()  // works
-console.error() // works
-app.use(logger('dev')) // Morgan is NOT logging requests that look like "GET /myURL 304 9.072 ms - -"

UPDATE: Ich habe Visual Studio-Code verwendet und musste diesen meiner Startkonfiguration hinzufügen

"outputCapture": "std"

Vorschlag: Wenn Sie von einer IDE ausgeführt werden, führen Sie diese direkt über die Befehlszeile aus, um sicherzustellen, dass die IDE das Problem nicht verursacht.

Vielleicht möchten Sie versuchen, Mongo-Morgan-Ext zu verwenden

Die Verwendung ist:

var logger = require('mongo-morgan-ext');

var db = 'mongodb://localhost:27017/MyDB';

var collection = 'Logs'

var skipfunction = function(req, res) {

return res.statusCode > 399;
} //Thiw would skip if HTTP request response is less than 399 i.e no errors.

app.use(logger(db,collection,skipfunction)); //In your express-application

Die erwartete Ausgabe ist

{
    "RequestID": "",
    "status": "",
    "method": "",
    "Remote-user": "",
    "Remote-address": "",
    "URL": "",
    "HTTPversion": "",
    "Response-time": "",
    "date":"",
    "Referrer": "",
    "REQUEST": { //10
        "Accept": "",
        "Accept-Charset": "",
        "Accept-Encoding": "",
        "Accept-Language": "",
        "Authorization": "",
        "Cache-Control": "",
        "Connection": "",
        "Cookie": "",
        "Content-Length": "",
        "Content-MD5": "",
        "Content-Type": "",
        "Expect": "",
        "Forwarded": "",
        "From": "",
        "Host": "",
        "Max-Forwards": "",
        "Origin": "",
        "Pragma": "",
        "Proxy-Authorization": "",
        "Range": "",
        "TE": "",
        "User-Agent": "",
        "Via": "",
        "Warning": "",
        "Upgrade": "",
        "Referer": "",
        "Date": "",
        "X-requested-with": "",
        "X-Csrf-Token": "",
        "X-UIDH": "",
        "Proxy-Connection": "",
        "X-Wap-Profile": "",
        "X-ATT-DeviceId": "",
        "X-Http-Method-Override":"",
        "Front-End-Https": "",
        "X-Forwarded-Proto": "",
        "X-Forwarded-Host": "",
        "X-Forwarded-For": "",
        "DNT": "",
        "Accept-Datetime": "",
        "If-Match": "",
        "If-Modified-Since": "",
        "If-None-Match": "",
        "If-Range": "",
        "If-Unmodified-Since": ""
    },
    "RESPONSE": {
        "Status": "",
        "Content-MD5":"",
        "X-Frame-Options": "",
        "Accept-Ranges": "",
        "Age": "",
        "Allow": "",
        "Cache-Control": "",
        "Connection": "",
        "Content-Disposition": "",
        "Content-Encoding": "",
        "Content-Language": "",
        "Content-Length": "",
        "Content-Location": "",
        "Content-Range": "",
        "Content-Type":"",
        "Date":"",
        "Last-Modified": "",
        "Link": "",
        "Location": "",
        "P3P": "",
        "Pragma": "",
        "Proxy-Authenticate": "",
        "Public-Key-Pins": "",
        "Retry-After": "",
        "Server": "",
        "Trailer": "",
        "Transfer-Encoding": "",
        "TSV": "",
        "Upgrade": "",
        "Vary": "",
        "Via": "",
        "Warning": "",
        "WWW-Authenticate": "",
        "Expires": "",
        "Set-Cookie": "",
        "Strict-Transport-Security": "",
        "Refresh":"",
        "Access-Control-Allow-Origin": "",
        "X-XSS-Protection": "",
        "X-WebKit-CSP":"",
        "X-Content-Security-Policy": "",
        "Content-Security-Policy": "",
        "X-Content-Type-Options": "",
        "X-Powered-By": "",
        "X-UA-Compatible": "",
        "X-Content-Duration": "",
        "Upgrade-Insecure-Requests": "",
        "X-Request-ID": "",
        "ETag": "",
        "Accept-Patch": ""
    }

}

Die Verwendung von Morgan ist ziemlich einfach. Wie aus der Dokumentation hervorgeht , gibt es verschiedene Möglichkeiten, mit Morgan die gewünschte Ausgabe zu erzielen. Es wird mit vorkonfigurierten Protokollierungsmethoden geliefert, oder Sie können eine selbst definieren. Z.B.

const morgan = erfordern ('morgan')

app.use (morgan ('winzig')

Dies gibt Ihnen die Vorkonfiguration winzig. Sie werden in Ihrem Terminal feststellen, was es tut. Wenn Sie damit nicht zufrieden sind und mehr wollen, z. B. die Anforderungs-URL, dann kommen hier Token ins Spiel.

morgan.token ('url', Funktion (req, res) {return '/ api / myendpoint'})

dann benutze es so:

app.use (morgan (': url')

Überprüfen Sie die Dokumentation, die dort hervorgehoben ist.