Este blog discutirá o valor de utilizar bibliotecas de registro e analisará as 10 ferramentas de registro mais bem avaliadas que encontramos para Node.js. No @playerzero, usamos as bibliotecas de registro node.js com frequência para criar e gerenciar eventos de registro. Saiba mais sobre como estamos trazendo nossa abordagem exclusiva para monitorar o que importa para aplicativos front-end e back-end hoje https://www.playerzero.app/

• pino

• Winston

• Bunyan

• Morgan

• Loglevel

• Log4js

• Npmlog

• rugido

• Marcador

• sinal

  
  

De uma perspectiva de alto nível, o log do Node.js é importante porque ajuda os desenvolvedores a rastrear os eventos e o desempenho de seus aplicativos, diagnosticar e corrigir problemas, monitorar o comportamento do sistema e tomar decisões informadas. O registro fornece um registro da atividade de um aplicativo, permitindo que os desenvolvedores identifiquem e depurem problemas, entendam o comportamento do usuário e melhorem o desempenho geral e a estabilidade do sistema. O log também pode ser útil em ambientes de produção para detectar e corrigir erros, monitorar o desempenho do sistema e detectar incidentes de segurança.

Registro versus rastreamento

Sempre que algo dá muito errado em um aplicativo, os desenvolvedores têm a opção de rastrear sua origem por meio de um rastreamento de pilha. Mas… confiar apenas em rastreamentos de pilha apenas pinta metade de uma imagem. O rastreamento fornecerá informações sobre a execução de um aplicativo, incluindo o fluxo de solicitações, consultas ao banco de dados, chamadas de API externas e métricas de desempenho - o que pode ser bastante útil. Em geral, os traces são usados para entender o comportamento de um aplicativo em um nível granular e para identificar gargalos de desempenho.

O registro preenche a outra metade da imagem. Logging é o processo de registrar mensagens e eventos relacionados a um aplicativo, como erros, avisos, métricas de desempenho e informações de depuração. O login no Node.js é usado para diagnosticar problemas, entender o comportamento do usuário e melhorar o desempenho geral e a estabilidade de um aplicativo. Ele também fornece um registro da atividade em um aplicativo, permitindo que os desenvolvedores identifiquem e depurem problemas e tomem decisões mais informadas.

Por que usar bibliotecas de registro para Node.js?

Há vários motivos pelos quais você deve usar as bibliotecas de registro Node.js:

1. Depuração aprimorada - as bibliotecas de registro fornecem informações detalhadas sobre erros e problemas, permitindo que os desenvolvedores diagnostiquem e corrijam problemas com mais eficiência.
2. Visibilidade aprimorada - o registro fornece uma visão clara do comportamento e desempenho de um aplicativo, permitindo que os desenvolvedores tomem decisões informadas e melhorem o sistema.
3. Melhor desempenho - as bibliotecas de registro podem ser otimizadas para desempenho, reduzindo a sobrecarga do registro e melhorando o desempenho geral do sistema.
4. Log centralizado - muitas bibliotecas de log permitem que os logs sejam gravados em um servidor de log centralizado, facilitando a coleta, visualização e análise de dados de log.
5. Personalização - as bibliotecas de registro podem ser personalizadas para atender a necessidades específicas, como níveis de registro personalizados, formatos de saída e filtros.

Níveis de registro

Os níveis de log são uma maneira de categorizar a importância ou a gravidade das mensagens de log. Normalmente, existem vários níveis, variando de erros críticos a mensagens informativas, e cada nível é associado a um valor numérico que pode ser usado para filtrar mensagens de log em uma biblioteca. Aqui estão os níveis mais comuns:

nível de registro FATAL

Talvez sem surpresa, o nível de log FATAL é um nível de gravidade que indica um erro crítico em um aplicativo - o que significa que os logs com um nível FATAL indicam que o aplicativo não pode continuar a funcionar normalmente sem a intervenção do desenvolvedor.

Nível de log ERROR

O nível de log ERROR indica que um aplicativo pode ser executado no momento, MAS está encontrando um problema. Normalmente, isso indica que uma tarefa necessária no aplicativo falhou - que houve uma exceção, comportamento inesperado ou entradas incorretas.

nível de registro WARN

WARN é um nível de log menos grave que ERROR , mas, mesmo assim, não deve ser ignorado. Os logs WARN podem ser usados para identificar problemas proativamente e evitar que os problemas se tornem mais graves, pois indicam que algo em seu aplicativo pode se tornar um catalisador para um problema mais significativo.

