middleware de morgan

Requisição de logger middleware HTTP para node.js

Named after Dexter, a show you should not watch until completion.

Instalação

Este é um módulo Node.js disponível através do registro do npm. A instalação é feita usando o comando npm install:

npm install morgan

morgan does not include its own TypeScript type definitions. If you use TypeScript, also install the community-maintained types from DefinitelyTyped as a development dependency:

npm install --save-dev @types/morgan

API

For ES Modules:

import morgan from 'morgan';

For CommonJS:

var morgan = require('morgan');

Crie uma nova função middleware de agente de login usando o formato e opções informados. O argumento format pode ser uma string de um nome predefinido (veja abaixo para os nomes), uma string de uma string de formato, ou uma função que produzirá uma entrada de log.

A função format será chamada com três argumentos tokens, req, e res, onde ‘tokens’ é um objeto com todos os tokens definidos, ‘req’ é a solicitação HTTP e ‘res’ é a resposta HTTP. Espera-se que a função retorne uma string que será a linha registro ou undefined / null para pular o log.

Usando uma string de formato predefinida

morgan('tiny');

Usando formato de string de tokens predefinidos

morgan(':method :url :status :res[content-length] - :response-time ms');

Usando uma função de formato personalizado

morgan(function (tokens, req, res) {
  return [
    tokens.method(req, res),
    tokens.url(req, res),
    tokens.status(req, res),
    tokens.res(req, res, 'content-length'),
    '-',
    tokens['response-time'](req, res),
    'ms',
  ].join(' ');
});

Opções

Morgan aceita essas propriedades no objeto de opções.

imediato

Escrever linha de log na solicitação em vez de resposta. This means that requests will be logged even if the server crashes, but data from the response (like the response code, content length, etc.) não pode ser logado.

Pular

Função para determinar se o log é ignorado, o padrão é false. Esta função será chamada como skip(req, res).

// EXAMPLE: only log error responses
morgan('combined', {
  skip: function (req, res) {
    return res.statusCode < 400;
  },
});

fluxo

Fluxo de saída para escrever linhas de log, padrão para process.stdout.

If the stream is in object mode (stream.writableObjectMode is true) and the format function returns an object, the object is written to the stream as-is, without a trailing newline. This allows passing structured log entries to loggers that accept objects:

morgan(
  function (tokens, req, res) {
    return {
      method: tokens.method(req, res),
      url: tokens.url(req, res),
      status: Number(tokens.status(req, res)),
    };
  },
  {
    stream: {
      writableObjectMode: true,
      write: function (entry) {
        // entry is the object returned by the format function
      },
    },
  }
);

Formatos predefinidos

Existem vários formatos predefinidos fornecidos:

combinado

Saída de log combinado padrão de Apache.

:remote-addr - :remote-user [:date[clf]] ":method :url HTTP/:http-version" :status :res[content-length] ":referrer" ":user-agent"
# will output
::1 - - [27/Nov/2024:06:21:42 +0000] "GET /combined HTTP/1.1" 200 2 "-" "curl/8.7.1"

comum

Saída de log comum padrão Apache.

:remote-addr - :remote-user [:date[clf]] ":method :url HTTP/:http-version" :status :res[content-length]
# will output
::1 - - [27/Nov/2024:06:21:46 +0000] "GET /common HTTP/1.1" 200 2

desenvolvedor

Saída concisa colorida pelo status de resposta para uso do desenvolvimento. O :status token será colorido verde para códigos de sucesso, vermelho para códigos de erro do servidor, amarelo para códigos de erro do cliente, cyan para códigos de redirecionamento e não coloridos para códigos de informação.

:method :url :status :response-time ms - :res[content-length]
# will output
GET /dev 200 0.224 ms - 2

Coloring is disabled when the NO_COLOR environment variable is set to any non-empty value, in which case the output above is written without any escape sequences. The variable is read once, when morgan is first required.

curto

Menor que o padrão, incluindo também o tempo de resposta.

:remote-addr :remote-user :method :url HTTP/:http-version :status :res[content-length] - :response-time ms
# will output
::1 - GET /short HTTP/1.1 200 2 - 0.283 ms

minúsculo

A saída mínima.

:method :url :status :res[content-length] - :response-time ms
# will output
GET /tiny 200 2 - 0.188 ms

Tokens

Criando novos tokens

Para definir um token, basta invocar morgan.token() com o nome e uma função de retorno de chamada. Esta função de callback é esperada para retornar um valor de string O valor retornado está disponível como “:type” neste caso:

morgan.token('type', function (req, res) {
  return req.headers['content-type'];
});

Chamando morgan.token() usando o mesmo nome que um token existente substituirá que a definição do token.

Espera-se que a função de token seja chamada com os argumentos req e res, representando a solicitação HTTP e a resposta HTTP. Additionally, the token can accept further arguments of its choosing to customize behavior.

:date[format]

A data e hora atuais em UTC. Os formatos disponíveis são:

clf para o formato comum de log ("10/Oct/2000:13:55:36 +0000")
iso para o formato de data comum ISO 8601 (2000-10-10T13:55:36.000Z)
web para o formato comum de data RFC 1123 (Ter, 10 outubro de 2000 13:55:36 GMT)

Se nenhum formato é dado, então o padrão é web.

:http-versão

A versão HTTP da solicitação.

O método HTTP do pedido.

O ID do processo do Node.js lidando com a solicitação.

O cabeçalho do Referrer da solicitação. This will use the standard mis-spelled Referer header if it exists, otherwise Referrer.

