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

Rencontrez-vous des difficultés lors du débuggage de votre code ? Êtes-vous à la recherche de solutions d'enregistrement qui pourraient simplifier ce processus ? Poursuivez votre lecture pour en savoir davantage.

Le développement de logiciels englobe plusieurs étapes : la collecte des besoins, l'analyse, le codage, les tests et la maintenance. Parmi ces phases, la phase de codage/développement est souvent la plus chronophage et exigeante en efforts. Les ingénieurs logiciels sont confrontés à divers types d'erreurs, telles que les erreurs de syntaxe, les erreurs logiques et les erreurs d'exécution. Les erreurs de syntaxe sont détectées lors de la compilation, car le code ne respecte pas les règles du langage de programmation utilisé.

En revanche, les erreurs logiques et d'exécution, qui ne sont pas identifiables par l'environnement de développement intégré (IDE), sont souvent plus complexes à déboguer et à corriger. La résolution de ces bogues peut être un processus long et nécessiter de nombreux efforts de débuggage.

Le débuggage est une démarche qui vise à comprendre pourquoi un code ne fonctionne pas comme prévu. Il est plus simple de résoudre un problème lorsque l'erreur et les lignes de code concernées sont clairement identifiées. C'est là que l'enregistrement de journaux (ou "logging") devient précieux.

Qu'est-ce que l'enregistrement de journaux ?

L'enregistrement de journaux est une technique qui consiste à capturer des messages pendant l'exécution d'un programme. Seuls les messages qui peuvent être utiles lors du débuggage doivent être enregistrés. Il est donc crucial de savoir quand insérer des instructions de journalisation dans le code, et de faire la distinction entre différents types de journaux. Il existe plusieurs niveaux de journalisation, tels que "info", "warn", "error", "debug" et "verbose". Les instructions "error" et "warn" sont souvent utilisées pour la gestion des exceptions.

Les données retournées par les fonctions, les résultats des manipulations de tableaux, les données extraites d'API, sont autant d'exemples de données qui peuvent être enregistrées à l'aide d'instructions "info". Les journaux de type "debug" et "verbose" servent à fournir une description détaillée des erreurs.

Le journal "debug" peut inclure des informations telles que la trace de la pile ou les paramètres d'entrée/sortie. "Verbose", moins détaillé que "debug", liste les événements qui se sont produits. Les journaux peuvent être enregistrés dans la console, dans des fichiers ou dans un flux de sortie. Des outils de gestion de journaux permettent de structurer et de formater l'enregistrement de manière plus efficace.

Journalisation avec Node.js

Node.js est un environnement d'exécution JavaScript. Les applications Node.js, asynchrones et non bloquantes, sont couramment utilisées dans les systèmes de gestion de données en temps réel. Pour mieux comprendre Node.js, il est conseillé de consulter sa documentation et des tutoriels. La journalisation joue un rôle essentiel dans l'amélioration des performances, le dépannage et le suivi des erreurs. Il est possible de faire de la journalisation en utilisant la fonction intégrée `console.log`. Plusieurs bibliothèques permettent également une utilisation plus avancée de la journalisation.

Les middlewares sont utilisés pour gérer les requêtes et les réponses. Un middleware peut être une application ou un framework JavaScript. La journalisation dans le middleware peut être effectuée via des applications ou des routeurs. Pour utiliser un outil de journalisation Node.js, il faut généralement l'installer à l'aide de la commande `npm` ou `yarn install`.

Npm signifie "Node Package Manager" et YARN signifie "Yet Another Resource Negotiator". Yarn est souvent préféré à npm pour sa rapidité et sa capacité à installer les packages en parallèle.

Voici quelques-uns des meilleurs outils de journalisation pour Node.js :

Pino

Pino est une bibliothèque open source, reconnue pour sa rapidité et son efficacité dans le domaine de la journalisation pour les applications Node.js. Elle enregistre les informations au format JSON, facile à lire et à interpréter. Pino utilise plusieurs niveaux de journalisation tels que "debug", "warn", "error" et "info". Une instance de l'outil Pino peut être importée dans un projet, et les instructions `console.log` sont remplacées par des instructions `logger.info`.

Pour installer Pino, utilisez la commande suivante :

$ npm install pino

