Como usar o logger Morgan?

Não consigo entrar com Morgan. Ele não registra informações no console. A documentação não diz como usá-lo.

Eu quero ver o que é uma variável. Este é um código do response.jsarquivo do 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);
};

Como usar o Morgan?

Parece que você também está confuso com a mesma coisa que eu, a razão pela qual tropecei nessa questão. Acho que associamos o log com o log manual, como faríamos em Java com log4j (se você conhece java), onde instanciamos um Logger e dizemos log 'this'.

Então eu cavei no código Morgan, descobri que não é esse tipo de logger, é para registro automatizado de solicitações, respostas e dados relacionados. Quando adicionado como um middleware a um aplicativo express / connect, por padrão, ele deve registrar declarações para stdout mostrando detalhes de: ip remoto, método de solicitação, versão de http, status de resposta, agente de usuário etc. Ele permite que você modifique o log usando tokens ou adicione cor a eles definindo 'dev' ou até mesmo efetuando logout em um fluxo de saída, como um arquivo.

Para o efeito pensamos que podemos usá-lo, pois neste caso, ainda temos que usar:

console.log(..);

Ou se quiser tornar a saída bonita para objetos:

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

Acho que tenho uma maneira de você não conseguir exatamente o que deseja, mas pode integrar o registro do Morgan com o log4js - em outras palavras, toda a sua atividade de registro pode ir para o mesmo lugar. Espero que este resumo de um servidor Express seja mais ou 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);

Agora você pode escrever o que quiser no AppLog e Morgan escreverá o que quiser no mesmo lugar, usando os mesmos appenders etc. etc. Claro, você pode chamar info () ou o que quiser no wrapper de fluxo em vez de debug () - isso apenas reflete o nível de registro que você deseja fornecer ao registro req / res do Morgan.

Morgan não deve ser usado para fazer login da maneira que você está descrevendo. Morgan foi construído para fazer log da maneira que servidores como Apache e Nginx logam no error_log ou access_log. Para referência, é assim que você 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'));
}

Observe a linha de produção onde você vê Morgan chamado com um hash de opções {skip: ..., stream: __dirname + '/../morgan.log'}

A streampropriedade desse objeto determina para onde o logger sai. Por padrão, é STDOUT (seu console, como você deseja), mas registrará apenas os dados da solicitação. Não vai fazer o que console.log()faz.

Se você deseja inspecionar as coisas em tempo real, use a utilbiblioteca integrada :

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

Portanto, a resposta à sua pergunta é que você está fazendo a pergunta errada. Mas se você ainda quiser usar o Morgan para solicitações de registro, pronto.

Eu enfrentei o mesmo problema atrás e, em vez disso, usei o winston. Como disseram os companheiros acima, Morgan é para registro automatizado de solicitação / resposta. O Winston pode ser configurado praticamente da mesma forma que log4Net / log4J, tem níveis de gravidade, diferentes fluxos nos quais você pode registrar etc.

Por exemplo:

npm install winston

Então, se você chamar o código abaixo em algum lugar na inicialização do aplicativo:

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 chamar o código acima, winston.loggers está vazio, ou seja, você ainda não tem nenhum logger configurado. Muito parecido com os métodos Log4Net / J XmlConfigure - você precisa primeiro chamá-los, para iniciar seu registro.

Então, mais tarde, em qualquer lugar em seu código do lado do servidor de aplicativos, você pode fazer:

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 ajude.

para referência de documentação adicional: https://www.npmjs.com/package/winston

Morgan: - Morgan é um middleware que nos ajudará a identificar os clientes que estão acessando nosso aplicativo. Basicamente, um logger.

Para usar o Morgan, precisamos seguir as etapas abaixo: -

1. Instale o Morgan usando o comando abaixo:

npm install --save morgan

Isso adicionará morgan ao arquivo json.package

2. Inclua o Morgan no seu projeto

var morgan = require('morgan');

3> // criar um fluxo de gravação (no modo anexar)

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

Nota: Certifique-se de não fazer a sondagem acima às cegas, certifique-se de ter todas as condições de que precisa.

Acima irá criar automaticamente um arquivo access.log para sua raiz assim que o usuário acessar seu aplicativo.

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

exemplo nodejs + express + morgan

No meu 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 - -"

CORREÇÃO: Eu estava usando o código do Visual Studio e tive que adicionar isso ao meu Launch Config

"outputCapture": "std"

Sugestão, caso você esteja executando a partir de um IDE, execute diretamente a partir da linha de comando para ter certeza de que o IDE não está causando o problema.

Você pode querer tentar usar mongo-morgan-ext

O uso é:

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

A saída esperada é

{
    "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 é bastante simples. Como a documentação sugere, existem diferentes maneiras de obter a saída desejada com Morgan. Ele vem com métodos de registro pré-configurados ou você mesmo pode definir um. Por exemplo.

const morgan = requer ('morgan')

app.use (morgan ('minúsculo')

Isso lhe dará a pré-configuração chamada tiny. Você notará em seu terminal o que ele faz. Caso você não esteja satisfeito com isso e queira mais detalhes, por exemplo, digamos, o URL do pedido, então é aqui que entram os tokens.

morgan.token ('url', função (req, res) {return '/ api / myendpoint'})

em seguida, use-o assim:

app.use (morgan (': url')

Confira a documentação toda destacada lá.