Come utilizzare il logger Morgan?

Question

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

Voglio vedere che cos'è una variabile. Questo è un codice da response.js file quadro 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 usare Morgan?

Answer 1

Sembra che anche tu sia confuso con la stessa cosa di me, il motivo per cui sono incappato in questa domanda. Penso che associamo il logging con il logging manuale come faremmo in Java con log4j (se conosci java) dove istanziamo un Logger e diamo il log 'this'.

Quindi ho scavato nel codice morgan, risulta che non è quel tipo di logger, è per la registrazione automatica di richieste, risposte e dati correlati. Quando aggiunto come middleware a un'app express/connect, per impostazione predefinita dovrebbe registrare istruzioni sullo stdout che mostrano i dettagli di: ip remoto, metodo di richiesta, versione http, stato della risposta, agente utente ecc. Permette di modificare il log usando token o aggiungi loro un colore definendo 'dev' o anche effettuando il logout su un flusso di output, come un file.

Ai fini abbiamo pensato possiamo usarlo, come in questo caso, dobbiamo ancora usare:

console.log(..); 

Oppure, se si vuole fare l'uscita abbastanza per gli oggetti:

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

Answer 2

Penso di avere un modo in cui potresti non ottenere esattamente quello che vuoi, 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 digerire da un server Express è più o meno auto-esplicativo:

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 si può scrivere quello che vuoi theAppLog e Morgan scriverà ciò che vuole nello stesso posto, utilizzando gli stessi appenders etc etc Ovviamente, è possibile chiamare info() o qualsiasi altra cosa nel wrapper di streaming anziché in debug(), che riflette solo il livello di registrazione che si desidera fornire alla registrazione req/res di Morgan.

Answer 3

Morgan non deve essere utilizzato per accedere nel modo in cui si sta descrivendo. Morgan è stato creato per fare il login nel modo in cui i server come Apache e Nginx si collegano a error_log o access_log. Per avere un riferimento, questo è il modo di utilizzare 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 si vede Morgan ha chiamato con una scelta hash {skip: ..., stream: __dirname + '/../morgan.log'}

La stream proprietà di tale oggetto determina dove le uscite logger. Di default è STDOUT (la tua console, proprio come vuoi) ma registra solo i dati delle richieste. Non farà ciò che fa console.log().

Se si vuole ispezionare le cose al volo utilizzare il costruito nel util libreria:

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

Quindi la risposta alla tua domanda è che si sta facendo la domanda sbagliata. Ma se vuoi comunque utilizzare Morgan per le richieste di registrazione, ecco fatto.

Answer 4

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

example nodejs + express + morgan

Answer 5

Ho affrontato lo stesso problema fa e invece, ho usato Winston. Come sopra detto, morgan è per la registrazione automatica di richiesta/risposta. Winston può essere configurato praticamente allo stesso modo come log4net/Log4J, ha livelli di gravità, torrenti diversi a cui è possibile accedere ecc

Ad esempio:

npm install winston

Quindi, se si chiama il codice qui sotto da qualche parte su di voi 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 sopra il codice, winston.loggers è vuoto, vale a dire che non hanno ancora alcun logger configurato. Proprio come i metodi Log4Net/J XmlConfigure - è necessario prima chiamarli, per avviare la registrazione.

Poi, più tardi, ovunque in voi codice lato server di applicazione che si può 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') 

Speranza che aiuta.

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

Answer 6

si potrebbe desiderare di provare a utilizzare 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 

Il risultato atteso è

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

} 

Answer 7

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

Per utilizzare Morgan, Abbiamo bisogno di seguire la procedura: -

1. Installare il morgan usando sotto comando:

npm install --save morgan

Questo aggiungerà Morgan per jason.package file di

2. Includi il morgan nel tuo progetto

var morgan = require('morgan');

3> // creare un flusso di scrittura (in modalità append)

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

Nota: Assicurarsi non è a piombo sopra ciecamente assicurarsi di avere ogni condizioni in cui è necessario .

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