nível de registro INFO

O nível de log INFO é um tipo de mensagem de log usada em sistemas de log para indicar uma mensagem informativa geral. Geralmente é usado para registrar rotina, eventos esperados no aplicativo ou sistema, como o início de um processo, a conclusão de uma tarefa ou uma alteração no estado do sistema. Esses alertas geralmente podem ser ignorados, pois servem para confirmar que um aplicativo está funcionando corretamente.

nível de registro DEBUG

Normalmente, o nível de log DEBUG fornece informações úteis estritamente no processo de depuração. Os logs DEBUG são o tipo mais detalhado de mensagem de log e fornecem uma visão granular do funcionamento interno de um aplicativo. O principal objetivo dos logs DEBUG é ajudar os desenvolvedores a entender o que o sistema está fazendo, identificar bugs e problemas e diagnosticar problemas.

10 melhores bibliotecas de registro Node.js e como começar a usá-las

#1. pino

Benefícios do Pino

Pino é uma ferramenta de registro muito popular e estabelecida há muito tempo, com mais de 10,9 mil estrelas do Github e milhões de downloads no npm. Pino é uma biblioteca de registro popular para Node.js porque fornece vários recursos importantes que a tornam adequada para uso em aplicativos Node.js:

• Fast - Pino é projetado para ser rápido e leve, com foco no desempenho. Ele usa um formato binário para mensagens de log, o que permite gerar saída de log de forma rápida e eficiente.

• Logs estruturados - Pino registra mensagens no formato JSON, o que permite fácil análise, filtragem e análise de dados de log. Isso torna mais fácil pesquisar, visualizar e analisar dados de log e integrar dados de log em outros sistemas.

• Fácil de estender - Pino foi projetado para ser altamente extensível e inclui vários plug-ins integrados que podem ser usados para adicionar funcionalidades adicionais, como gravar dados de log em um arquivo ou enviar dados de log para um servidor remoto.

• Baixa sobrecarga - Pino é uma biblioteca de registro Node.js altamente eficiente devido à sua utilização mínima de recursos. O processo de registro com o Pino acumula mensagens gradativamente, levando a um estrangulamento do aplicativo e a uma diminuição do número de solicitações por segundo. A limitação é uma técnica em que a função conectada a um evento é acionada para ser executada apenas uma vez dentro de um período de tempo especificado, mesmo que o evento seja acionado várias vezes.

• Transportes - Pino oferece uma variedade de opções para enviar logs, incluindo gravação em arquivos, exibição no console e utilização de plataformas como Sentry, Azure Application Insights e CouchDB.

  
  

Para usar o Pino em um aplicativo Node.js, siga estas etapas:

Instalando Pino

Para instalar o Pino, basta instalá-lo executando o seguinte comando em um novo diretório:

 npm install pino

Importar - em seu aplicativo Node.js, importe Pino adicionando a seguinte linha de código na parte superior do arquivo:

 const pino = require('pino');

Usando Pino

Inicialização - inicialize o Pino criando uma instância do logger, por exemplo:

 const logger = pino({ level: 'info' });

Este script produz logs com um nível de log de INFO e superior no console.

Ao definir o nível para info, Pino registrará mensagens com um nível de registro de INFO , WARN , ERROR e FATAL . Mensagens com um nível de registro abaixo INFO , como DEBUG , não serão registradas.

Esse código cria apenas uma instância do registrador Pino com o nível de log definido como INFO. Nenhuma mensagem de log é gerada ou exibida até que você registre algo usando a instância do criador de logs. Por exemplo:

 logger.info('This is an info message');

Isso produziria a seguinte saída no console:

 {"level":30,"time":1624825088703,"msg":"This is an info message","pid":1234,"hostname":"my-machine"}

Os dados registrados exibidos no console incluem o nível de registro, o registro de data e hora em que foi registrado, a mensagem sendo registrada, um identificador para o registro e o nome do host.

Logging - você também pode usar a instância logger para registrar outras mensagens em seu aplicativo. Por exemplo:

 logger.warn('This is a warning message'); logger.error('This is an error message');

Saída - por padrão, Pino registra no console. Se quiser alterar a saída, você pode usar um dos transportes disponíveis do Pino que mencionamos anteriormente, como gravar em um arquivo, enviar logs para um serviço remoto como o Sentry ou usar o Azure Application Insights. Para obter mais informações, consulte a seção "Transportes conhecidos" de Pino.

