O registro em log é uma parte crucial de qualquer aplicativo, fornecendo insights sobre o comportamento do aplicativo, ajudando a depurar problemas e monitorando o desempenho. Em uma API Node.js, o registro avançado pode ser obtido usando bibliotecas como Winston e Morgan. Este artigo irá guiá-lo na configuração e uso de Winston e Morgan para registro avançado em uma API Node.js.

Por que o registro avançado é necessário
O registro avançado é essencial por vários motivos:

• Depuração e solução de problemas: os logs fornecem um histórico detalhado de eventos do aplicativo, o que é inestimável ao diagnosticar problemas. Eles ajudam a identificar a causa raiz dos erros e a compreender a sequência de ações que levam a um problema.

• Monitoramento e manutenção: O monitoramento contínuo de logs permite que os desenvolvedores rastreiem a integridade e o desempenho do aplicativo. Ao analisar os registros, você pode detectar anomalias, gargalos de desempenho e possíveis problemas antes que se tornem críticos.

• Auditoria e Conformidade: Para muitas aplicações, especialmente aquelas que lidam com dados confidenciais, manter registros detalhados é um requisito de conformidade. Os logs fornecem um registro das ações do usuário e alterações do sistema, o que pode ser crítico para auditorias e conformidade regulatória.

• Segurança: registrar eventos relacionados à segurança, como tentativas de login malsucedidas, acesso não autorizado e atividades suspeitas, é crucial para detectar e responder a ameaças à segurança. O registro avançado ajuda a manter um ambiente de aplicativo seguro.

Índice

1. Introdução a Winston e Morgan
2. Configurando um projeto Node.js
3. Instalando Winston e Morgan
4. Configurando Winston para registro avançado
5. Integração do Morgan para registro de solicitações HTTP
6. Combinando Winston e Morgan
7. Personalização de formatos de registro
8. Registro em diferentes transportes
9. Tratamento e registro de erros
10. Conclusão

1.Introdução a Winston e Morgan
Winston é uma biblioteca de registro versátil e fácil de usar para Node.js. Ele suporta vários transportes para mensagens de log, o que significa que você pode registrar em diferentes locais (console, arquivos, servidores remotos, etc.) com vários formatos e níveis.

Morgan é um middleware registrador de solicitações HTTP para Node.js. Ele simplifica o registro de solicitações HTTP em um formato predefinido, o que pode ser muito útil para rastrear solicitações e respostas recebidas em uma API.

2.Configurando um projeto Node.js
Primeiro, crie um novo projeto Node.js se ainda não tiver um:

mkdir node-api-logging
cd node-api-logging
npm init -y

3.Instalando Winston e Morgan
Instale Winston e Morgan junto com Express (para configurar uma API básica):

npm install express winston morgan

4.Configurando Winston para registro avançado
Crie um arquivo logger.js para configurar o Winston:

// logger.js
const { createLogger, format, transports } = require('winston');
const { combine, timestamp, printf, errors } = format;

const customFormat = printf(({ level, message, timestamp, stack }) => {
  return `${timestamp} ${level}: ${stack || message}`;
});

const logger = createLogger({
  level: 'info',
  format: combine(
    timestamp(),
    errors({ stack: true }),
    customFormat
  ),
  transports: [
    new transports.Console(),
    new transports.File({ filename: 'logs/error.log', level: 'error' }),
    new transports.File({ filename: 'logs/combined.log' })
  ]
});

module.exports = logger;

5. Integração do Morgan para registro de solicitações HTTP
Crie um arquivo middleware/logger.js para integrar Morgan com Winston:

// middleware/logger.js
const morgan = require('morgan');
const logger = require('../logger');

const stream = {
  write: (message) => logger.info(message.trim())
};

const morganMiddleware = morgan('combined', { stream });

module.exports = morganMiddleware;

6.Combinando Winston e Morgan
Integre Winston e Morgan em seu aplicativo Express:

// app.js
const express = require('express');
const logger = require('./logger');
const morganMiddleware = require('./middleware/logger');

const app = express();

// Use Morgan middleware for HTTP request logging
app.use(morganMiddleware);

// Example route
app.get('/', (req, res) => {
  logger.info('Hello world endpoint was called');
  res.send('Hello, world!');
});

// Error handling middleware
app.use((err, req, res, next) => {
  logger.error(err.message, { stack: err.stack });
  res.status(500).send('Something went wrong!');
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  logger.info(`Server is running on port ${PORT}`);
});

7.Personalização de formatos de registro
Você pode personalizar os formatos de registro em Winston e Morgan. Por exemplo, você pode querer registrar detalhes adicionais da solicitação, como cabeçalhos, parâmetros de consulta ou tempos de resposta.

8.Registro em diferentes transportes
Winston oferece suporte a vários transportes. Você pode registrar em destinos diferentes com base na gravidade das mensagens. Por exemplo, você pode querer enviar logs de erros para um servidor de registro remoto ou um serviço de terceiros como Loggly ou Papertrail.

9. Tratamento e registro de erros
O tratamento e registro de erros adequados são essenciais para identificar e resolver problemas. Certifique-se de que seu middleware de tratamento de erros registre informações detalhadas de erro usando Winston.

10.Conclusão
Ao combinar Winston e Morgan, você pode obter log avançado em sua API Node.js. Winston fornece uma estrutura robusta para registrar eventos em nível de aplicativo, enquanto Morgan simplifica o registro de solicitações HTTP. Juntos, eles fornecem uma solução de registro abrangente que aprimora sua capacidade de monitorar e depurar seu aplicativo.

Visão geral do código final
Aqui está uma rápida recapitulação dos arquivos e seu conteúdo:

• logger.js: configura Winston com formatação e transportes personalizados.
• middleware/logger.js: Integra Morgan com Winston.
• app.js: configura o aplicativo Express, integrando Winston e Morgan. Com esta configuração, você pode registrar e monitorar efetivamente sua API Node.js, facilitando a manutenção e a depuração.