Você está lutando para depurar seu código? Você está procurando algumas soluções de log que possam facilitar a depuração? Leia para saber mais.
O desenvolvimento de software passa por várias fases: levantamento de requisitos, análise, codificação, teste e manutenção. De todas essas fases, a fase de codificação/desenvolvimento requer muito tempo e esforço. Os engenheiros de software lidam com erros de sintaxe, erros lógicos e erros de tempo de execução. Erros sintáticos são identificados em tempo de compilação e ocorrem devido ao código não obedecer às regras de uma linguagem de programação.
Por outro lado, erros lógicos e de tempo de execução não podem ser identificados pelo Ambiente de Desenvolvimento Integrado (IDE) e geralmente são difíceis de depurar e corrigir. A resolução de bugs é um processo demorado e requer muita depuração.
A depuração é um processo no qual se tenta entender por que o código escrito não está funcionando conforme o esperado. É fácil resolver o problema quando sabemos o erro e as linhas exatas no código onde ele está ocorrendo. Portanto, o registro em log é muito útil para depurar código.
últimas postagens
O que é Logging?
Logging é uma técnica na qual as mensagens são capturadas durante a execução de um programa. É preciso registrar apenas essas mensagens, o que pode ajudá-los na depuração. Portanto, saber quando adicionar instruções de log ao código é extremamente importante. Além disso, diferenciar entre as instruções de log é igualmente essencial. Existem vários níveis no registro, como informações, aviso, erro, depuração e verbose. Instruções de erro e aviso são usadas para tratamento de exceção.
Dados que são retornados de funções, resultados após manipulação de arrays, dados recuperados de APIs, etc., são alguns exemplos de dados que podem ser registrados usando instruções info. Os logs de depuração e detalhados são usados para fornecer uma descrição detalhada dos erros.
O log de depuração fornece informações sobre o rastreamento de pilha, parâmetros de entrada e saída, etc. “Verbose” não é tão detalhado quanto o log de “depuração”, mas fornece uma lista de todos os eventos que ocorreram. Os logs são gravados no console, nos arquivos e no fluxo de saída. As ferramentas de gerenciamento de log podem ser usadas para log estruturado e formatado.
Registro do Node.js
Nodejs é um ambiente de tempo de execução javascript. Os aplicativos Node.js são assíncronos e não bloqueantes e são usados em sistemas com uso intenso de dados e em tempo real. A melhor maneira de aprender mais sobre o Node.js é consultar os tutoriais do Node.js e sua documentação. O registro é necessário para melhorar o desempenho, a solução de problemas e o rastreamento de erros. O login no Node.js pode ser feito usando a função incorporada console.log. Além disso, a função de depuração está interligada com vários pacotes e pode ser usada de forma eficaz.
Middleware é usado para gerenciar solicitações e respostas. Middleware pode ser um aplicativo ou qualquer outro framework Javascript. O log no middleware pode ser feito por meio de aplicativos e roteadores. Qualquer registrador Node.js precisa usar o comando npm ou yarn install para instalar os registradores.
Npm significa “Node Package Manager” e YARN significa “Yet Another Resource Negotiator”. No entanto, o Yarn é preferível ao npm, pois é mais rápido e instala pacotes paralelamente.
Alguns dos melhores registradores Node.js estão listados abaixo:
Pino
Pino é uma biblioteca que é um dos melhores registradores para aplicativos Node.js. É de código aberto, extremamente rápido e registra as instruções em um formato JSON de fácil leitura. Alguns dos níveis de log do Pino são – mensagens de depuração, aviso, erro e informações. Uma instância Pino logger pode ser importada para o projeto e as instruções console.log devem ser substituídas por instruções logger.info.
Use o seguinte comando para instalar o Pino:
$ npm install pino
Os logs gerados são elaborados e em formato JSON, destacando o número da linha do log, o tipo de log, a hora em que foi logado, etc. Pino causa sobrecarga mínima de log em um aplicativo e é extremamente flexível no processamento de logs.
Pino pode ser integrado com frameworks web como Hapi, Restify, Express, etc. Os logs gerados pelo Pino também podem ser armazenados em arquivos. Ele usa threads de trabalho para operação e é compatível com TypeScript.
Winston
O Winston oferece suporte ao log para várias estruturas da Web com foco principal na flexibilidade e extensibilidade. Ele suporta vários tipos de transporte e pode armazenar logs em vários locais de arquivo. Os transportes são locais onde as mensagens de log são armazenadas.
Junto com alguns transportes integrados como Http, Console, File e Stream, ele suporta outros transportes, como Cloud watch e MongoDB. Ele faz o registro em vários níveis e formatos. Os níveis de registro indicam a gravidade do problema.
Os vários níveis de registro são mostrados abaixo:
{
error: 0,
warn: 1,
info: 2,
http: 3,
verbose: 4,
debug: 5,
silly: 6
}
O formato de saída de log pode ser personalizado, filtrado e combinado também. Os logs incluem informações sobre o carimbo de data/hora, rótulos associados a um log, milissegundos decorridos do log anterior etc.
Winston também lida com exceções e promessas não atendidas. Ele fornece recursos adicionais, como arquivamento de tempo de execução de consultas, logs de streaming, etc. Em primeiro lugar, é preciso instalar o Winston. Em seguida, um objeto de configuração Winston, juntamente com o transporte, é criado para armazenar o log. Um objeto logger é criado usando a função createLogger() e a mensagem de log é passada para ele.
Node-Bunyan
Bunyan é usado para registro rápido em node.js no formato JSON. Ele também fornece uma ferramenta CLI (Command Line Interface) para visualizar os logs. É leve e oferece suporte a vários ambientes de tempo de execução, como Node.js, Browserify, WebPack e NW.js. O formato JSON dos logs é ainda mais embelezado usando a função de impressão bonita. Os logs têm vários níveis como fatal, error, warning, info, debug e trace; cada um está associado a um valor numérico.
Todos os níveis acima do nível definido para a instância são registrados. O fluxo Bunyan é um local onde as saídas são registradas. Os subcomponentes de um aplicativo podem ser registrados usando a função log.child(). Todos os registradores filhos são vinculados a um aplicativo pai específico. O tipo de fluxo pode ser um arquivo, arquivo rotativo, dados brutos etc. O exemplo de código para definir um fluxo é mostrado abaixo:
var bunyan = require('bunyan');
var log = bunyan.createLogger({
name: "foo",
streams: [
{
stream: process.stderr,
level: "debug"
},
...
]
});
Bunyan também oferece suporte ao registro do DTrace. Os probes envolvidos no log do DTrace incluem log-trace, log-warn, log-error, log-info, log-debug e log-fatal. Bunyan usa serializadores para produzir os logs no formato JSON. As funções do serializador não lançam exceções e são defensivas.
Nível de registro
Loglevel é usado para fazer login em aplicativos Javascript. É também um dos melhores registradores do Node.js, pois é leve e simples. Ele registra o nível fornecido e usa um único arquivo sem dependências para registro. O nível de log padrão é “aviso”. As saídas de log são bem formatadas junto com os números de linha. Alguns métodos usados para logging são trace, debug, warning, error e info.
Eles são resilientes a falhas em qualquer ambiente. getLogger() é o método usado para recuperar o objeto logger. Ele também pode ser combinado com outros plugins para estender seus recursos. Alguns dos plugins incluem loglevel-plugin-prefix, loglevel-plugin-remote, ServerSend e DEBUG. O plugin para adicionar mensagens de prefixo ao registro é mostrado abaixo:
var originalFactory = log.methodFactory;
log.methodFactory = function (methodName, logLevel, loggerName) {
var rawMethod = originalFactory(methodName, logLevel, loggerName);
return function (message) {
rawMethod("Newsflash: " + message);
};
};
log.setLevel(log.getLevel()); // Be sure to call setLevel method in order to apply plugin
As compilações são executadas usando o comando npm run dist e os testes podem ser executados usando o comando npm test. O nível de log suporta pacotes Webjar, Bower e Atmosphere. Uma nova versão do Loglevel é lançada sempre que novos recursos são adicionados.
Sinalizador
O Signale consiste em 19 registradores para aplicativos Javascript. Ele suporta TypeScript e log com escopo. Ele consiste em temporizadores que ajudam a registrar o registro de data e hora, dados e nome de arquivo. Além dos 19 loggers como await, complete, fatal, fav, info, etc., pode-se criar logs personalizados.
Os logs personalizados são criados definindo um objeto JSON e campos com os dados do registrador. Registradores interativos também podem ser criados. Quando um registrador interativo é definido como verdadeiro, os novos valores dos registradores interativos substituem os antigos.
A melhor parte do Signale é a capacidade de filtrar informações confidenciais ou confidenciais. Vários segredos são armazenados em uma matriz. addSecrets() e clearSecrets() são as funções usadas para adicionar e limpar os segredos do array. Boostnote, Docz, Shower, Taskbook e Vant usam Signale para registro. A sintaxe para chamar APIs do Signale é a seguinte:
signale.<logger>(message[,message]|messageObj|errorObj)
O número de downloads do Signale é superior a 1 milhão no momento da redação deste artigo.
Marcador
O Tracer é usado para produzir mensagens de log detalhadas. As mensagens de registro consistem em carimbos de data/hora, nomes de arquivos, números de linha e nomes de métodos. Os pacotes auxiliares podem ser instalados para personalizar o formato de registro de saída. Os pacotes auxiliares podem ser instalados usando o seguinte comando.
npm install -dev tracer
O Tracer é compatível com transporte de arquivo, fluxo e MongoDB. Ele suporta console de cores e condições de filtro no registro. Inicialmente, o rastreador deve ser instalado usando npm install. Em segundo lugar, um objeto logger deve ser criado e o tipo de console deve ser selecionado. Em seguida, os vários níveis ou tipos de log podem ser especificados sobre o objeto para mais log.
Filtros personalizados podem ser criados definindo funções síncronas com a lógica de negócios presente no corpo da função. Micro-modelos como tinytim também podem ser usados para log do sistema.
Cabin.js
Cabin é usado para log do lado do servidor e do cliente de aplicativos node.js. É usado onde o mascaramento de informações confidenciais e críticas é necessário. Isso inclui números de cartão de crédito, cabeçalhos BasicAuth, salts, senhas, tokens CSRF e números de contas bancárias. O snippet de código abaixo mostra a geração de registros usando Cabin.js.
const Cabin = require('cabin');
const cabin = new Cabin();
cabin.info('hello world');
cabin.error(new Error('oops!'));
Consiste em mais de 1600 nomes de campo. Também segue o princípio do Bring Your Own Logger (BYOL). Isso o torna compatível com vários outros registradores como Axe, Pino, Bunyan, Winston, etc. Reduz os custos de armazenamento em discos devido ao fluxo automático e buffers de cabine. É compatível com várias plataformas e fácil de depurar.
O log do lado do servidor requer o uso de middleware para roteamento e log de saída automático. O registro no navegador requer solicitações e scripts XHR. Ele usa o Axe que exibe metadados, ou seja, dados sobre dados, rastreamentos de pilha e outros erros. SHOW_STACK e SHOW_META são variáveis booleanas definidas como true ou false para mostrar ou ocultar rastreamentos de pilha e metadados.
Npmlog
Npmlog é um tipo básico de registrador que o npm usa. Alguns dos métodos de registro usados são nível, registro, maxRecordSize, prefixStyle, título e fluxo. Ele também suporta registro colorido. Os vários níveis de log são bobo, verboso, info, aviso, http e erro. Um trecho de código de exemplo para usar o log npm é mostrado abaixo.
var log = require('npmlog')
// additional stuff ---------------------------+
// message ----------+ |
// prefix ----+ | |
// level -+ | | |
// v v v v
log.info('fyi', 'I have a kitty cat: %j', myKittyCat)
Todas as mensagens são suprimidas se “Infinity” for especificado como o nível de log. Se “-Infinity” for especificado como o nível de log, a opção para ver as mensagens de log deve ser habilitada para ver os logs.
Eventos e objetos de mensagem são usados para registro. As mensagens de prefixo são emitidas quando os eventos de prefixo são usados. Objetos de estilo são usados para formatar os logs, como adicionar cor ao texto e plano de fundo, estilo de fonte como negrito, itálico, sublinhado, etc. Alguns pacotes de log npm são brolog, npmlogger, npmdate log, etc.
Rugido
Roarr é um agente de log para Node.js que não requer inicialização e produz dados estruturados. Possui CLI e variáveis ambientais. É compatível com navegador. Ele pode ser integrado com Fastify, Fastify, Elastic Search, etc. Ele pode distinguir entre código de aplicativo e código de dependência. Cada mensagem de log consiste em um contexto, mensagem, sequência, hora e versão. Vários níveis de log incluem rastreamento, depuração, informações, aviso, erro e fatal. Um trecho de código de amostra sobre como o registro é feito é Roarr é o seguinte:
import {
ROARR,
} from 'roarr';
ROARR.write = (message) => {
console.log(JSON.parse(message));
};
Além disso, a serialização de erros pode ser feita, o que significa que a instância com o erro pode ser registrada junto com o contexto do objeto. Algumas das variáveis de ambiente específicas para Node.js e Roarr são ROARR_LOG e ROARR_STREAM. “adopt” é uma função que é usada com node.js para passar as propriedades de contexto para vários níveis. As funções filhas também podem ser usadas com middleware durante o registro.
Palavras finais
Logging é um método de acompanhar várias atividades e eventos durante a execução de um programa. O log desempenha um papel vital na depuração de código. Também ajuda a aumentar a legibilidade do código. Node.js é um ambiente de tempo de execução javascript de código aberto. Alguns dos melhores registradores Node.js são Pino, Winston, Bunyan, Signale, Tracer, Npmlog, etc. Cada tipo de registrador tem seus próprios recursos, como criação de perfil, filtragem, streaming e transporte.
Alguns registradores suportam consoles coloridos e alguns são adequados para lidar com informações confidenciais. Logs detalhados e formatados ajudam mais os desenvolvedores enquanto tentam corrigir bugs em seu código. O formato JSON é geralmente preferido para registro porque registra dados na forma de pares de valores-chave, tornando-o fácil de usar.
Os registradores também podem ser integrados a outros aplicativos e são compatíveis com vários navegadores. É sempre aconselhável examinar as necessidades e os aplicativos que você está construindo antes de escolher o tipo de registrador que deseja usar.
Você também pode ver como instalar o Node.js e o NPM no Windows e no macOS.