Instalando o Pino bonito

O recurso de formatador NDJSON pino-pretty básico do Pino é um ótimo formatador simples para logs do Pino e é fácil de configurar. Veja como colocá-lo em funcionamento:

Etapa 1 - instale o pino-pretty como uma dependência em seu projeto Node.js executando o seguinte comando em seu terminal:

 npm install pino-pretty

Passo 2 - importe pino-pretty em seu aplicativo Node.js adicionando a seguinte linha de código na parte superior de seu arquivo:

 const pino = require('pino'); const pinoPretty = require('pino-pretty'); const logger = pino({ level: 'info' }); logger.pipe(pinoPretty());

Com esses dois trechos de código, você instalou pino-pretty e o configurou para formatar seus logs do Pino. Agora você pode usar a instância do logger para registrar mensagens em seu aplicativo e os logs serão exibidos em um formato bonito e legível por humanos no console.

Aprenda ainda mais sobre depuração com Pino em Como depurar Node.js com as melhores ferramentas disponíveis por @RisingStack

#2. Winston

Benefícios do Winston

Com mais de 20.000 estrelas no GitHub, Winston é uma biblioteca de registro muito popular para Node.js. Winston é uma biblioteca de registro exclusiva no ecossistema Node.js devido ao seu conjunto abrangente de recursos e facilidade de uso. Algumas das razões pelas quais Winston se destaca são:

• Flexível - Winston é altamente personalizável e fornece uma variedade de opções de registro e mecanismos de transporte que permitem que os registros sejam gravados em várias saídas, como o console, um arquivo ou um servidor remoto.
• Logs que podem ser consultados - Winston fornece um arquivo de log que pode ser consultado, o que torna mais fácil pesquisar e analisar logs.
• Fácil de usar - Winston tem uma API simples e fácil de usar que facilita o início do login em um aplicativo Node.js. Ele fornece um conjunto mínimo de funcionalidades principais, além de permitir que os desenvolvedores estendam e personalizem a funcionalidade de log conforme necessário.
• Bem documentado - Winston tem uma documentação abrangente que fornece informações detalhadas sobre sua API e inclui vários exemplos e tutoriais para ajudar os desenvolvedores a começar de maneira rápida e fácil.
• Orientado pela comunidade - Winston é um projeto de código aberto com uma grande e ativa comunidade de desenvolvedores, o que ajuda a garantir que a biblioteca seja bem mantida, livre de bugs e atualizada para acompanhar as últimas tendências e tecnologias.

Instalando o Winston

Para instalar o Winston em seu projeto Node.js, você pode usar o gerenciador de pacotes npm executando o seguinte comando em seu terminal:

 npm install winston

Usando o Winston

Depois que a instalação estiver concluída, você poderá importar e usar o Winston em seu código Node.js incluindo a seguinte linha:

 const winston = require('winston');

Você pode usar a biblioteca Winston para configurar e criar suas instâncias de registro, por exemplo:

 const logger = winston.createLogger({ level: 'info', format: winston.format.json(), transports: [ new winston.transports.Console() ] });

Isso cria uma instância do criador de logs com um nível de informação e um transporte de console. Você pode usar essa instância do logger para registrar mensagens em seu aplicativo, por exemplo:

 logger.info('Hello World');

Isso registrará a mensagem Hello World no console com o nível de registro de informações.

Níveis de registro em Winston

O Winston está equipado com seis níveis de registro padrão, organizados de acordo com as diretrizes descritas no documento RFC5424. Os níveis recebem prioridade numérica, com a gravidade mais alta sendo atribuída ao número mais baixo. Os seis níveis e seus respectivos valores de prioridade são:

 { error: 0, warn: 1, info: 2, http: 3, verbose: 4, debug: 5, silly: 6 }

Para cada um dos seis níveis de log, existe um método correspondente no objeto logger:

 logger.error('error'); logger.warn('warn'); logger.info('info'); logger.verbose('verbose'); logger.debug('debug'); logger.silly('silly');

Você também pode passar uma string representando o nível de registro para o método log():

 logger.log('error', 'error message'); logger.log('info', 'info message');

