Come utilizzare Morgan logger?

Non riesco ad accedere a Morgan. Non registra le informazioni sulla console. La documentazione non dice come usarlo.

Voglio vedere cos'è una variabile. Questo è un codice dal response.jsfile del 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);
};

Come si usa Morgan?

Sembra che anche tu sia confuso con la stessa cosa di me, il motivo per cui sono incappato in questa domanda. Penso che associamo la registrazione alla registrazione manuale come faremmo in Java con log4j (se conosci java) dove istanziamo un logger e diciamo log "questo".

Poi ho scavato nel codice Morgan, risulta che non è quel tipo di logger, è per la registrazione automatica di richieste, risposte e dati correlati. Quando viene aggiunto come middleware a un'app express / connect, per impostazione predefinita dovrebbe registrare le istruzioni su stdout mostrando i dettagli di: ip remoto, metodo di richiesta, versione http, stato della risposta, agente utente ecc. Consente di modificare il registro utilizzando token o aggiungere colore a loro definendo "dev" o anche disconnettendosi a un flusso di output, come un file.

Allo scopo abbiamo pensato di poterlo utilizzare, in quanto in questo caso dobbiamo ancora utilizzare:

console.log(..);

O se vuoi rendere l'output carino per gli oggetti:

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

Penso di avere un modo in cui potresti non ottenere esattamente ciò che desideri, ma puoi integrare la registrazione di Morgan con log4js - in altre parole, tutta la tua attività di registrazione può andare nello stesso posto. Spero che questo riassunto da un server Express sia più o meno autoesplicativo:

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

Ora puoi scrivere quello che vuoi su AppLog e Morgan scriverà ciò che vuole nello stesso posto, usando gli stessi appendici ecc. Ecc. Ovviamente puoi chiamare info () o qualunque cosa ti piaccia nel wrapper dello stream invece di debug () - che riflette solo il livello di registrazione che si desidera dare alla registrazione req / res di Morgan.

Morgan non dovrebbe essere utilizzato per accedere nel modo in cui stai descrivendo. Morgan è stato creato per eseguire la registrazione nel modo in cui server come Apache e Nginx accedono a error_log o access_log. Per riferimento, ecco come usi 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'));
}

Nota la linea di produzione in cui vedi Morgan chiamato con un hash delle opzioni {skip: ..., stream: __dirname + '/../morgan.log'}

La streamproprietà di quell'oggetto determina la posizione di output del logger. Per impostazione predefinita è STDOUT (la tua console, proprio come vuoi tu) ma registrerà solo i dati delle richieste. Non farà quello che console.log()fa.

Se vuoi ispezionare le cose al volo usa la utillibreria incorporata :

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

Quindi la risposta alla tua domanda è che stai facendo la domanda sbagliata. Ma se vuoi ancora utilizzare Morgan per la registrazione delle richieste, eccolo.

Ho affrontato lo stesso problema fa e invece ho usato Winston. Come hanno detto i ragazzi sopra, morgan è per la registrazione automatica di richieste / risposte. Winston può essere configurato più o meno allo stesso modo di log4Net / log4J, ha livelli di gravità, flussi diversi a cui è possibile accedere ecc.

Per esempio:

npm install winston

Quindi, se chiami il codice seguente da qualche parte durante l'inizializzazione dell'applicazione:

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

nota: prima di chiamare il codice sopra, winston.loggers è vuoto, cioè non hai ancora configurato alcun logger. Più o meno come i metodi Log4Net / J XmlConfigure: devi prima chiamarli per avviare la registrazione.

Quindi, in seguito, ovunque nel codice lato server delle applicazioni puoi fare:

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

Spero che aiuti.

per ulteriore riferimento alla documentazione: https://www.npmjs.com/package/winston

Morgan: - Morgan è un middleware che ci aiuterà a identificare i clienti che accedono alla nostra applicazione. Fondamentalmente un logger.

Per utilizzare Morgan, dobbiamo seguire i seguenti passaggi: -

1. Installa il morgan usando il comando seguente:

npm install --save morgan

Questo aggiungerà morgan al file json.package

2. Includi il morgan nel tuo progetto

var morgan = require('morgan');

3> // crea un flusso di scrittura (in modalità di aggiunta)

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

Nota: assicurati di non scandagliare sopra ciecamente assicurati di avere tutte le condizioni in cui hai bisogno.

Sopra creerà automaticamente un file access.log nella tua root una volta che l'utente avrà accesso alla tua app.

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

esempio nodejs + express + morgan

Nel mio caso:

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

FIX: stavo usando il codice di Visual Studio e ho dovuto aggiungerlo alla mia configurazione di avvio

"outputCapture": "std"

Suggerimento, nel caso in cui esegui da un IDE, esegui direttamente dalla riga di comando per assicurarti che l'IDE non stia causando il problema.

Potresti provare a usare mongo-morgan-ext

L'utilizzo è:

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

L'output previsto è

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

}

Usare morgan è molto semplice. Come suggerisce la documentazione , ci sono diversi modi per ottenere l'output desiderato con morgan. Viene fornito con metodi di registrazione preconfigurati oppure puoi definirne uno tu stesso. Per esempio.

const morgan = require ('morgan')

app.use (Morgan ( 'piccolo')

Questo ti darà la preconfigurazione chiamata tiny. Noterai nel tuo terminale cosa fa. Nel caso in cui non sei soddisfatto di questo e desideri più approfondimenti, ad esempio diciamo l'URL della richiesta, è qui che entrano i token.

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

quindi usalo in questo modo:

app.use (morgan (': url')

Controlla la documentazione, è tutto evidenziato lì.