9 bibliothèques d'enregistrement Node.js que vous pouvez essayer pour un meilleur enregistrement

Vous avez du mal à déboguer votre code ? Cherchez-vous des solutions de journalisation qui pourraient faciliter le débogage ? Lisez ce qui suit pour en savoir plus.

Le développement d’un logiciel passe par plusieurs phases : la collecte des besoins, l’analyse, le codage, les tests et la maintenance. Parmi toutes ces phases, la phase de codage/développement demande beaucoup de temps et d’efforts. Les ingénieurs logiciels sont confrontés à des erreurs de syntaxe, des erreurs logiques et des erreurs d’exécution. Les erreurs syntaxiques sont identifiées au moment de la compilation et sont dues au fait que le code ne respecte pas les règles d’un langage de programmation.

En revanche, les erreurs logiques et d’exécution ne peuvent pas être identifiées par l’environnement de développement intégré (IDE) et sont souvent difficiles à déboguer et à corriger. La résolution des bogues est un processus qui prend du temps et nécessite beaucoup de débogage.

Le débogage est un processus au cours duquel on essaie de comprendre pourquoi le code écrit ne fonctionne pas comme prévu. Il est facile de résoudre le problème lorsque l’on connaît l’erreur et les lignes exactes du code où elle se produit. La journalisation est donc très utile pour le débogage du code.

Qu’est-ce que la journalisation ?

La journalisation est une technique qui permet de capturer des messages pendant l’exécution d’un programme. Il convient de ne consigner que les messages susceptibles de faciliter le débogage. Il est donc extrêmement important de savoir quand ajouter des instructions de journalisation au code. Il est également essentiel de savoir différencier les instructions de journalisation. Il existe différents niveaux de journalisation, tels que info, warn, error, debug et verbose. Les déclarations d’erreur et d’avertissement sont utilisées pour la gestion des exceptions.

Les données renvoyées par les fonctions, les résultats de la manipulation de tableaux, les données extraites des API, etc. sont autant d’exemples de données qui peuvent être enregistrées à l’aide des instructions info. Les journaux debug et verbose sont utilisés pour donner une description détaillée des erreurs.

Le journal de débogage donne des informations sur la trace de la pile, les paramètres d’entrée-sortie, etc. le journal “Verbose” n’est pas aussi détaillé que le journal “debug”, mais il donne une liste de tous les événements qui se sont produits. Les journaux sont écrits dans la console, les fichiers et le flux de sortie. Des outils de gestion des journaux peuvent être utilisés pour structurer et formater les journaux.

Journalisation Node.js

Nodejs est un environnement d’exécution javascript. Les applications Node.js sont asynchrones et non bloquantes, et sont utilisées dans des systèmes à forte intensité de données et en temps réel. La meilleure façon d’en savoir plus sur Nodejs est de consulter les tutoriels Nodejs et sa documentation. La journalisation est nécessaire pour améliorer les performances, le dépannage et le suivi des erreurs. La journalisation dans Node.js peut être réalisée à l’aide de la fonction intégrée console.log. De plus, la fonction de débogage est liée à plusieurs paquets et peut être utilisée efficacement.

L’intergiciel est utilisé pour gérer les demandes et les réponses. Il peut s’agir d’une application ou de tout autre cadre Javascript. L’enregistrement dans l’intergiciel peut se faire par le biais d’applications et de routeurs. Tout logger Node.js doit utiliser la commande npm ou yarn install pour installer les loggers.

Npm signifie “Node Package Manager” et YARN signifie “Yet Another Resource Negotiator”. Cependant, Yarn est préféré à npm car il est plus rapide et installe les paquets en parallèle.

Vous trouverez ci-dessous quelques-uns des meilleurs loggers Node.js :

Pino

Pino est une bibliothèque qui est l’un des meilleurs loggers pour les applications Node.js. Elle est open source, extrêmement rapide et enregistre les déclarations dans un format JSON facile à lire. Les niveaux de journalisation de Pino sont les suivants : debug, warn, error et info. Une instance de logger Pino peut être importée dans le projet, et les instructions console.log doivent être remplacées par des instructions logger.info.