A propriedade level no logger determina quais mensagens de log serão passadas para os transportes que você configurou. Por exemplo, se a propriedade level for definida como info , apenas as entradas de log com uma gravidade de info ou superior serão gravadas e todas as outras serão despriorizadas. Isso significa que na configuração atual, apenas mensagens de log com níveis de info , warn e error serão exibidas.

#3. Bunyan

Benefícios do Bunyan

Bunyan é uma biblioteca de log exclusiva para Node.js devido ao seu foco em tornar os dados de log mais estruturados e legíveis (eles conseguem isso serializando logs como objetos JSON em vez de texto simples). Veja por que Bunyan tem 7 mil estrelas no Github:

1. Formato JSON - ao contrário de algumas outras bibliotecas de registro, Bunyan registra dados em formato JSON, facilitando a análise e a integração com outras ferramentas e plataformas.
2. Níveis de registro flexíveis - o Bunyan oferece suporte a vários níveis de registro com opções flexíveis para gerenciar o nível e o limite de gravidade do registro.
3. Serialização - Em Bunyan, existe um recurso chamado serialização, onde as funções convertem um objeto JavaScript em um objeto representável por JSON. Isso permite que uma instância específica do criador de logs tenha um serializador que vincula um nome de campo de registro de log a uma função de serialização.
4. API fácil de usar - Bunyan fornece uma API simples e fácil de usar para registro, tornando-a acessível para desenvolvedores de todos os níveis de habilidade.
5. Plug-ins e transportes - Bunyan oferece suporte a uma variedade de plug-ins e transportes, como console, arquivo, HTTP e e-mail, facilitando a personalização da saída de registro para atender a necessidades e requisitos específicos.

Instalando o Bunyan

Para instalar o Bunyan, você pode executar o seguinte comando em seu terminal ou prompt de comando:

 npm install bunyan

Isso instalará a biblioteca Bunyan e suas dependências em seu projeto Node.js. Depois de instalada, você pode exigir a biblioteca em seu código e começar a usá-la.

Usando Bunyan

Importe o Bunyan em seu projeto - na parte superior do seu arquivo JavaScript, adicione a seguinte linha:

 const bunyan = require('bunyan');

Crie uma instância do logger - em seguida, crie uma instância do logger usando o seguinte código:

 const logger = bunyan.createLogger({ name: 'my-app-name', level: 'info' });

Neste exemplo, name é o nome do seu aplicativo e level especifica o nível mínimo de logs que você deseja ver.

Registrar uma mensagem - para registrar uma mensagem, basta chamar um dos métodos de registro do Bunyan, como info, warning ou error, e passar a mensagem que deseja registrar, assim:

 logger.info('This is an info log message'); logger.warn('This is a warn log message'); logger.error('This is an error log message');

Execute seu código - finalmente, execute seu código e você verá as mensagens registradas no console.

Por padrão, Bunyan gera logs no formato JSON, facilitando a análise e análise de logs com ferramentas de gerenciamento de log. Você também pode personalizar o formato usando a opção de streams do Bunyan.

#4. Morgan

benefícios Morgan

Morgan é uma biblioteca de registro exclusiva para Node.js por vários motivos, principalmente por seu posicionamento exclusivo como middleware. Isso, entre outras razões, tornou-o muito popular, com 7,3 mil estrelas no GitHub no momento em que escrevemos. Aqui estão algumas razões pelas quais Morgan é tão popular:

1. Baseado em middleware - Morgan opera como middleware na estrutura Node.js Express, facilitando a integração em aplicativos existentes baseados em Express.
2. Personalizável - Morgan oferece uma ampla gama de opções de personalização, desde o formato de log até tokens personalizados, permitindo que os desenvolvedores adaptem seus logs às suas necessidades específicas.
3. Baseado em fluxos - Morgan pode gravar dados de log em uma variedade de fluxos de saída, incluindo o console, arquivos ou até mesmo servidores remotos.
4. Rápido e leve - O Morgan foi projetado para ser rápido e leve, tornando-o adequado para aplicações de alto tráfego onde o desempenho é crítico.
5. Log de solicitação HTTP - Morgan é projetado especificamente para registrar solicitações e respostas HTTP, o que é útil para depurar e analisar o desempenho do servidor web.

Instalando Morgan

Comece instalando o pacote morgan usando npm:

 npm install morgan

Usando Morgan

Depois de concluir o processo de instalação, você precisa importar a biblioteca usando a função "require" e integrá-la ao seu aplicativo Express.js como middleware.

O código para isso ficaria assim:

 var morgan = require('morgan'); app.use(morgan('dev'));

