¿Cómo utilizar Morgan Logger?

No puedo iniciar sesión con Morgan. No registra información en la consola. La documentación no dice cómo usarlo.

Quiero ver qué es una variable. Este es un código del response.jsarchivo del marco 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);
};

¿Cómo usar Morgan?

Parece que tú también estás confundido con lo mismo que yo, la razón por la que me topé con esta pregunta. Creo que asociamos el registro con el registro manual como lo haríamos en Java con log4j (si conoce Java), donde instanciamos un registrador y decimos log 'esto'.

Luego indagué en el código morgan, resulta que no es ese tipo de registrador, es para el registro automático de solicitudes, respuestas y datos relacionados. Cuando se agrega como un middleware a una aplicación express / connect, de manera predeterminada debe registrar declaraciones en stdout mostrando detalles de: ip remota, método de solicitud, versión http, estado de respuesta, agente de usuario, etc. Le permite modificar el registro usando tokens o agrégueles color definiendo 'dev' o incluso cerrando sesión en un flujo de salida, como un archivo.

Para el propósito que pensamos que podemos usarlo, como en este caso, todavía tenemos que usar:

console.log(..);

O si desea que la salida sea bonita para los objetos:

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

Creo que tengo una forma en la que es posible que no obtenga exactamente lo que desea, pero puede integrar el registro de Morgan con log4js; en otras palabras, toda su actividad de registro puede ir al mismo lugar. Espero que este resumen de un servidor Express sea más o menos autoexplicativo:

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

Ahora puede escribir lo que quiera en el AppLog y Morgan escribirá lo que quiera en el mismo lugar, usando los mismos añadidos, etc. Por supuesto, puede llamar a info () o lo que quiera en el contenedor de flujo en lugar de debug () - que solo refleja el nivel de registro que desea dar al registro de req / res de Morgan.

Morgan no debe usarse para iniciar sesión de la manera que está describiendo. Morgan fue construido para realizar el registro de la misma manera que los servidores como Apache y Nginx registran el error_log o el access_log. Como referencia, así es como se usa 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'));
}

Tenga en cuenta la línea de producción donde ve a Morgan llamado con un hash de opciones {skip: ..., stream: __dirname + '/../morgan.log'}

La streampropiedad de ese objeto determina dónde sale el registrador. De forma predeterminada, es STDOUT (su consola, tal como lo desea) pero solo registrará los datos de solicitud. No va a hacer lo que console.log()hace.

Si desea inspeccionar cosas sobre la marcha, use la utilbiblioteca incorporada :

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

Entonces, la respuesta a tu pregunta es que estás haciendo la pregunta incorrecta. Pero si aún desea utilizar Morgan para registrar solicitudes, ya está.

Enfrenté el mismo problema hace y, en su lugar, usé winston. Como los muchachos dijeron anteriormente, Morgan es para el registro automático de solicitudes / respuestas. Winston se puede configurar casi de la misma manera que log4Net / log4J, tiene niveles de gravedad, diferentes flujos en los que puede iniciar sesión, etc.

Por ejemplo:

npm install winston

Luego, si llama al siguiente código en algún lugar de la inicialización de su aplicación:

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: antes de llamar al código anterior, winston.loggers está vacío, es decir, aún no ha configurado ningún registrador. Al igual que los métodos Log4Net / J XmlConfigure: primero debe llamarlos para iniciar su registro.

Luego, más tarde, en cualquier lugar del código del lado del servidor de aplicaciones, puede hacer:

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

Espero que ayude.

para obtener más referencias de documentación: https://www.npmjs.com/package/winston

Morgan: - Morgan es un middleware que nos ayudará a identificar a los clientes que acceden a nuestra aplicación. Básicamente un registrador.

Para utilizar Morgan, debemos seguir los pasos a continuación: -

1. Instale el morgan usando el siguiente comando:

npm install --save morgan

Esto agregará morgan al archivo json.package

2. Incluye morgan en tu proyecto

var morgan = require('morgan');

3> // crea una secuencia de escritura (en modo adjuntar)

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

Nota: asegúrese de no aplomar arriba a ciegas, asegúrese de tener todas las condiciones donde lo necesite.

Lo anterior creará automáticamente un archivo access.log en su raíz una vez que el usuario acceda a su aplicación.

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

ejemplo nodejs + express + morgan

En mi 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 - -"

REVISIÓN: Estaba usando el código de Visual Studio y tuve que agregar esto a mi configuración de inicio

"outputCapture": "std"

Sugerencia, en caso de que esté ejecutando desde un IDE, hágalo directamente desde la línea de comandos para asegurarse de que el IDE no esté causando el problema.

Es posible que desee intentar usar mongo-morgan-ext

El uso es:

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

La salida esperada es

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

}

Usar Morgan es bastante sencillo. Como sugiere la documentación , hay diferentes formas de obtener el resultado deseado con morgan. Viene con métodos de registro preconfigurados o puede definir uno usted mismo. P.ej.

const morgan = require ('morgan')

app.use (morgan ('diminuto')

Esto le dará la preconfiguración llamada tiny. Notarás en tu terminal lo que hace. En caso de que no esté satisfecho con esto y desee más información, por ejemplo, digamos la URL de solicitud, entonces aquí es donde entran los tokens.

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

luego úsalo así:

app.use (morgan (': url')

Verifique la documentación que está resaltada allí.