Utilisez la commande suivante pour installer Pino :

$ npm install pino  

Les journaux générés sont élaborés et au format JSON, mettant en évidence le numéro de ligne du journal, le type de journal, l’heure à laquelle il a été enregistré, etc. Pino génère un minimum de logs dans une application et est extrêmement flexible dans le traitement des logs.

Pino peut être intégré à des frameworks web tels que Hapi, Restify, Express, etc. Les journaux générés par Pino peuvent également être stockés dans des fichiers. Il utilise des threads Worker pour fonctionner et est compatible avec TypeScript.

Winston

Winston prend en charge la journalisation pour divers frameworks web en mettant l’accent sur la flexibilité et l’extensibilité. Il prend en charge plusieurs types de transport et peut stocker les journaux dans différents emplacements de fichiers. Les transports sont des endroits où les messages de log sont stockés.

Outre les transports intégrés tels que Http, Console, File et Stream, il prend en charge d’autres transports tels que Cloud watch et MongoDB. Il effectue la journalisation sous différents niveaux et formats. Les niveaux de journalisation indiquent la gravité du problème.

Les différents niveaux de journalisation sont indiqués ci-dessous :

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

Le format de sortie des journaux peut également être personnalisé, filtré et combiné. Les journaux contiennent des informations sur l’horodatage, les étiquettes associées à un journal, les millisecondes écoulées depuis le journal précédent, etc.

Winston gère également les exceptions et les promesses non capturées. Winston gère également les exceptions et les promesses non capturées. Il fournit des fonctionnalités supplémentaires telles que l’archivage de l’exécution des requêtes, les journaux en continu, etc. Tout d’abord, il faut installer Winston. Ensuite, un objet de configuration Winston, avec transport, est créé pour stocker le journal. Un objet logger est créé à l’aide de la fonction createLogger(), et le message de log lui est transmis.

Node-Bunyan

Bunyan est utilisé pour la journalisation rapide dans node.js au format JSON. Il fournit également un outil CLI (Command Line Interface) pour visualiser les logs. Il est léger et prend en charge divers environnements d’exécution tels que Node.js, Browserify, WebPack et NW.js. Le format JSON des journaux est embelli à l’aide de la fonction pretty printing. Les journaux ont différents niveaux comme fatal, error, warn, info, debug et trace ; chacun est associé à une valeur numérique.

Tous les niveaux supérieurs au niveau défini pour l’instance sont enregistrés. Le flux Bunyan est un endroit où les sorties sont enregistrées. Les sous-composants d’une application peuvent être enregistrés à l’aide de la fonction log.child(). Tous les loggers enfants sont liés à une application parent spécifique. Le type de flux peut être un fichier, un fichier tournant, des données brutes, etc. L’exemple de code pour définir un flux est présenté ci-dessous :

var bunyan = require('bunyan') ;
var log = bunyan.createLogger({
 name : "foo",
 streams : [
 {
 stream : process.stderr,
 level : "debug"
 },
...
   ]
}) ;

Bunyan prend également en charge la journalisation DTrace. Les sondes impliquées dans la journalisation DTrace sont log-trace, log-warn, log-error, log-info, log-debug et log-fatal. Bunyan utilise des sérialiseurs pour produire les journaux au format JSON. Les fonctions de sérialisation ne lèvent pas d’exceptions et sont défensives.

Niveau de journalisation

Loglevel est utilisé pour la journalisation dans les applications Javascript. C’est aussi l’un des meilleurs loggers de Node.js car il est léger et simple. Il enregistre le niveau donné et utilise un seul fichier sans dépendances pour l’enregistrement. Le niveau de journalisation par défaut est “warn” Les sorties de log sont bien formatées avec des numéros de ligne. Les méthodes utilisées pour la journalisation sont trace, debug, warn, error et info.