O argumento "dev" é uma opção de formato fornecida pelo Morgan. Morgan oferece cinco formatos de log diferentes, incluindo:

1. tiny tem uma saída minúscula.
2. short inclui o tempo de resposta e abrevia o log por padrão.
3. dev fornece uma saída concisa e codificada por cores para uso durante o desenvolvimento
4. common também usa a saída de log combinada do Apache.
5. combined utiliza a saída de log combinada padronizada do Apache.

Você pode escolher entre esses formatos usando o argumento apropriado ao integrar o Morgan em seu aplicativo, conforme mostrado abaixo:

 app.use(morgan('combined')); app.use(morgan('common')); app.use(morgan('dev')); app.use(morgan('short')); app.use(morgan('tiny'));

#5. Loglevel

Benefícios do nível de registro

Loglevel é um pouco menos popular do que algumas das outras opções listadas aqui, com 2,4 mil estrelas no Github, mas ainda assim continua sendo uma biblioteca de registro leve e excelente. Aqui estão algumas razões pelas quais loglevel é uma biblioteca de registro exclusiva para Node.js:

1. Mínima pegada de código - loglevel é uma biblioteca muito leve, tornando-a ideal para situações em que você precisa de uma quantidade mínima de sobrecarga de código.
2. Níveis de registro dinâmico - loglevel fornece níveis de registro dinâmico, o que permite alterar o nível de registro em tempo de execução, facilitando a alternância entre diferentes níveis de detalhes de registro sem a necessidade de modificar o código.
3. API simples - a API do loglevel é simples, fornecendo uma maneira flexível e fácil de usar para registrar mensagens.
4. Compatibilidade do navegador - loglevel é compatível com Node.js e navegadores da Web, tornando-o uma opção versátil para fazer login em vários ambientes.
5. Compatibilidade entre plataformas - loglevel é construído sobre log4js, que é uma biblioteca de registro amplamente usada, garantindo compatibilidade em diferentes plataformas.

Instalando Loglevel

Para configurar o nível de log, você precisa instalá-lo primeiro usando o npm:

 npm install loglevel

Usando Loglevel

Depois de instalá-lo, você pode importá-lo em seu projeto Node.js e começar a usá-lo definindo o nível de log:

 const log = require('loglevel'); log.setLevel(log.levels.ERROR);

Ao definir o nível de log como ERROR, você está especificando que apenas as mensagens de log com um nível de gravidade de ERROR serão registradas. Depois de definir o nível de log, você pode usar os seguintes métodos para registrar mensagens em diferentes níveis:

 log.trace('This is a trace message'); log.debug('This is a debug message'); log.info('This is an info message'); log.warn('This is a warning message'); log.error('This is an error message');

O nível de registro definido determinará quais mensagens serão registradas e quais serão ignoradas. Por exemplo, se o nível de log for definido como info, apenas as mensagens registradas usando log.info e log.warn ou log.error serão exibidas.

#6. Log4js

Benefícios do Log4js

Claro, não poderíamos mencionar loglevel sem também listar seu irmão mais velho, Log4js. Log4js é uma biblioteca de registro JavaScript que foi iniciada como uma porta da popular biblioteca de registro Java Log4j. Ele foi criado para fornecer uma solução de log semelhante para aplicativos JavaScript e, desde então, evoluiu para fornecer capacidades e recursos de log avançados. Com mais de 5,6 mil estrelas no Github, aqui estão algumas das razões pelas quais o Log4js é tão popular:

• Flexibilidade na configuração - Log4js oferece uma variedade de opções para registro, incluindo níveis de registro, diferentes tipos de anexadores (por exemplo, console, arquivo, rede) e a capacidade de especificar diferentes configurações de registro para diferentes partes do aplicativo.
• Anexadores personalizados - Log4js oferece suporte à criação de anexadores personalizados, permitindo que os desenvolvedores estendam a biblioteca para atender aos seus requisitos de registro específicos.
• Suporte para contexto de log - Log4js permite que os desenvolvedores associem mensagens de log com informações contextuais adicionais, como os dados de solicitação do usuário, para tornar as mensagens de log mais úteis para depuração.
• Configuração de nível de log dinâmico - Log4js suporta a alteração do nível de log em tempo de execução, facilitando o gerenciamento de log em um ambiente de produção.
• Integração com outras ferramentas - O Log4js possui suporte integrado para ferramentas populares, como Logstash e Graylog, facilitando a integração do registro em um fluxo de trabalho de análise e monitoramento de aplicativos mais amplo.

