9 bibliothèques de journalisation Node.js que vous pouvez essayer pour une meilleure journalisation

Avez-vous du mal à déboguer votre code ? Recherchez-vous des solutions de journalisation qui pourraient faciliter le débogage ? Continuez à lire pour en savoir plus.

Le développement logiciel passe par plusieurs phases : collecte des exigences, analyse, codage, test et maintenance. Parmi toutes ces phases, la phase de codage/développement demande beaucoup de temps et d'efforts. Les ingénieurs logiciels traitent les erreurs de syntaxe, les erreurs logiques et les erreurs d'exécution. Les erreurs syntaxiques sont identifiées au moment de la compilation et se produisent parce que le code ne respecte pas les règles d'un langage de programmation.

D'autre part, 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 dans lequel on essaie de comprendre pourquoi le code écrit ne fonctionne pas comme prévu. Il est facile de résoudre le problème lorsque nous connaissons l'erreur et les lignes exactes du code où elle se produit. Par conséquent, la journalisation est très utile pour le débogage du code.

Qu'est-ce que la journalisation ?

La journalisation est une technique dans laquelle les messages sont capturés pendant l'exécution d'un programme. On doit enregistrer uniquement ces messages, ce qui pourrait les aider dans le débogage. Il est donc extrêmement important de savoir quand ajouter des instructions de journal au code. En outre, la différenciation entre les instructions de journal est tout aussi essentielle. Il existe différents niveaux de journalisation, tels que info, warn, error, debug et verbose. Les instructions d'erreur et d'avertissement sont utilisées pour la gestion des exceptions.

Les données renvoyées par les fonctions, les résultats après manipulation du tableau, les données extraites des API, etc., sont quelques exemples de données pouvant être enregistrées à l'aide d'instructions info. Les journaux de débogage et détaillés 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. "Verbose" n'est pas aussi détaillé que le journal "debug" mais 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. Les outils de gestion des journaux peuvent être utilisés pour une journalisation structurée et formatée.

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 les systèmes gourmands en données et en temps réel. La meilleure façon d'en savoir plus sur Node.js est de parcourir les didacticiels Node.js et sa documentation. La journalisation est nécessaire pour améliorer les performances, le dépannage et le suivi des erreurs. La connexion à Node.js peut être effectuée à l'aide de la fonction intégrée console.log. En outre, la fonction de débogage est liée à plusieurs packages et peut être utilisée efficacement.

Le middleware est utilisé pour gérer les demandes et les réponses. Le middleware peut être une application ou tout autre framework Javascript. La connexion au middleware peut être effectuée via des applications et des routeurs. Tout enregistreur Node.js doit utiliser la commande npm ou yarn install pour installer les enregistreurs.

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 packages en parallèle.

Certains des meilleurs enregistreurs Node.js sont répertoriés ci-dessous :

pino

Pino est une bibliothèque qui est l'un des meilleurs enregistreurs pour les applications Node.js. Il est open source, extrêmement rapide et enregistre les déclarations dans un format JSON facile à lire. Certains des niveaux de journal Pino sont les messages de débogage, d'avertissement, d'erreur et d'information. Une instance d'enregistreur 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 entraîne une journalisation minimale dans une application et est extrêmement flexible lors du traitement des journaux.

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 de travail pour le fonctionnement 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 divers emplacements de fichiers. Les transports sont des endroits où les messages du journal sont stockés.

Outre certains 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 fait 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 du journal peut également être personnalisé, filtré et combiné. Les journaux incluent 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 tenues. Il fournit des fonctionnalités supplémentaires telles que le dépôt de requêtes, les journaux de diffusion en continu, etc. Tout d'abord, il faut installer Winston. Ensuite, un objet de configuration Winston, avec le transport, est créé pour stocker le journal. Un objet logger est créé à l'aide de la fonction createLogger() et le message de journal lui est transmis.

Node-Bunyan

Bunyan est utilisé pour une journalisation rapide dans node.js au format JSON. Il fournit également un outil CLI (Command Line Interface) pour afficher les journaux. 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 encore embelli à l'aide de la jolie fonction d'impression. 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 consigné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 enregistreurs enfants sont liés à une application parent spécifique. Le type de flux peut être un fichier, un fichier rotatif, des données brutes, etc. L'exemple de code permettant de 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 incluent 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 génèrent pas d'exceptions et sont défensives.

Niveau de journalisation

Loglevel est utilisé pour la journalisation dans les applications Javascript. C'est également l'un des meilleurs enregistreurs Node.js car il est léger et simple. Il enregistre le niveau donné et utilise un seul fichier sans dépendances pour la journalisation. Le niveau de journalisation par défaut est « avertissement ». Les sorties de journal sont bien formatées avec les numéros de ligne. Certaines méthodes utilisées pour la journalisation sont trace, debug, warn, error et info.