Elles résistent aux pannes dans n’importe quel environnement. getLogger() est la méthode utilisée pour récupérer l’objet logger. Il peut être combiné avec d’autres plugins afin d’étendre ses fonctionnalités. Parmi ces plugins, citons loglevel-plugin-prefix, loglevel-plugin-remote, ServerSend et DEBUG. Le plugin permettant d’ajouter des messages de préfixe à la journalisation est illustré ci-dessous :

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()) ; // Assurez-vous d'appeler la méthode setLevel afin d'appliquer le plugin

Les builds sont exécutés à l’aide de la commande npm run dist, et les tests peuvent être exécutés à l’aide de la commande npm test. Loglevel prend en charge les paquets Webjar, Bower et Atmosphere. Une nouvelle version de Loglevel est publiée chaque fois que de nouvelles fonctionnalités sont ajoutées.

Signale

Signale est composé de 19 loggers pour les applications Javascript. Il prend en charge TypeScript et l’enregistrement des données. Il se compose de minuteurs qui aident à enregistrer l’horodatage, les données et le nom du fichier. En plus des 19 loggers tels que await, complete, fatal, fav, info, etc., il est possible de créer des logs personnalisés.

Les journaux personnalisés sont créés en définissant un objet JSON et des champs avec les données du journal. Il est également possible de créer des enregistreurs interactifs. Lorsqu’un enregistreur interactif est défini comme vrai, les nouvelles valeurs des enregistreurs interactifs remplacent les anciennes.

La meilleure partie de Signale est la capacité de filtrer les informations secrètes ou sensibles. Plusieurs secrets sont stockés dans un tableau. addSecrets() et clearSecrets() sont les fonctions utilisées pour ajouter et effacer les secrets du tableau. Boostnote, Docz, Shower, Taskbook et Vant utilisent Signale pour la journalisation. La syntaxe pour appeler les API à partir de Signale est la suivante :

signale.<logger>(message[,message]|messageObj|errorObj)

Le nombre de téléchargements de Signale est supérieur à 1 million au moment de la rédaction de cet article.

Tracer

Tracer est utilisé pour produire des messages de journalisation détaillés. Les messages de journalisation consistent en des horodatages, des noms de fichiers, des numéros de lignes et des noms de méthodes. Des paquets d’aide peuvent être installés pour personnaliser le format de journalisation de la sortie. Les paquets d’aide peuvent être installés à l’aide de la commande suivante.

 npm install -dev tracer

Tracer prend en charge le transport de fichiers, de flux et de MongoDB. Il prend en charge la console de couleur et les conditions de filtrage dans la journalisation. Dans un premier temps, le traceur doit être installé à l’aide de la commande npm install. Ensuite, un objet logger doit être créé et le type de console doit être sélectionné. Ensuite, les différents niveaux ou types de logs peuvent être spécifiés sur l’objet pour la suite de la journalisation.

Des filtres personnalisés peuvent être créés en définissant des fonctions synchrones avec la logique métier présente dans le corps de la fonction. Des micro-modèles comme tinytim peuvent également être utilisés pour la journalisation du système.

Cabin.js

Cabin est utilisé pour la journalisation côté serveur et client des applications node.js. Il est utilisé lorsqu’il est nécessaire de masquer des informations sensibles et critiques. Il s’agit notamment des numéros de carte de crédit, des en-têtes BasicAuth, des sels, des mots de passe, des jetons CSRF et des numéros de compte bancaire. L’extrait de code ci-dessous montre la journalisation à l’aide de Cabin.js.

const Cabin = require('cabin') ;
const cabin = new Cabin() ;
cabin.info('hello world') ;
cabin.error(new Error('oops!')) ;

Il comprend plus de 1600 noms de champs. Il suit également le principe du “Bring Your Own Logger” (BYOL). Cela le rend compatible avec d’autres loggers tels que Axe, Pino, Bunyan, Winston, etc. Il réduit les coûts de stockage sur les disques grâce aux tampons automatiques des flux et des cabines. Il est compatible avec plusieurs plateformes et facile à déboguer.

