Stai lottando con il debug del tuo codice? Stai cercando alcune soluzioni di registrazione che potrebbero semplificare il debug? Continuate a leggere per saperne di più.
Lo sviluppo del software passa attraverso diverse fasi: raccolta dei requisiti, analisi, codifica, test e manutenzione. Di tutte queste fasi, la fase di codifica/sviluppo richiede molto tempo e fatica. Gli ingegneri del software si occupano di errori di sintassi, errori logici ed errori di runtime. Gli errori sintattici vengono identificati in fase di compilazione e si verificano a causa del codice che non rispetta le regole di un linguaggio di programmazione.
D’altra parte, gli errori logici e di runtime non possono essere identificati dall’ambiente di sviluppo integrato (IDE) e sono spesso difficili da eseguire il debug e correggere. La risoluzione dei bug è un processo che richiede molto tempo e richiede molto debug.
Il debug è un processo in cui si cerca di capire perché il codice scritto non funziona come previsto. È facile risolvere il problema quando conosciamo l’errore e le righe esatte nel codice in cui si verifica. Quindi, la registrazione è molto utile per il debug del codice.
Sommario:
Che cos’è la registrazione?
La registrazione è una tecnica in cui i messaggi vengono acquisiti durante l’esecuzione di un programma. È necessario registrare solo quei messaggi, che potrebbero aiutarli nel debug. Quindi, sapere quando aggiungere istruzioni di registro al codice è estremamente importante. Inoltre, la differenziazione tra le istruzioni di registro è ugualmente essenziale. Ci sono vari livelli nella registrazione, come info, warning, error, debug e verbose. Le istruzioni di errore e avviso vengono utilizzate per la gestione delle eccezioni.
I dati restituiti dalle funzioni, i risultati dopo la manipolazione dell’array, i dati recuperati dalle API e così via, sono alcuni esempi di dati che possono essere registrati utilizzando le istruzioni info. I log di debug e dettagliato vengono utilizzati per fornire una descrizione dettagliata degli errori.
Il registro di debug fornisce informazioni sulla traccia dello stack, i parametri di input-output, ecc. “Verbose” non è dettagliato come il registro di “debug”, ma fornisce un elenco di tutti gli eventi che si sono verificati. I registri vengono scritti nella console, nei file e nel flusso di output. Gli strumenti di gestione dei registri possono essere utilizzati per la registrazione strutturata e formattata.
Registrazione di Node.js
Nodejs è un ambiente di runtime javascript. Le applicazioni Node.js sono asincrone e non bloccanti e vengono utilizzate in sistemi ad alta intensità di dati e in tempo reale. Il modo migliore per saperne di più su Node.js è consultare i tutorial di Node.js e la relativa documentazione. La registrazione è necessaria per migliorare le prestazioni, la risoluzione dei problemi e il rilevamento degli errori. L’accesso a Node.js può essere eseguito utilizzando la funzione integrata console.log. Inoltre, la funzione di debug è interconnessa con più pacchetti e può essere utilizzata in modo efficace.
Il middleware viene utilizzato per la gestione di richieste e risposte. Il middleware potrebbe essere un’applicazione o qualsiasi altro framework Javascript. L’accesso al middleware può essere effettuato tramite applicazioni e router. Qualsiasi logger Node.js deve utilizzare il comando npm o yarn install per installare i logger.
Npm sta per “Node Package Manager” e YARN sta per “Yet Another Resource Negotiator”. Tuttavia, Yarn è preferito a npm in quanto è più veloce e installa i pacchetti in parallelo.
Alcuni dei migliori logger Node.js sono elencati di seguito:
Pino
Pino è una libreria che è uno dei migliori logger per le applicazioni Node.js. È open source, estremamente veloce e registra le istruzioni in un formato JSON di facile lettura. Alcuni dei livelli di registro di Pino sono: messaggi di debug, avviso, errore e informazioni. Un’istanza di Pino logger può essere importata nel progetto e le istruzioni console.log devono essere sostituite con istruzioni logger.info.
Utilizzare il comando seguente per installare Pino:
$ npm install pino
I log generati sono elaborati e in formato JSON, evidenziando il numero di riga del log, il tipo di log, l’ora in cui è stato registrato, ecc. Pino causa un sovraccarico minimo di registrazione in un’applicazione ed è estremamente flessibile durante l’elaborazione dei log.
Pino può essere integrato con framework web come Hapi, Restify, Express, ecc. I log generati da Pino possono anche essere archiviati in file. Utilizza i thread di lavoro per il funzionamento ed è compatibile con TypeScript.
Winston
Winston supporta la registrazione per vari framework Web con l’obiettivo principale di flessibilità ed estensibilità. Supporta più tipi di trasporto e può archiviare i registri in varie posizioni di file. I trasporti sono luoghi in cui vengono archiviati i messaggi di registro.
Insieme ad alcuni trasporti integrati come HTTP, Console, File e Stream, supporta altri trasporti come Cloud Watch e MongoDB. Esegue la registrazione in vari livelli e formati. I livelli di registrazione indicano la gravità del problema.
I vari livelli di registrazione sono mostrati di seguito:
{
error: 0,
warn: 1,
info: 2,
http: 3,
verbose: 4,
debug: 5,
silly: 6
}
Il formato di output del registro può anche essere personalizzato, filtrato e combinato. I registri includono informazioni sul timestamp, etichette associate a un registro, millisecondi trascorsi dal registro precedente, ecc.
Winston gestisce anche le eccezioni e le promesse non mantenute. Fornisce funzionalità aggiuntive come l’archiviazione di runtime di query, log di streaming, ecc. Innanzitutto, è necessario installare Winston. Quindi, viene creato un oggetto di configurazione Winston, insieme al trasporto, per archiviare il registro. Un oggetto logger viene creato utilizzando la funzione createLogger() e il messaggio di registro gli viene passato.
Nodo-Bunyan
Bunyan viene utilizzato per l’accesso rapido a node.js in formato JSON. Fornisce inoltre uno strumento CLI (Command Line Interface) per la visualizzazione dei registri. È leggero e supporta vari ambienti di runtime come Node.js, Browserify, WebPack e NW.js. Il formato JSON dei log è ulteriormente abbellito utilizzando la graziosa funzione di stampa. I registri hanno vari livelli come fatale, errore, avviso, informazioni, debug e traccia; a ciascuno è associato un valore numerico.
Tutti i livelli al di sopra del livello impostato per l’istanza vengono registrati. Il flusso Bunyan è un luogo in cui vengono registrati gli output. I sottocomponenti di un’applicazione possono essere registrati utilizzando la funzione log.child(). Tutti i logger figlio sono vincolati a un’applicazione padre specifica. Il tipo di flusso potrebbe essere un file, un file rotante, dati grezzi e così via. Di seguito viene mostrato l’esempio di codice per la definizione di un flusso:
var bunyan = require('bunyan');
var log = bunyan.createLogger({
name: "foo",
streams: [
{
stream: process.stderr,
level: "debug"
},
...
]
});
Bunyan supporta anche la registrazione DTrace. I probe coinvolti nella registrazione di DTrace includono log-trace, log-warn, log-error, log-info, log-debug e log-fatal. Bunyan utilizza serializzatori per produrre i log in formato JSON. Le funzioni del serializzatore non generano eccezioni e sono difensive.
Loglevel
Loglevel viene utilizzato per accedere alle applicazioni Javascript. È anche uno dei migliori logger di Node.js in quanto è leggero e semplice. Registra il livello specificato e utilizza un singolo file senza dipendenze per la registrazione. Il livello di registro predefinito è “avviso”. Gli output del registro sono ben formattati insieme ai numeri di riga. Alcuni metodi utilizzati per la registrazione sono trace, debug, warning, error e info.
Sono resistenti al fallimento in qualsiasi ambiente. getLogger() è il metodo utilizzato per recuperare l’oggetto logger. Può essere combinato anche con altri plugin per estenderne le funzionalità. Alcuni dei plugin includono loglevel-plugin-prefix, loglevel-plugin-remote, ServerSend e DEBUG. Il plug-in per l’aggiunta di messaggi di prefisso alla registrazione è mostrato di seguito:
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
Le build vengono eseguite utilizzando il comando npm run dist e i test possono essere eseguiti utilizzando il comando npm test. Il livello di registro supporta i pacchetti Webjar, Bower e Atmosphere. Una nuova versione di Loglevel viene rilasciata ogni volta che vengono aggiunte nuove funzionalità.
Segnale
Signale è composto da 19 logger per applicazioni Javascript. Supporta TypeScript e la registrazione con ambito. È costituito da timer che aiutano a registrare il timestamp, i dati e il nome del file. Oltre ai 19 logger come await, complete, fatal, fav, info, ecc., è possibile creare log personalizzati.
I log personalizzati vengono creati definendo un oggetto JSON e campi con i dati del logger. È anche possibile creare logger interattivi. Quando un logger interattivo è impostato su true, i nuovi valori dei logger interattivi sovrascrivono quelli vecchi.
La parte migliore di Signale è la capacità di filtrare le informazioni segrete o sensibili. Più segreti sono archiviati in un array. addSecrets() e clearSecrets() sono le funzioni utilizzate per aggiungere e cancellare i segreti dall’array. Boostnote, Docz, Shower, Taskbook e Vant usano Signale per la registrazione. La sintassi per chiamare le API da Signale è la seguente:
signale.<logger>(message[,message]|messageObj|errorObj)
Il numero di download di Signale è di oltre 1 milione al momento della stesura di questo articolo.
Tracciante
Tracer viene utilizzato per produrre messaggi di registrazione dettagliati. I messaggi di registrazione sono costituiti da timestamp, nomi di file, numeri di riga e nomi di metodi. È possibile installare pacchetti di supporto per personalizzare il formato di registrazione dell’output. I pacchetti di supporto possono essere installati utilizzando il comando seguente.
npm install -dev tracer
Tracer supporta il trasporto di file, stream e MongoDB. Supporta la console dei colori e le condizioni del filtro nella registrazione. Inizialmente, il tracciante deve essere installato utilizzando npm install. In secondo luogo, è necessario creare un oggetto logger e selezionare il tipo di console. Quindi, i vari livelli o tipi di registro possono essere specificati sull’oggetto per un’ulteriore registrazione.
È possibile creare filtri personalizzati definendo funzioni sincrone con la logica di business presente nel corpo della funzione. Anche i micromodelli come tinytim possono essere utilizzati per la registrazione del sistema.
Cabin.js
Cabin viene utilizzato per la registrazione lato server e client delle applicazioni node.js. Viene utilizzato laddove è richiesto il mascheramento di informazioni sensibili e critiche. Ciò include numeri di carta di credito, intestazioni BasicAuth, sali, password, token CSRF e numeri di conto bancario. Il frammento di codice seguente mostra la registrazione utilizzando Cabin.js.
const Cabin = require('cabin');
const cabin = new Cabin();
cabin.info('hello world');
cabin.error(new Error('oops!'));
Consiste di più di 1600 nomi di campo. Segue anche il principio di Bring Your Own Logger (BYOL). Ciò lo rende compatibile con vari altri logger come Axe, Pino, Bunyan, Winston, ecc. Riduce i costi di archiviazione nei dischi grazie al flusso automatico e ai buffer Cabin. È compatibile con più piattaforme e facile da eseguire il debug.
La registrazione lato server richiede l’utilizzo del middleware per il routing e la registrazione automatica dell’output. La registrazione lato browser richiede richieste e script XHR. Utilizza Axe che visualizza i metadati, ovvero i dati sui dati, le tracce dello stack e altri errori. SHOW_STACK e SHOW_META sono variabili booleane impostate su true o false per mostrare o nascondere le tracce dello stack e i metadati.
Npmlog
Npmlog è un tipo base di logger utilizzato da npm. Alcuni dei metodi di registrazione utilizzati sono level, record, maxRecordSize, prefixStyle, header e stream. Supporta anche la registrazione colorata. I vari livelli di registrazione sono sciocco, dettagliato, info, warning, http ed errore. Di seguito viene mostrato un frammento di codice di esempio per l’utilizzo del registro npm.
var log = require('npmlog')
// additional stuff ---------------------------+
// message ----------+ |
// prefix ----+ | |
// level -+ | | |
// v v v v
log.info('fyi', 'I have a kitty cat: %j', myKittyCat)
Tutti i messaggi vengono eliminati se viene specificato “Infinito” come livello di registro. Se è specificato “-Infinity” come livello di registro, l’opzione per visualizzare i messaggi di registrazione deve essere abilitata per visualizzare i registri.
Gli eventi e gli oggetti del messaggio vengono utilizzati per la registrazione. I messaggi di prefisso vengono emessi quando vengono utilizzati eventi di prefisso. Gli oggetti di stile vengono utilizzati per formattare i registri, come aggiungere colore al testo e allo sfondo, stili di carattere come grassetto, corsivo, sottolineato, ecc. Alcuni pacchetti di log npm sono brolog, npmlogger, npmdate log, ecc.
Ruggito
Roarr è un logger per Node.js che non richiede l’inizializzazione e produce dati strutturati. Ha CLI e variabili ambientali. È compatibile con browser. Può essere integrato con Fastify, Fastify, Elastic Search, ecc. Può distinguere tra codice dell’applicazione e codice di dipendenza. Ogni messaggio di registro è costituito da contesto, messaggio, sequenza, ora e versione. Vari livelli di registro includono traccia, debug, informazioni, avviso, errore e fatale. Un frammento di codice di esempio su come viene eseguita la registrazione è Roarr è il seguente:
import {
ROARR,
} from 'roarr';
ROARR.write = (message) => {
console.log(JSON.parse(message));
};
Inoltre, è possibile eseguire la serializzazione degli errori, il che significa che l’istanza con l’errore può essere registrata insieme al contesto dell’oggetto. Alcune delle variabili di ambiente specifiche di Node.js e Roarr sono ROARR_LOG e ROARR_STREAM. “adopt” è una funzione utilizzata con node.js per trasferire le proprietà del contesto a vari livelli. Le funzioni figlio possono essere utilizzate anche con il middleware durante la registrazione.
Parole finali
La registrazione è un metodo per tenere traccia di varie attività ed eventi durante l’esecuzione di un programma. La registrazione svolge un ruolo fondamentale nel debug del codice. Aiuta anche ad aumentare la leggibilità del codice. Node.js è un ambiente di runtime javascript open source. Alcuni dei migliori logger Node.js sono Pino, Winston, Bunyan, Signale, Tracer, Npmlog, ecc. Ogni tipo di logger ha le sue caratteristiche come la profilazione, il filtraggio, lo streaming e il trasporto.
Alcuni logger supportano console colorate e alcuni sono adatti per la gestione di informazioni sensibili. I registri dettagliati e formattati aiutano maggiormente gli sviluppatori mentre cercano di correggere i bug nel loro codice. Il formato JSON è generalmente preferito per la registrazione perché registra i dati sotto forma di coppie chiave-valore che lo rendono facile da usare.
I logger possono anche essere integrati con altre applicazioni e sono compatibili con più browser. È sempre consigliabile esaminare le esigenze e le applicazioni che si stanno creando prima di scegliere il tipo di logger che si desidera utilizzare.
Puoi anche vedere come installare Node.js e NPM su Windows e macOS.