:remote-addr

O endereço remoto da solicitação. Isto usará o valor req.ip, caso contrário o valor padrão req.connection.remoteAddress (endereço socket).

:remote-usuário

O usuário autenticado como parte da autenticação básica para a solicitação.

:req[header]

O cabeçalho dado da solicitação. Se o cabeçalho não estiver presente, o valor será exibido como "-" no log.

:res[header]

O cabeçalho dado da resposta. Se o cabeçalho não estiver presente, o valor será exibido como "-" no log.

:response-time[digits]

O tempo entre a solicitação chegando em morgan e quando os cabeçalhos de resposta são escritos, em milissegundos.

O argumento dígitos é um número que especifica o número de dígitos a incluir no número, por padrão até 3, que fornece precisão de microsegundos.

O código de status da resposta.

Se o ciclo de solicitação/resposta completar antes de uma resposta ser enviada para o cliente (por exemplo, o soquete TCP fechou prematuramente por um cliente abortando o pedido), em seguida, o status estará vazio (exibido como "-" no log).

:total-tempo[digits]

O tempo entre o pedido chegando em morgan e quando a resposta terminou de ser escrita para a conexão, em milissegundos.

O argumento dígitos é um número que especifica o número de dígitos a incluir no número, por padrão até 3, que fornece precisão de microsegundos.

A URL da solicitação. This will use req.originalUrl if it exists, otherwise req.url.

:user-agent

O conteúdo do cabeçalho User-Agent da solicitação.

morgan.compile(formato)

Compilar uma string de formato em uma função format para usar por morgan. Uma string de formato é uma string que representa uma única linha de log e pode utilizar a sintaxe do token. Tokens are referenced by :token-name. If tokens accept arguments, they can be passed using [], for example: :token-name[pretty] would pass the string 'pretty' as an argument to the token token-name.

The function returned from morgan.compile takes three arguments tokens, req, and res, where tokens is an object with all defined tokens, req is the HTTP request and res is the HTTP response. A função retornará uma string que será a linha de log, ou undefined / null para pular o log.

Normally formats are defined using morgan.format(name, format), but for certain advanced uses, this compile function is directly available.

Exemplos

expressão/conexão

Sample app that will log all requests in the Apache combined format to STDOUT

var express = require('express');
var morgan = require('morgan');

var app = express();

app.use(morgan('combined'));

app.get('/', function (req, res) {
  res.send('hello, world!');
});

servidor http vanilla

Sample app that will log all requests in the Apache combined format to STDOUT

var finalhandler = require('finalhandler');
var http = require('http');
var morgan = require('morgan');

// create "middleware"
var logger = morgan('combined');

http.createServer(function (req, res) {
  var done = finalhandler(req, res);
  logger(req, res, function (err) {
    if (err) return done(err);

    // respond to request
    res.setHeader('content-type', 'text/plain');
    res.end('hello, world!');
  });
});

escrever logs em um arquivo

arquivo único

O aplicativo de exemplo que registrará todas as solicitações no formato combinado do Apache para o arquivo access.log.

var express = require('express');
var fs = require('fs');
var morgan = require('morgan');
var path = require('path');

var app = express();

// create a write stream (in append mode)
var accessLogStream = fs.createWriteStream(path.join(__dirname, 'access.log'), { flags: 'a' });

// setup the logger
app.use(morgan('combined', { stream: accessLogStream }));

app.get('/', function (req, res) {
  res.send('hello, world!');
});

rotação do arquivo de log

Aplicativo de exemplo que registrará todas as solicitações no formato combinado do Apache em um arquivo de log por dia no diretório log/ usando o rotating-file-stream module.

var express = require('express');
var morgan = require('morgan');
var path = require('path');
var rfs = require('rotating-file-stream'); // version 2.x

var app = express();

// create a rotating write stream
var accessLogStream = rfs.createStream('access.log', {
  interval: '1d', // rotate daily
  path: path.join(__dirname, 'log'),
});

// setup the logger
app.use(morgan('combined', { stream: accessLogStream }));

app.get('/', function (req, res) {
  res.send('hello, world!');
});

dividir / dual log

O middleware morgan pode ser usado quantas vezes for necessário, permitindo combinações como:

Registrar a entrada a pedido e uma na resposta
Registrar todas as requisições em arquivo, mas erros no console
… e mais!

Aplicativo de exemplo que registrará todas as solicitações em um arquivo usando o formato Apach, mas as respostas de erros são registradas no console:

var express = require('express');
var fs = require('fs');
var morgan = require('morgan');
var path = require('path');

var app = express();

// log only 4xx and 5xx responses to console
app.use(
  morgan('dev', {
    skip: function (req, res) {
      return res.statusCode < 400;
    },
  })
);

// log all requests to access.log
app.use(
  morgan('common', {
    stream: fs.createWriteStream(path.join(__dirname, 'access.log'), { flags: 'a' }),
  })
);

app.get('/', function (req, res) {
  res.send('hello, world!');
});

use formatos de token personalizados

Exemplo de aplicativo que usará formatos de token personalizados. Isso adiciona um ID a todos os pedidos e exibe usando o token :id.

var express = require('express');
var morgan = require('morgan');
var uuid = require('uuid');

morgan.token('id', function getId(req) {
  return req.id;
});

var app = express();

app.use(assignId);
app.use(morgan(':id :method :url :response-time'));

app.get('/', function (req, res) {
  res.send('hello, world!');
});

function assignId(req, res, next) {
  req.id = uuid.v4();
  next();
}

Tipo:

MIT