Ils sont résistants à l'échec dans n'importe quel environnement. getLogger() est la méthode utilisée pour récupérer l'objet logger. Il peut également être combiné avec d'autres plugins pour étendre ses fonctionnalités. Certains des plugins incluent loglevel-plugin-prefix, loglevel-plugin-remote, ServerSend et DEBUG. Le plug-in permettant d'ajouter des messages de préfixe à la journalisation est présenté 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()); // Be sure to call setLevel method in order to apply 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. Le niveau de journalisation prend en charge les packages Webjar, Bower et Atmosphere. Une nouvelle version de Loglevel est publiée chaque fois que de nouvelles fonctionnalités sont ajoutées.

Signaux

Signale se compose de 19 loggers pour les applications Javascript. Il prend en charge TypeScript et la journalisation étendue. Il se compose de minuteries qui aident à enregistrer l'horodatage, les données et le nom de fichier. Outre les 19 enregistreurs tels que await, complete, fatal, fav, info, etc., il est possible de créer des journaux personnalisés.

Les journaux personnalisés sont créés en définissant un objet JSON et des champs avec les données de l'enregistreur. Des enregistreurs interactifs peuvent également être créés. Lorsqu'un enregistreur interactif est défini sur 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 depuis Signale est la suivante :

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

Le nombre de téléchargements de Signale dépasse le million au moment de la rédaction de cet article.

Traceur

Tracer est utilisé pour produire des messages de journalisation détaillés. Les messages de journalisation se composent d'horodatages, de noms de fichiers, de numéros de ligne et de noms de méthodes. Des packages d'assistance peuvent être installés pour personnaliser le format de journalisation de sortie. Les packages d'assistance 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 MongoDB. Il prend en charge la console de couleur et les conditions de filtre dans la journalisation. Initialement, le traceur doit être installé à l'aide de npm install. Deuxièmement, un objet logger doit être créé et le type de console doit être sélectionné. Ensuite, les différents niveaux ou types de journalisation peuvent être spécifiés sur l'objet pour une journalisation ultérieure.

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 côté client des applications node.js. Il est utilisé lorsque le masquage d'informations sensibles et critiques est requis. Cela inclut les numéros de carte de crédit, les en-têtes BasicAuth, les sels, les mots de passe, les jetons CSRF et les 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 se compose de plus de 1600 noms de champs. Il suit également le principe de Bring Your Own Logger (BYOL). Cela le rend compatible avec divers autres enregistreurs comme Axe, Pino, Bunyan, Winston, etc. Il réduit les coûts de stockage sur disques grâce au flux automatique et aux tampons Cabin. Il est compatible multiplateforme et facile à déboguer.

La journalisation côté serveur nécessite l'utilisation d'un middleware pour le routage et la journalisation automatique des sorties. La journalisation côté navigateur nécessite des requêtes et des scripts XHR. Il utilise Ax 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 définies sur true ou false pour afficher ou masquer les traces de pile et les métadonnées.

NpmlogName

Npmlog est un type de journal de base utilisé par npm. Certaines des méthodes de journalisation utilisées sont level, record, maxRecordSize, prefixStyle, header 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. Un exemple d'extrait de code pour l'utilisation du journal npm est présenté ci-dessous.

 var log = require('npmlog') // additional stuff ---------------------------+ // message ----------+ | // prefix ----+ | | // level -+ | | | // vvvv 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 événements et les objets de message sont utilisés pour la journalisation. Des 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 ajouter de la couleur au texte et à l'arrière-plan, un style de police comme le gras, l'italique, le soulignement, etc. Certains packages de journaux npm sont brolog, npmlogger, npmdate log, etc.

Rugir

Roarr est un enregistreur pour Node.js qui ne nécessite pas d'initialisation et produit des données structurées. Il a CLI et variables environnementales. Il est compatible avec les navigateurs. Il peut être intégré à Fastify, Fastify, Elastic Search, etc. Il peut faire la distinction entre le code d'application et le code de 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 incluent la trace, le débogage, les informations, l'avertissement, l'erreur et la fatalité. Voici un exemple d'extrait de code expliquant comment la journalisation est effectuée par Roarr :

 import { ROARR, } from 'roarr'; ROARR.write = (message) => { console.log(JSON.parse(message)); };

En outre, la sérialisation des erreurs peut être effectuée, ce qui signifie que l'instance avec 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 de contexte à différents niveaux. Les fonctions enfants peuvent également être utilisées avec le middleware lors de la journalisation.

Derniers mots

La journalisation est une méthode de suivi de diverses activités et événements pendant l'exécution d'un programme. La journalisation joue un rôle essentiel dans le débogage du code. Cela aide également à augmenter la lisibilité du code. Node.js est un environnement d'exécution javascript open source. Certains des meilleurs enregistreurs Node.js sont Pino, Winston, Bunyan, Signale, Tracer, Npmlog, etc. Chaque type d'enregistreur possède ses propres fonctionnalités telles que le profilage, le filtrage, le streaming et le transport.

Certains enregistreurs prennent en charge les consoles colorées et certains conviennent au traitement d'informations sensibles. Les journaux détaillés et formatés aident le plus 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 construisez avant de choisir le type d'enregistreur que vous souhaitez utiliser.

Vous pouvez également voir comment installer Node.js et NPM sous Windows et macOS.