Les journaux générés par Pino sont détaillés, au format JSON et incluent des informations comme le numéro de ligne, le type de journal et l'heure d'enregistrement. Pino est conçu pour minimiser l'impact sur les performances d'une application et offre une grande flexibilité dans le traitement des logs.

Pino peut être intégré à des frameworks web tels que Hapi, Restify ou Express. Les journaux peuvent également être sauvegardés dans des fichiers. Pino utilise des "threads" de travail pour son fonctionnement et est compatible avec TypeScript.

Winston

Winston est une bibliothèque qui prend en charge la journalisation pour plusieurs frameworks web en mettant l'accent sur la flexibilité et l'extensibilité. Il prend en charge différents types de transport, ce qui signifie qu'il peut enregistrer les logs dans divers emplacements de fichiers. Les transports sont des endroits où sont stockés les messages de journaux.

En plus des transports intégrés comme Http, Console, File et Stream, Winston supporte d'autres options comme Cloud Watch ou MongoDB. Winston utilise différents niveaux et formats pour la journalisation. Les niveaux de journalisation indiquent la gravité d'un 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 logs incluent des informations sur l'horodatage, les étiquettes associées à un journal, les millisecondes écoulées depuis le log précédent.

Winston gère également les exceptions et les promesses non tenues. Il offre des fonctionnalités supplémentaires comme l'archivage de requêtes, la diffusion en continu des logs, etc. Pour utiliser Winston, il faut d'abord l'installer. Ensuite, un objet de configuration Winston, incluant 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 au format JSON dans Node.js. Il inclut un outil en ligne de commande (CLI) pour visualiser les logs. Il est léger et prend en charge plusieurs environnements d'exécution comme Node.js, Browserify, WebPack et NW.js. Le format JSON des logs peut être amélioré à l'aide de la fonction d'impression "pretty". Les journaux peuvent avoir différents niveaux comme "fatal", "error", "warn", "info", "debug" et "trace", chacun étant 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 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. Voici un exemple de code pour définir un flux :

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 utilisées pour la journalisation DTrace incluent "log-trace", "log-warn", "log-error", "log-info", "log-debug" et "log-fatal". Bunyan utilise des sérialiseurs pour produire des logs au format JSON. Les fonctions de sérialisation sont conçues pour ne pas générer d'exceptions.

Loglevel

Loglevel est utilisé pour la journalisation dans les applications JavaScript. C'est un outil léger et simple d'utilisation pour Node.js. Il enregistre le niveau donné en utilisant un seul fichier sans dépendances pour la journalisation. Le niveau de journalisation par défaut est "avertissement" (warn). Les sorties de journal sont bien formatées et incluent les numéros de ligne. Quelques méthodes utilisées pour la journalisation incluent "trace", "debug", "warn", "error" et "info".

Ces méthodes sont résistantes aux erreurs dans tous les environnements. La méthode `getLogger()` sert à récupérer l'objet logger. Il est également possible de combiner Loglevel avec des plugins pour étendre ses fonctionnalités. Certains plugins incluent `loglevel-plugin-prefix`, `loglevel-plugin-remote`, `ServerSend` et `DEBUG`. Voici un exemple de plugin qui permet d'ajouter des préfixes aux messages de journalisation :

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 avec la commande `npm run dist` et les tests peuvent être effectués avec `npm test`. Loglevel prend en charge les packages Webjar, Bower et Atmosphere. Une nouvelle version de Loglevel est publiée lorsqu'il y a de nouvelles fonctionnalités à ajouter.

Signale

Signale est une bibliothèque de 19 outils de journalisation pour les applications JavaScript. Elle prend en charge TypeScript et la journalisation étendue. Elle utilise des minuteries pour enregistrer l'horodatage, les données et le nom de fichier. En plus des 19 outils comme "await", "complete", "fatal", "fav" et "info", 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 du logger. Des enregistreurs interactifs peuvent également être créés. Si un enregistreur interactif est activé, les nouvelles valeurs remplacent les anciennes.

Une fonctionnalité importante de Signale est sa capacité à filtrer les informations secrètes ou sensibles. Ces informations sont stockées dans un tableau. Les fonctions `addSecrets()` et `clearSecrets()` permettent d'ajouter et de supprimer des secrets du tableau. Signale est utilisé par des projets comme Boostnote, Docz, Shower, Taskbook et Vant. Voici la syntaxe pour appeler les API de Signale :

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