Instalando o Log4js

Para instalar o Log4js, você pode usar o gerenciador de pacotes npm executando o seguinte comando em seu terminal:

 npm install log4js

Isso instalará a versão mais recente do Log4js e suas dependências. Você pode exigir a biblioteca em seu aplicativo Node.js e começar a usá-la para registrar mensagens.

Usando Log4js

Para começar a usar o Log4js, primeiro exija-o em seu código e configure-o:

 const log4js = require('log4js'); log4js.configure({ appenders: { console: { type: 'console' } }, categories: { default: { appenders: ['console'], level: 'info' } } }); const logger = log4js.getLogger();

Você pode então usar o logger para registrar mensagens em diferentes níveis:

 logger.trace('Entering cheese testing'); logger.debug('Got cheese.'); logger.info('Cheese is Gouda.'); logger.warn('Cheese is quite smelly.'); logger.error('Cheese is too ripe!'); logger.fatal('Cheese was breeding ground for listeria.');

Aqui está um exemplo de uso do Log4js para registrar mensagens em vários anexadores (console e arquivo) com diferentes níveis de registro:

 const log4js = require('log4js'); log4js.configure({ appenders: { console: { type: 'console' }, file: { type: 'file', filename: 'app.log' } }, categories: { default: { appenders: ['console'], level: 'info' }, file: { appenders: ['file'], level: 'error' } } }); const logger = log4js.getLogger(); const fileLogger = log4js.getLogger('file'); logger.info('This is an informational message'); fileLogger.error('This is an error message');

Neste exemplo, o registrador com a categoria "padrão" é configurado para registrar mensagens com informações de nível ou superior no console. O logger com a categoria "arquivo" está configurado para registrar mensagens com erro de nível ou superior ao arquivo. Os dois registradores podem ser usados alternadamente para registrar mensagens em seus respectivos anexadores.

#7. Npmlog

Benefícios do Npmlog

O valor exclusivo do npmlog reside em sua simplicidade e sobrecarga mínima, tornando-o adequado para uso em projetos de pequena escala ou sensíveis ao desempenho. É fácil de configurar e integra-se perfeitamente com o ecossistema npm (o que não surpreende desde o utilitário logger oficial do npm), tornando-o uma escolha popular para desenvolvedores que procuram uma solução de registro leve. Aqui estão algumas razões pelas quais o npmlog fez a lista:

1. Leve - o npmlog tem uma pequena base de código e sobrecarga mínima, tornando-o adequado para projetos de pequena escala ou sensíveis ao desempenho.
2. Fácil integração com o npm - o npmlog foi projetado especificamente para uso no ecossistema npm, facilitando a integração com outros pacotes e ferramentas npm.
3. Personalizável - o npmlog permite que você personalize o nível de log, fluxo e prefixo, dando a você controle total sobre como seus logs são gerados e exibidos.
4. Versátil - o npmlog é adequado para uma ampla gama de projetos, desde pequenos scripts até grandes aplicativos, tornando-o uma ferramenta de registro versátil e flexível.
5. Simples de usar - o npmlog tem uma API direta e requer configuração mínima, tornando rápido e fácil começar a fazer login em seu projeto Node.js.

Instalando o Npmlog

Para instalar o npmlog, você precisa ter o Node.js e o npm (Node Package Manager) instalados em sua máquina. Em seguida, você pode executar o seguinte comando em seu terminal ou prompt de comando:

 npm install npmlog

Isso fará o download e instalará a versão mais recente do npmlog e suas dependências, permitindo que você o use em seu projeto Node.js.

Usando Npmlog

Aqui está um exemplo de como usar o npmlog em um projeto Node.js:

 const log = require('npmlog'); log.level = 'verbose'; log.verbose('This is a verbose message'); log.info('This is an informational message'); log.warn('This is a warning'); log.error('This is an error');

Neste exemplo, começamos exigindo o módulo npmlog e atribuindo-o a uma variável. Em seguida, definimos o nível de log como verbose , o que significa que as mensagens com nível de log verbose , info , warn e error serão exibidas. Em seguida, registramos as mensagens em níveis diferentes usando os verbose , info , warn e error .

Observe que, por padrão, o npmlog grava em process.stderr . Se você precisar gravar em process.stdout , poderá usar a propriedade log.stream .

