Os 4 principais pacotes para registro no Node.js

O registro adequado é um aspecto crítico da criação e manutenção de aplicativos da Web funcionais. Ele pode ajudá-lo a rastrear erros, diagnosticar problemas de desempenho e entender como os usuários interagem com seu aplicativo.

O Node.js tem muitos pacotes de log para ajudá-lo a criar e gerenciar logs estruturados. Aqui você explorará os principais pacotes de registro atualmente disponíveis no ecossistema Node.js e como usá-los.

1. Winston

Winston é uma biblioteca Node.js que fornece funcionalidade de registro flexível, incluindo vários transportes. Um “transporte” é um meio de armazenamento para seus logs.

Winston suporta transportes de console, arquivo e rede. Isso significa que você pode imprimir seus logs no console, gravá-los em um arquivo ou enviá-los por uma rede. Usando os níveis de log do Winston, você pode criar transportes personalizados e filtrar logs com base na gravidade.

Você pode instalar o Winston como uma dependência no diretório do seu projeto usando npm, o gerenciador de pacotes JavaScript. Execute este comando:

npm instalar winston

O bloco de código abaixo demonstra como configurar um sistema de registro básico usando o Winston. Você pode definir logs para diferentes locais e níveis variados de gravidade.

const Winston = exigir("winston");
// Registrador Winston
const logger = winston.createLogger({
 nível: 'informações',
 formato: winston.format.json(),
 padrãoMeta: { serviço: 'meu-serviço' },
 transportes: [
novo winston.transports. Console(),
novo winston.transports. Arquivo({ nome do arquivo: 'error.log', nível: 'erro' }),
novo winston.transports. Arquivo({ nome do arquivo: 'combined.log' })
 ]
});
logger.info('Olá, Winston!');
logger.warn('Aviso: Algo pode estar errado.');
logger.error('Um erro ocorreu.');

Este código configura um logger com três transportes. O primeiro é um transporte de console, que enviará mensagens de log para o console. O segundo é um transporte de arquivo que gravará logs com um nível de "error" em um arquivo "error.log". O terceiro é um transporte de arquivo que gravará todos os logs em um arquivo "combined.log".

O logger é configurado para registrar no nível "info" por padrão e inclui um objeto de metadados padrão com um campo "service" definido como "my-service".

O código então registra três mensagens usando o logger nos níveis "info", "aviso" e "erro", respectivamente. Essas mensagens serão enviadas para o console e os arquivos de log apropriados de acordo com a configuração dos transportes.

2. Morgan

Morgan é um middleware de log para Node.js que fornece recursos básicos de log de solicitação. Ele foi projetado para ser leve e fácil de usar. Morgan funciona interceptando solicitações HTTP e registrando informações relevantes, como método de solicitação, URL, código de status, etc.

Um dos principais benefícios do Morgan é sua simplicidade. Você pode adicioná-lo a um aplicativo Node.js com algumas linhas de código, pois não requer nenhuma configuração adicional para configurar.

Morgan oferece suporte a vários formatos de registro, incluindo o comum, combinado, curto, pequeno, e desenvolvedor formatos, permitindo que você escolha aquele que melhor se adapta às suas necessidades.

Você pode instalar o Morgan como uma dependência no diretório do seu projeto executando este comando:

npm instalar morgan

Este código mostra como usar Morgan em um aplicativo expresso:

const expresso = exigir("expressar");
const morgan = exigir("morgan");
const aplicativo = expresso();
app.use (morgan("desenvolvimento"));
app.get("/", (req, res) => {
 res.enviar("Olá Mundo!");
});
app.listen(3000, () => console.registro(`Aplicativo iniciado`));

O código inicializa Morgan usando o desenvolvedor formatar. Quando você faz uma solicitação GET para a rota raiz (/), Morgan registra os detalhes dessa solicitação no console.

Apesar de sua simplicidade, o Morgan é um poderoso pacote de registro que fornece recursos essenciais de registro de solicitação para aplicativos Node.js.

3. pino

Pino é um pacote de registro popular e leve para aplicativos Node.js que oferece desempenho rápido e baixo overhead, conforme indicado em seus benchmarks.

O Pino oferece suporte a vários tipos de transporte, facilmente estendidos com transportes personalizados. Um dos principais recursos do Pino é sua capacidade de registrar mensagens formatadas em JSON, o que as torna fáceis de analisar e analisar.

O uso do Pino varia dependendo da estrutura do Node.js; você pode instalar o Pino como uma dependência no diretório do seu projeto Express executando o comando abaixo:

npm install pino-http

Para estruturas diferentes, verifique o Documentação Pino.

Este bloco de código mostra o uso do Pino em um aplicativo Express:

const expresso = exigir("expressar");
const aplicativo = expresso();
const pino = exigir('pino-http')()
app.use (pino)
app.get("/", (req, res) => {
 pino (req, res) // registra requisição e resposta
 req.log.info('rota raiz') // registra informações adicionais
 res.enviar("Olá Mundo!");
});
app.listen(3000, () => console.registro(`Aplicativo iniciado`));

Este código inicializa o Pino e o registra como middleware. Quando você faz uma solicitação GET para a rota raiz (/), Pino registra os detalhes de sua solicitação e sua resposta no console.

4. Depurar

Debug é um pacote de registro para Node.js modelado de acordo com a técnica de depuração do núcleo do Node.js. Ele fornece uma solução de log leve que permite habilitar ou desabilitar o log seletivamente sem modificar o código, facilitando a depuração e a solução de problemas.

A depuração também permite que você defina namespaces de log, que fornecem uma estrutura hierárquica para seus logs com base nos componentes e módulos em seu aplicativo, tornando mais fácil filtrá-los e pesquisá-los. Além disso, o Debug oferece vários níveis de log, como erro, aviso e informações, que você pode usar para priorizar e filtrar seus logs.

Você pode instalar o Debug como uma dependência no diretório do seu projeto com este comando:

npm instalar depuração

Este código mostra o uso do Debug em um aplicativo Express:

const expresso = exigir('expressar');
// Importar depurar e criar namespace
const depurar = exigir('depurar')('meuaplicativo: servidor');
const aplicativo = expresso();
const port = process.env. PORTO || 3000;
app.get('/', (req, res) => {
 depurar('Pedido recebido para /');
 res.enviar('Olá Mundo!');
});
app.listen (porta, () => {
 depurar(`Servidor escutando na porta ${porta}`);
});

O código cria um namespace, meuaplicativo: servidor. Este namespace irá distinguir logs relacionados ao seu “servidor” daqueles associados a outros módulos com um namespace diferente em seu aplicativo.

Execute este comando para iniciar o debug:

DEBUG=meuaplicativo:* nó server.js

Este comando acima corresponderá a qualquer mensagem de log com um namespace que comece com meuaplicativo:. Se você deseja apenas ver os logs relacionados ao seu servidor módulo, você pode definir o DEPURAR variável de ambiente para meuaplicativo: servidor.

Outra vantagem do Debug é sua compatibilidade com outros pacotes de registro, como o Winston.

Escolhendo um pacote de registro

A escolha de um pacote de log é uma decisão importante que pode afetar significativamente a eficiência e a eficácia do processo de depuração. É essencial considerar fatores como os recursos e capacidades do pacote, sua compatibilidade com sua linguagem de programação e ambiente de desenvolvimento, e sua facilidade de uso e configuração.

Por fim, a escolha do pacote de registro dependerá das necessidades e requisitos específicos do seu projeto.