La journalisation côté serveur nécessite l’utilisation d’un logiciel intermédiaire pour le routage et la journalisation automatique des sorties. La journalisation côté navigateur nécessite des requêtes XHR et des scripts. Il utilise Axe qui affiche des métadonnées, c’est-à-dire des données sur les données, des traces de pile et d’autres erreurs. SHOW_STACK et SHOW_META sont des variables booléennes auxquelles on attribue la valeur true ou false pour afficher ou masquer les traces de pile et les métadonnées.

Npmlog

Npmlog est un type de logger de base utilisé par npm. Certaines des méthodes de journalisation utilisées sont level, record, maxRecordSize, prefixStyle, heading et stream. Il prend également en charge la journalisation colorée. Les différents niveaux de journalisation sont silly, verbose, info, warn, http et error. Vous trouverez ci-dessous un exemple de code pour l’utilisation de npm log.

var log = require('npmlog')

// additional stuff --------------------------- 
// message ---------- |
// prefix ---- | |
// level - | |
// v v v v
 log.info('fyi', 'I have a kitty cat : %j', myKittyCat)

Tous les messages sont supprimés si “Infinity” est spécifié comme niveau de journalisation. Si “-Infinity” est spécifié comme niveau de journalisation, l’option permettant de voir les messages de journalisation doit être activée pour voir les journaux.

Les objets événements et messages sont utilisés pour la journalisation. Les messages de préfixe sont émis lorsque des événements de préfixe sont utilisés. Les objets de style sont utilisés pour formater les journaux, comme l’ajout de couleur au texte et à l’arrière-plan, le style de police comme gras, italique, souligné, etc. Certains paquets de logs npm sont brolog, npmlogger, npmdate log, etc.

Roarr

Roarr est un logger pour Node.js qui ne nécessite pas d’initialisation et produit des données structurées. Il dispose d’un CLI et de variables environnementales. Il est compatible avec les navigateurs. Il peut être intégré avec Fastify, Fastify, Elastic Search, etc. Il peut faire la distinction entre le code de l’application et le code de la dépendance. Chaque message de journal se compose d’un contexte, d’un message, d’une séquence, d’une heure et d’une version. Les différents niveaux de journalisation comprennent trace, debug, info, warn, error et fatal. Voici un exemple d’extrait de code montrant comment la journalisation est effectuée dans Roarr :

import {
 ROARR,
} from 'roarr' ;

ROARR.write = (message) => {
 console.log(JSON.parse(message)) ;
} ;

Il est également possible de sérialiser les erreurs, ce qui signifie que l’instance contenant l’erreur peut être enregistrée avec le contexte de l’objet. Certaines des variables d’environnement spécifiques à Node.js et à Roarr sont ROARR_LOG et ROARR_STREAM. “adopt” est une fonction utilisée avec node.js pour transmettre les propriétés du contexte à différents niveaux. Les fonctions enfant peuvent également être utilisées avec des intergiciels, lors de la journalisation.

Mot de la fin

La journalisation est une méthode qui permet de garder la trace de diverses activités et événements au cours de l’exécution d’un programme. La journalisation joue un rôle essentiel dans le débogage du code. Elle permet également d’améliorer la lisibilité du code. Node.js est un environnement d’exécution javascript open-source. Parmi les meilleurs loggers Node.js, citons Pino, Winston, Bunyan, Signale, Tracer, Npmlog, etc. Chaque type de logger possède ses propres fonctionnalités telles que le profilage, le filtrage, le streaming et le transport.

Certains enregistreurs prennent en charge des consoles colorées et d’autres sont adaptés à la manipulation d’informations sensibles. Des journaux détaillés et formatés sont d’une grande aide pour les développeurs lorsqu’ils tentent de corriger les bogues dans leur code. Le format JSON est généralement préféré pour la journalisation, car il enregistre les données sous la forme de paires clé-valeur, ce qui le rend convivial.

Les enregistreurs peuvent également être intégrés à d’autres applications et sont compatibles avec plusieurs navigateurs. Il est toujours conseillé d’examiner les besoins et les applications que vous créez avant de choisir le type d’enregistreur que vous souhaitez utiliser.

Vous pouvez également regarder comment installer Node.js et NPM sur Windows et macOS.