#8. rugido

Benefícios do Roarr

A biblioteca roarr é uma ferramenta de log Node.js projetada para produzir dados estruturados sem a necessidade de inicialização. Possui uma interface de linha de comando (CLI) e suporta variáveis ambientais, tornando-o versátil e fácil de usar. Além disso, o roarr é compatível com Node.js e ambientes de navegador, tornando-o uma solução de registro versátil para uma ampla gama de aplicativos.

Aqui estão alguns pontos-chave que destacam o valor exclusivo da biblioteca roarr:

1. Log estruturado - a biblioteca produz logs em um formato estruturado, facilitando o processamento e a análise de logs usando ferramentas legíveis por máquina.
2. Metadados ricos - o roarr fornece um conjunto rico de metadados, como informações de solicitação e resposta, que podem ser usados para diagnosticar problemas e melhorar a qualidade geral de seus logs.
3. Legível por humanos - apesar de seu formato estruturado, os logs do roarr também são projetados para serem legíveis por humanos, facilitando a compreensão do contexto e do conteúdo de seus logs.
4. Fácil de usar - a biblioteca fornece uma API simples e intuitiva para registro, sem complexidade desnecessária.
5. Personalizável - a biblioteca roarr permite que você personalize a aparência e o conteúdo de seus logs, incluindo opções para personalizar o nível de log, fluxo e metadados.

Instalando o Roarr

Primeiro, instale o roarr usando npm:

 npm install roarr

Usando o Roarr

Em seguida, importe o roarr para o seu código e crie um logger:

 const Roarr = require('roarr').default; const logger = new Roarr({ context: { service: 'my-service' } });

Registre mensagens usando o método log :

 logger.info('Hello, world!');

Por padrão, os logs do roarr serão enviados para o console. Você pode personalizar a saída do log especificando um fluxo diferente, como um arquivo, usando a opção stream :

 const Roarr = require('roarr').default; const fs = require('fs'); const logger = new Roarr({ context: { service: 'my-service' }, stream: fs.createWriteStream('./my-service.log') });

Este é apenas um exemplo básico de como usar o roarr. Há muito mais opções e recursos disponíveis, portanto, consulte a documentação oficial do roarr para obter mais informações.

#9. Marcador

Benefícios do rastreador

Tracer é uma biblioteca de registro de software livre para aplicativos Node.js, desenvolvida pela comunidade Node.js. Ele foi projetado para fornecer uma maneira eficiente e flexível de registrar mensagens e informações de depuração em aplicativos Node.js. O Tracer foi mantido e desenvolvido ativamente por uma equipe de voluntários e está disponível para qualquer pessoa usar e contribuir no Github. Aqui estão alguns dos recursos que o tornam uma biblioteca de registro exclusiva:

1. Log assíncrono - O Tracer usa log assíncrono, o que significa que os logs não estão bloqueando a execução do programa.
2. Log estruturado - O Tracer fornece log estruturado, o que significa que os logs são organizados em pares chave-valor, tornando mais fácil pesquisar, analisar e visualizar dados de log.
3. Saída personalizável - o Tracer fornece um formato de saída personalizável, permitindo que os desenvolvedores escolham o formato e o destino de seus logs, incluindo console, arquivo ou serviços baseados em nuvem, como o AWS CloudWatch.
4. Contexto de log rico - o Tracer fornece um contexto de log rico, incluindo a capacidade de anexar metadados, como IDs de solicitação, IDs de usuário e outras informações aos logs.
5. Suporte a middleware - O Tracer oferece suporte a middleware, permitindo que os desenvolvedores adicionem log facilmente a seus aplicativos Express.js ou Koa.js.

Instalando o Rastreador

O Tracer pode ser instalado usando o Node Package Manager (npm). Aqui estão os passos para instalar o Tracer:

1. Abra seu terminal ou prompt de comando
2. Altere seu diretório atual para o diretório do projeto Node.js
3. Execute o seguinte comando para instalar o Tracer:

 npm install tracer

Isso instalará o Tracer como uma dependência em seu projeto. Você pode então exigi-lo em seu código e começar a usá-lo para registrar mensagens.

Usando rastreador

Aqui está um exemplo de como usar o Tracer em seu código:

 const tracer = require('tracer'); const logger = tracer.console(); logger.info('Starting the application...');