Signale compte plus d'un million de téléchargements au moment de la rédaction de cet article.

Tracer

Tracer sert à produire des messages de journalisation détaillés. Ces messages comprennent l'horodatage, les noms de fichiers, les numéros de ligne et les noms de méthodes. Des packages d'assistance peuvent être installés pour personnaliser le format de sortie du journal. On peut les installer à l'aide de la commande suivante :

npm install -dev tracer

Tracer supporte le transport de fichiers, de flux et MongoDB. Il prend en charge la console de couleur et les conditions de filtrage dans la journalisation. Pour commencer, il faut installer Tracer à l'aide de `npm install`. Ensuite, un objet logger doit être créé et le type de console sélectionné. Ensuite, les différents niveaux de journalisation peuvent être spécifiés sur l'objet pour une utilisation 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 système.

Cabin.js

Cabin est utilisé pour la journalisation côté serveur et côté client des applications Node.js. Il est utilisé quand il est nécessaire de masquer des informations sensibles telles que les numéros de carte de crédit, les en-têtes "BasicAuth", les mots de passe, les "tokens" CSRF ou les numéros de compte bancaire. Voici un extrait de code montrant comment utiliser 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 le principe "Bring Your Own Logger" (BYOL). Cela le rend compatible avec divers autres outils de journalisation comme Axe, Pino, Bunyan et Winston. Cabin réduit les coûts de stockage sur disque grâce au flux automatique et aux tampons Cabin. Il est 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 XHR et des scripts. 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.

Npmlog

Npmlog est un outil de journalisation basique utilisé par npm. Les méthodes de journalisation utilisées incluent "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". Voici un exemple d'extrait de code montrant l'utilisation de Npmlog :

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é, il faut activer l'option pour voir les messages de journalisation afin de pouvoir les visualiser.

Des événements et des 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. Des objets de style sont utilisés pour formater les logs, comme ajouter de la couleur au texte et à l'arrière-plan ou utiliser des styles comme le gras, l'italique ou le soulignement. On trouve divers packages npm de journalisation comme brolog, npmlogger, ou npmdate log.

Roarr

Roarr est un enregistreur pour Node.js qui ne nécessite pas d'initialisation et produit des données structurées. Il utilise une interface de ligne de commande (CLI) et des variables d'environnement. Il est compatible avec les navigateurs et peut être intégré à des outils comme Fastify ou Elastic Search. 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 sont "trace", "debug", "info", "warn", "error" et "fatal". Voici un exemple d'extrait de code montrant la journalisation effectuée par Roarr :

import {
  ROARR,
} from 'roarr';

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

Roarr peut également gérer la sérialisation des erreurs. Cela signifie que l'instance de l'erreur peut être enregistrée avec le contexte de l'objet. Les 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. Des fonctions enfants peuvent également être utilisées avec le middleware pendant la journalisation.

En conclusion

La journalisation est un moyen de suivre les différentes activités et événements qui se produisent pendant l'exécution d'un programme. Elle joue un rôle essentiel dans le débuggage du code et permet d'améliorer sa lisibilité. Node.js est un environnement d'exécution JavaScript open source. Parmi les meilleurs outils de journalisation pour Node.js, on trouve Pino, Winston, Bunyan, Signale, Tracer et Npmlog. Chaque outil possède ses propres fonctionnalités comme le profilage, le filtrage, le streaming et le transport.

Certains outils de journalisation prennent en charge les consoles colorées et d'autres sont plus adaptés au traitement d'informations sensibles. Des logs détaillés et bien formatés sont particulièrement utiles pour les développeurs lorsqu'ils doivent corriger des bogues dans leur code. Le format JSON est souvent préféré pour la journalisation car il enregistre les données sous forme de paires clé-valeur, ce qui facilite leur interprétation.

Les outils de journalisation peuvent également être intégrés à d'autres applications et sont compatibles avec plusieurs navigateurs. Il est toujours conseillé de bien évaluer les besoins et les applications que vous construisez avant de choisir un outil de journalisation spécifique.

Vous pouvez également consulter des tutoriels pour savoir comment installer Node.js et NPM sous Windows et macOS.