Comment utiliser Morgan Logger?

Je ne peux pas me connecter avec Morgan. Il n'enregistre pas les informations dans la console. La documentation ne dit pas comment l'utiliser.

Je veux voir ce qu'est une variable. Ceci est un code du response.jsfichier du framework expressjs:

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);
};

Comment utiliser Morgan?

Il semble que vous aussi êtes confondu avec la même chose que moi, la raison pour laquelle je suis tombé sur cette question. Je pense que nous associons la journalisation à la journalisation manuelle comme nous le ferions en Java avec log4j (si vous connaissez java) où nous instancions un enregistreur et disons log 'this'.

Ensuite, j'ai creusé dans le code morgan, il s'avère que ce n'est pas ce type d'enregistreur, c'est pour la journalisation automatisée des demandes, des réponses et des données associées. Lorsqu'il est ajouté en tant que middleware à une application express / connect, il doit par défaut enregistrer les instructions dans stdout en affichant les détails de: l'adresse IP distante, la méthode de requête, la version http, l'état de la réponse, l'agent utilisateur, etc. Il vous permet de modifier le journal à l'aide de jetons ou ajoutez-leur de la couleur en définissant «dev» ou même en vous déconnectant d'un flux de sortie, comme un fichier.

Pour le but, nous avons pensé pouvoir l'utiliser, comme dans ce cas, nous devons encore utiliser:

console.log(..);

Ou si vous voulez rendre la sortie jolie pour les objets:

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

Je pense que j'ai un moyen de ne pas obtenir exactement ce que vous voulez, mais vous pouvez intégrer la journalisation de Morgan avec log4js - en d'autres termes, toute votre activité de journalisation peut aller au même endroit. J'espère que ce résumé d'un serveur Express est plus ou moins explicite:

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);

Vous pouvez maintenant écrire ce que vous voulez dans l'AppLog et Morgan écrira ce qu'il veut au même endroit, en utilisant les mêmes appenders, etc. - qui reflète simplement le niveau de journalisation que vous souhaitez donner à la journalisation des demandes / res de Morgan.

Morgan ne doit pas être utilisé pour se connecter de la manière que vous décrivez. Morgan a été conçu pour se connecter de la même manière que les serveurs comme Apache et Nginx enregistrent dans le journal d'erreur ou le journal d'accès. Pour référence, voici comment vous utilisez morgan:

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'));
}

Notez la ligne de production où vous voyez morgan appelé avec un hachage d'options {skip: ..., stream: __dirname + '/../morgan.log'}

La streampropriété de cet objet détermine où le journal sort. Par défaut, c'est STDOUT (votre console, comme vous le souhaitez) mais il ne consignera que les données de demande. Il ne fera pas ce que console.log()fait.

Si vous voulez inspecter les choses à la volée, utilisez le util bibliothèque intégrée:

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

La réponse à votre question est donc que vous posez la mauvaise question. Mais si vous souhaitez toujours utiliser Morgan pour la journalisation des demandes, vous y êtes.

J'ai fait face au même problème il y a et à la place, j'ai utilisé winston. Comme les gars l'ont dit ci-dessus, morgan est pour la journalisation automatisée des demandes / réponses. Winston peut être configuré à peu près de la même manière que log4Net / log4J, a des niveaux de gravité, différents flux auxquels vous pouvez vous connecter, etc.

Par exemple:

npm install winston

Ensuite, si vous appelez le code ci-dessous quelque part lors de l'initialisation de votre application:

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,
    },
});

note: avant d'appeler le code ci-dessus, winston.loggers est vide, c'est-à-dire que vous n'avez pas encore configuré d'enregistreurs. Un peu comme les méthodes Log4Net / J XmlConfigure - vous devez d'abord les appeler, pour lancer votre journalisation.

Ensuite, plus tard, n'importe où dans votre code côté serveur d'applications, vous pouvez faire:

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')

J'espère que cela pourra aider.

pour plus d'informations sur la documentation: https://www.npmjs.com/package/winston

Morgan: - Morgan est un middleware qui nous aidera à identifier les clients qui accèdent à notre application. Fondamentalement, un enregistreur.

Pour utiliser Morgan, nous devons suivre les étapes ci-dessous: -

1. Installez le morgan en utilisant la commande ci-dessous:

npm install --save morgan

Cela ajoutera morgan au fichier json.package

2. Incluez le morgan dans votre projet

var morgan = require('morgan');

3> // créer un flux d'écriture (en mode ajout)

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

Remarque: assurez-vous de ne pas aplomber aveuglément au-dessus, assurez-vous que toutes les conditions sont nécessaires.

Ci-dessus créera automatiquement un fichier access.log à votre racine une fois que l'utilisateur aura accès à votre application.

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!')
});

exemple nodejs + express + morgan

Dans mon cas:

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

CORRECTIF: J'utilisais du code Visual Studio et je devais l'ajouter à ma configuration de lancement

"outputCapture": "std"

Suggestion, dans le cas où vous exécutez à partir d'un IDE, exécutez directement à partir de la ligne de commande pour vous assurer que l'EDI n'est pas à l'origine du problème.

Vous voudrez peut-être essayer d'utiliser mongo-morgan-ext

L'utilisation est:

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

Le résultat attendu est

{
    "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": ""
    }

}

L'utilisation de Morgan est assez simple. Comme le suggère la documentation , il existe différentes manières d'obtenir la sortie souhaitée avec morgan. Il est livré avec des méthodes de journalisation préconfigurées ou vous pouvez en définir une vous-même. Par exemple.

const morgan = require ('morgan')

app.use (morgan ('minuscule')

Cela vous donnera la préconfiguration appelée tiny. Vous remarquerez dans votre terminal ce qu'il fait. Dans le cas où vous n'êtes pas satisfait de cela et que vous voulez plus profond, par exemple, disons l'url de la requête, alors c'est là que les jetons entrent en jeu.

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

puis utilisez-le comme ceci:

app.use (morgan (': url')

Vérifiez la documentation, tout est mis en évidence ici.