Neste exemplo, primeiro precisamos da biblioteca Tracer e, em seguida, criamos um registrador de console usando o método tracer.console() . Por fim, registramos uma mensagem informativa usando o método info no objeto logger.

Aqui está outro exemplo de uso do Tracer:

 const tracer = require('tracer'); const logger = tracer.dailyfile({root: './logs', maxLogFiles: 10}); logger.error('An error has occurred:', new Error('Something went wrong'));

Neste exemplo, estamos usando o método tracer.dailyfile para criar um logger de arquivo que grava logs em um arquivo rotativo diário. A opção root especifica o diretório onde os arquivos de log serão armazenados e a opção maxLogFiles limita o número de arquivos de log que serão mantidos.

Por fim, registramos uma mensagem de erro usando o método error no objeto logger, juntamente com um objeto error, fornecendo mais informações sobre o erro ocorrido.

#10. sinal

Benefícios do sinal

Sua página do Github se orgulha de ser “hackeável e configurável até o núcleo”, e isso é uma parte importante do que torna o Signale uma biblioteca de registro tão amada na comunidade Node.js. A biblioteca foi criada como uma solução para as dificuldades que os desenvolvedores enfrentam ao tentar registrar mensagens em aplicativos Node.js, como logs confusos e difíceis de ler. Aqui está o que o destaca do pacote:

1. Saídas de log personalizáveis - O Signale oferece uma variedade de saídas de log personalizáveis, permitindo que os desenvolvedores escolham a saída que melhor se adapta às suas necessidades, desde saídas de console simples até saídas mais avançadas, como JSON e Logfmt.
2. API intuitiva - O Signale possui uma API simples e intuitiva, facilitando o uso e a compreensão dos desenvolvedores, mesmo para aqueles que são novos no registro.
3. Saída com estilo - O Signale fornece saídas com estilo, tornando os logs mais legíveis e visualmente atraentes, facilitando a identificação rápida de mensagens de log importantes.
4. Contexto de log rico - O Signale fornece contexto de log rico, como registros de data e hora e níveis de log, facilitando a análise e a compreensão dos logs.
5. Comunidade ativa - Signale tem uma comunidade grande e ativa de desenvolvedores e colaboradores, garantindo que a biblioteca seja bem mantida e atualizada com as tecnologias e práticas recomendadas mais recentes.

Instalando Signale

Para instalar o Signale, você pode usar o npm, o gerenciador de pacotes Node.js, executando o seguinte comando em seu terminal:

 npm install signale

Como alternativa, você também pode usar yarn para instalar o Signale executando o seguinte comando em seu terminal:

 yarn add signale

Depois de instalado, você pode importar o Signale para seu aplicativo Node.js e começar a usá-lo para registrar mensagens e informações de depuração.

Usando Sinal

Aqui está um exemplo de como importar o Signale para seu aplicativo Node.js e usá-lo para registrar mensagens:

 const signale = require('signale'); // Log an info message signale.info('Starting up the server'); // Log a success message signale.success('Server started successfully'); // Log a warning message signale.warn('Low memory warning'); // Log an error message signale.error(new Error('An error occurred while processing data'));

Neste exemplo, importamos o Signale para nosso aplicativo Node.js usando a função require . Em seguida, usamos os vários métodos de registro fornecidos pelo Signale, como info , success , warn e error , para registrar diferentes tipos de mensagens. Cada um desses métodos possui um símbolo e uma cor distintos, facilitando a identificação rápida do tipo de mensagem de log.

Você pode encontrar mais informações sobre como usar o Signale, incluindo métodos de registro adicionais e opções de personalização, na documentação do Signale .

Otimize seu processo de depuração com bibliotecas de log Node.js

Em busca de um método rápido e eficiente para depurar seus aplicativos Node.js? Confira uma ou mais das bibliotecas mencionadas neste artigo, cada uma delas é uma ótima opção. Pino, no entanto, é nossa biblioteca de registro pessoal de escolha pelo que vale a pena 😉

Essas bibliotecas de registro provaram ser cruciais ao depurar aplicativos Node.js em ambientes de teste/desenvolvimento e em produção.

Além disso, ao integrá-los a uma solução de monitoramento como o PlayerZero, você pode obter insights ainda maiores sobre o desempenho de seus aplicativos Node.js.

Reserve uma demonstração para saber mais sobre como o PlayerZero pode ajudá-lo a otimizar o desempenho do seu aplicativo de back-end hoje!