Ce blog discutera de la valeur de l'utilisation des bibliothèques de journalisation et présentera les 10 outils de journalisation les mieux évalués que nous avons rencontrés pour Node.js. Chez @playerzero, nous utilisons souvent les bibliothèques de journalisation node.js pour créer et gérer les événements de journalisation. Découvrez comment nous apportons aujourd'hui notre approche unique pour surveiller ce qui compte pour les applications frontales et dorsales https://www.playerzero.app/

• pino

• Winston

• Bunyan

• Morgan

• Niveau de journalisation

• Log4js

• NpmlogName

• Rugir

• Traceur

• Signaux

  
  

D'un point de vue général, la journalisation Node.js est importante car elle aide les développeurs à suivre les événements et les performances de leur application, à diagnostiquer et à résoudre les problèmes, à surveiller le comportement du système et à prendre des décisions éclairées. La journalisation fournit un enregistrement de l'activité d'une application, permettant aux développeurs d'identifier et de déboguer les problèmes, de comprendre le comportement des utilisateurs et d'améliorer les performances et la stabilité globales du système. La journalisation peut également être utile dans les environnements de production pour détecter et corriger les erreurs, surveiller les performances du système et détecter les incidents de sécurité.

Journalisation vs traçage

Chaque fois que quelque chose ne va pas dans une application, les développeurs ont la possibilité de retrouver sa source via une trace de pile. Mais… se fier uniquement aux traces de la pile ne peint qu'une demi-image. Le traçage vous fournira des informations sur l'exécution d'une application, y compris le flux de requêtes, les requêtes de base de données, les appels d'API externes et les mesures de performances - ce qui peut être très utile. En général, les traces sont utilisées pour comprendre le comportement d'une application à un niveau granulaire et pour identifier les goulots d'étranglement des performances.

La journalisation remplit l'autre moitié de l'image. La journalisation est le processus d'enregistrement des messages et des événements liés à une application, tels que les erreurs, les avertissements, les mesures de performances et les informations de débogage. La connexion à Node.js est utilisée pour diagnostiquer les problèmes, comprendre le comportement des utilisateurs et améliorer les performances et la stabilité globales d'une application. Il fournit également un enregistrement de l'activité dans une application, permettant aux développeurs d'identifier et de déboguer les problèmes et de prendre des décisions plus éclairées.

Pourquoi utiliser des bibliothèques de journalisation pour Node.js ?

Il existe plusieurs raisons pour lesquelles vous devriez utiliser les bibliothèques de journalisation Node.js :

1. Débogage amélioré - les bibliothèques de journalisation fournissent des informations détaillées sur les erreurs et les problèmes, permettant aux développeurs de diagnostiquer et de résoudre les problèmes plus efficacement.
2. Visibilité améliorée - la journalisation fournit une vue claire du comportement et des performances d'une application, permettant aux développeurs de prendre des décisions éclairées et d'améliorer le système.
3. Meilleures performances - les bibliothèques de journalisation peuvent être optimisées pour les performances, réduisant ainsi la surcharge de journalisation et améliorant les performances globales du système.
4. Journalisation centralisée - de nombreuses bibliothèques de journalisation permettent d'écrire des journaux sur un serveur de journaux centralisé, ce qui facilite la collecte, l'affichage et l'analyse des données de journaux.
5. Personnalisation - les bibliothèques de journalisation peuvent être personnalisées pour répondre à des besoins spécifiques, tels que des niveaux de journalisation personnalisés, des formats de sortie et des filtres.

Niveaux de journalisation

Les niveaux de journalisation permettent de catégoriser l'importance ou la gravité des messages de journal. En règle générale, il existe plusieurs niveaux, allant des erreurs critiques aux messages d'information, et chaque niveau est associé à une valeur numérique qui peut être utilisée pour filtrer les messages de journal dans une bibliothèque. Voici les niveaux les plus courants :

Niveau de journal FATAL

Sans surprise, le niveau de journal FATAL est un niveau de gravité qui indique une erreur critique dans une application - ce qui signifie que les journaux avec un niveau FATAL indiquent que l'application ne peut pas continuer à fonctionner normalement sans l'intervention du développeur.

Niveau de journalisation ERROR

Le niveau de journalisation ERROR indique qu'une application est actuellement capable de s'exécuter, MAIS, elle rencontre un problème. Habituellement, cela indique qu'une tâche requise dans l'application a échoué - qu'il y a eu une exception, un comportement inattendu ou des entrées incorrectes.

Niveau de journalisation WARN

WARN est un niveau de journalisation moins sévère que ERROR , mais ne doit néanmoins pas être ignoré. Les journaux WARN peuvent être utilisés pour identifier de manière proactive les problèmes et empêcher les problèmes de s'aggraver, car ils indiquent qu'un élément de votre application pourrait devenir le catalyseur d'un problème plus important.

Niveau de journal INFO

Le niveau de journal INFO est un type de message de journal utilisé dans les systèmes de journalisation pour indiquer un message d'information général. Il est généralement utilisé pour consigner les événements de routine attendus dans l'application ou le système, tels que le démarrage d'un processus, l'achèvement d'une tâche ou un changement d'état du système. Ces alertes peuvent généralement être ignorées puisqu'elles sont destinées à confirmer qu'une application fonctionne correctement.

Niveau de journal DEBUG

En règle générale, le niveau de journalisation DEBUG fournit des informations strictement utiles dans le cadre du processus de débogage. Les journaux DEBUG sont le type de message de journal le plus détaillé et fournissent une vue granulaire du fonctionnement interne d'une application. L'objectif principal des journaux DEBUG est d'aider les développeurs à comprendre ce que fait le système, à identifier les bogues et les problèmes et à diagnostiquer les problèmes.

10 meilleures bibliothèques de journalisation Node.js et comment démarrer avec elles

#1. pino

Avantages Pino

Pino est un outil de journalisation établi de longue date et très populaire, avec plus de 10,9 000 étoiles Github et des millions de téléchargements sur npm. Pino est une bibliothèque de journalisation populaire pour Node.js car elle fournit plusieurs fonctionnalités clés qui la rendent bien adaptée à une utilisation dans les applications Node.js :

• Rapide - Pino est conçu pour être rapide et léger, avec un accent sur la performance. Il utilise un format binaire pour les messages de journal, ce qui lui permet de générer une sortie de journal rapidement et efficacement.

• Journaux structurés - Pino enregistre les messages au format JSON, ce qui permet une analyse, un filtrage et une analyse faciles des données de journal. Cela facilite la recherche, la visualisation et l'analyse des données de journal et l'intégration des données de journal dans d'autres systèmes.

• Facile à étendre - Pino est conçu pour être hautement extensible et comprend un certain nombre de plugins intégrés qui peuvent être utilisés pour ajouter des fonctionnalités supplémentaires, telles que l'écriture de données de journal dans un fichier ou l'envoi de données de journal à un serveur distant.

• Faible surcharge - Pino est une bibliothèque de journalisation Node.js très efficace en raison de son utilisation minimale des ressources. Le processus de journalisation avec Pino accumule progressivement les messages, entraînant un étranglement de l'application et une diminution du nombre de requêtes par seconde. La limitation est une technique dans laquelle la fonction connectée à un événement est déclenchée pour s'exécuter une seule fois dans un laps de temps spécifié, même si l'événement est déclenché plusieurs fois.

• Transports - Pino offre une variété d'options pour envoyer des journaux, y compris l'écriture dans des fichiers, l'affichage dans la console et l'utilisation de plates-formes telles que Sentry, Azure Application Insights et CouchDB.

  
  

Pour utiliser Pino dans une application Node.js, suivez ces étapes :

Installation de Pino

Pour installer Pino, installez-le simplement en exécutant la commande suivante dans un nouveau répertoire :

 npm install pino

Importer - dans votre application Node.js, importez Pino en ajoutant la ligne de code suivante en haut de votre fichier :

 const pino = require('pino');

Utilisation de Pino

Initialisation - initialisez Pino en créant une instance de logger, par exemple :

 const logger = pino({ level: 'info' });

Ce script génère des journaux avec un niveau de journalisation INFO et supérieur sur la console.

En définissant le niveau sur info, Pino enregistrera les messages avec un niveau de journalisation de INFO , WARN , ERROR et FATAL . Les messages dont le niveau de journalisation est inférieur INFO , tels que DEBUG , ne seront pas journalisés.

Ce code crée uniquement une instance d'enregistreur Pino avec le niveau de journal défini sur INFO. Aucun message de journal n'est généré ou affiché tant que vous n'avez pas consigné quelque chose à l'aide de l'instance de journalisation. Par exemple:

 logger.info('This is an info message');

Cela produirait la sortie suivante sur la console :

 {"level":30,"time":1624825088703,"msg":"This is an info message","pid":1234,"hostname":"my-machine"}

Les données consignées affichées sur la console incluent le niveau de journalisation, l'horodatage de l'enregistrement, le message consigné, un identifiant pour le journal et le nom d'hôte.

Journalisation - vous pouvez également utiliser l'instance logger pour consigner d'autres messages dans votre application. Par exemple:

 logger.warn('This is a warning message'); logger.error('This is an error message');

Sortie - par défaut, Pino se connecte à la console. Si vous souhaitez modifier la sortie, vous pouvez utiliser l'un des transports disponibles de Pino que nous avons mentionnés précédemment, comme l'écriture dans un fichier, l'envoi de journaux à un service distant comme Sentry ou l'utilisation d'Azure Application Insights. Pour plus d'informations, vous pouvez vous référer à la section "Transports connus" de Pino.

Installation de Pino jolie

La fonction de formatage NDJSON pino-pretty base de Pino est un excellent formateur simple pour les journaux Pino, et il est facile à configurer. Voici comment le faire fonctionner :

Étape 1 - installez pino-pretty en tant que dépendance dans votre projet Node.js en exécutant la commande suivante dans votre terminal :

 npm install pino-pretty

Étape 2 - importez pino-pretty dans votre application Node.js en ajoutant la ligne de code suivante en haut de votre fichier :

 const pino = require('pino'); const pinoPretty = require('pino-pretty'); const logger = pino({ level: 'info' }); logger.pipe(pinoPretty());

Avec ces deux extraits de code, vous avez installé pino-pretty et l'avez configuré pour formater vos journaux Pino. Vous pouvez maintenant utiliser l'instance de journalisation pour consigner les messages dans votre application et les journaux seront affichés dans un joli format lisible par l'homme sur la console.

Apprenez-en davantage sur le débogage avec Pino dans Comment déboguer Node.js avec les meilleurs outils disponibles par @RisingStack

#2. Winston

Avantages Winston

Avec plus de 20 000 étoiles sur GitHub, Winston est une bibliothèque de journalisation très populaire pour Node.js. Winston est une bibliothèque de journalisation unique dans l'écosystème Node.js en raison de son ensemble complet de fonctionnalités et de sa facilité d'utilisation. Certaines des raisons pour lesquelles Winston se démarque sont :

• Flexible - Winston est hautement personnalisable et fournit une variété d'options de journalisation et de mécanismes de transport qui permettent d'écrire des journaux sur plusieurs sorties, telles que la console, un fichier ou un serveur distant.
• Journaux interrogeables - Winston fournit une archive de journaux interrogeable, ce qui facilite la recherche et l'analyse des journaux.
• Facile à utiliser - Winston dispose d'une API simple et facile à utiliser qui facilite la prise en main de la journalisation dans une application Node.js. Il fournit un ensemble minimal de fonctionnalités de base, tout en permettant aux développeurs d'étendre et de personnaliser la fonctionnalité de journalisation selon les besoins.
• Bien documenté - Winston dispose d'une documentation complète qui fournit des informations détaillées sur son API et comprend un certain nombre d'exemples et de didacticiels pour aider les développeurs à démarrer rapidement et facilement.
• Piloté par la communauté - Winston est un projet open source avec une communauté de développeurs importante et active, ce qui permet de garantir que la bibliothèque est bien entretenue, sans bogue et mise à jour pour suivre les dernières tendances et technologies.

Installation de Winston

Pour installer Winston dans votre projet Node.js, vous pouvez utiliser le gestionnaire de packages npm en exécutant la commande suivante dans votre terminal :

 npm install winston

Utilisation de Winston

Une fois l'installation terminée, vous pouvez importer et utiliser Winston dans votre code Node.js en incluant la ligne suivante :

 const winston = require('winston');

Vous pouvez ensuite utiliser la bibliothèque Winston pour configurer et créer vos instances de journalisation, par exemple :

 const logger = winston.createLogger({ level: 'info', format: winston.format.json(), transports: [ new winston.transports.Console() ] });

Cela crée une instance de journalisation avec un niveau d'informations et un transport de console. Vous pouvez utiliser cette instance de journalisation pour consigner des messages dans votre application, par exemple :

 logger.info('Hello World');

Cela enregistrera le message Hello World sur la console avec le niveau de journalisation des informations.

Niveaux de journalisation dans Winston

Winston est équipé de six niveaux de journalisation par défaut, organisés conformément aux directives décrites dans le document RFC5424. Les niveaux se voient attribuer une priorité numérique, la gravité la plus élevée se voyant attribuer le numéro le plus bas. Les six niveaux et leurs valeurs de priorité respectives sont :

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

Pour chacun des six niveaux de journalisation, il existe une méthode correspondante sur l'objet logger :

 logger.error('error'); logger.warn('warn'); logger.info('info'); logger.verbose('verbose'); logger.debug('debug'); logger.silly('silly');

Vous pouvez également passer une chaîne représentant le niveau de journalisation à la méthode log() :

 logger.log('error', 'error message'); logger.log('info', 'info message');

La propriété level de l' logger détermine les messages de journal qui seront transmis aux transports que vous avez configurés. Par exemple, si la propriété level est définie sur info , seules les entrées de journal avec une gravité d' info ou supérieure seront écrites et toutes les autres seront dépriorisées. Cela signifie que dans la configuration actuelle, seuls les messages de journal avec les niveaux info , warn et error seront générés.

#3. Bunyan

Avantages Bunyan

Bunyan est une bibliothèque de journalisation unique pour Node.js en raison de son objectif de rendre les données de journal plus structurées et lisibles (ils y parviennent en sérialisant les journaux en tant qu'objets JSON plutôt qu'en texte brut). Voici pourquoi Bunyan a 7 000 étoiles sur Github :

1. Format JSON - contrairement à certaines autres bibliothèques de journalisation, Bunyan enregistre les données au format JSON, ce qui facilite l'analyse et l'intégration avec d'autres outils et plates-formes.
2. Niveaux de journalisation flexibles - Bunyan prend en charge plusieurs niveaux de journalisation avec des options flexibles pour gérer le niveau de gravité et le seuil du journal.
3. Sérialisation - Dans Bunyan, il existe une fonctionnalité appelée sérialisation, où les fonctions convertissent un objet JavaScript en un objet représentable JSON. Cela permet à une instance de journalisation spécifique d'avoir un sérialiseur qui lie un nom de champ d'enregistrement de journal à une fonction de sérialisation.
4. API facile à utiliser - Bunyan fournit une API simple et facile à utiliser pour la journalisation, la rendant accessible aux développeurs de tous niveaux.
5. Plugins et transports - Bunyan prend en charge une variété de plugins et de transports, tels que la console, le fichier, HTTP et le courrier électronique, ce qui facilite la personnalisation de la sortie de journalisation pour répondre aux besoins et exigences spécifiques.

Installation de Bunyan

Pour installer Bunyan, vous pouvez exécuter la commande suivante dans votre terminal ou invite de commande :

 npm install bunyan

Cela installera la bibliothèque Bunyan et ses dépendances dans votre projet Node.js. Une fois installée, vous pouvez exiger la bibliothèque dans votre code et commencer à l'utiliser.

Utilisation de Bunyan

Importez Bunyan dans votre projet - en haut de votre fichier JavaScript, ajoutez la ligne suivante :

 const bunyan = require('bunyan');

Créez une instance de journalisation - ensuite, créez une instance de journalisation en utilisant le code suivant :

 const logger = bunyan.createLogger({ name: 'my-app-name', level: 'info' });

Dans cet exemple, name est le nom de votre application et level spécifie le niveau minimum de journaux que vous souhaitez voir.

Consigner un message - pour consigner un message, appelez simplement l'une des méthodes de journalisation de Bunyan, telles que info, warn ou error, et transmettez le message que vous souhaitez consigner, comme ceci :

 logger.info('This is an info log message'); logger.warn('This is a warn log message'); logger.error('This is an error log message');

Exécutez votre code - enfin, exécutez votre code et vous devriez voir les messages enregistrés dans la console.

Par défaut, Bunyan génère les journaux au format JSON, ce qui facilite l'analyse et l'analyse des journaux avec des outils de gestion des journaux. Vous pouvez également personnaliser le format à l'aide de l'option de flux de Bunyan.

#4. Morgan

Avantages Morgan

Morgan est une bibliothèque de journalisation unique pour Node.js pour plusieurs raisons, principalement son positionnement unique en tant que middleware. Ceci, entre autres raisons, l'a conduit à être très populaire, avec 7,3 000 étoiles sur GitHub au moment de la rédaction. Voici quelques raisons pour lesquelles Morgan est si populaire :

1. Basé sur le middleware - Morgan fonctionne en tant que middleware dans le framework Node.js Express, ce qui facilite son intégration dans les applications existantes basées sur Express.
2. Personnalisable - Morgan propose une large gamme d'options de personnalisation, du format de journal aux jetons personnalisés, permettant aux développeurs d'adapter leurs journaux à leurs besoins spécifiques.
3. Basé sur les flux - Morgan peut écrire des données de journal dans une variété de flux de sortie, y compris la console, les fichiers ou même les serveurs distants.
4. Rapide et léger - Morgan est conçu pour être rapide et léger, ce qui le rend adapté aux applications à fort trafic où les performances sont essentielles.
5. Journalisation des requêtes HTTP - Morgan est spécialement conçu pour enregistrer les requêtes et les réponses HTTP, ce qui est utile pour le débogage et l'analyse des performances du serveur Web.

Installation de Morgan

Commencez par installer le package morgan à l'aide de npm :

 npm install morgan

Utilisation de Morgan

Une fois le processus d'installation terminé, vous devez importer la bibliothèque à l'aide de la fonction "require", puis l'intégrer dans votre application Express.js en tant que middleware.

Le code pour cela ressemblerait à ce qui suit :

 var morgan = require('morgan'); app.use(morgan('dev'));

L'argument "dev" est une option de format fournie par Morgan. Morgan propose cinq formats de journalisation différents, notamment :

1. tiny a une sortie minuscule.
2. short inclut le temps de réponse et abrège le journal par défaut.
3. dev fournit une sortie concise et codée par couleur à utiliser pendant le développement
4. common utilise également la sortie de journal combinée d'Apache.
5. combined utilise la sortie de journal combinée Apache standardisée.

Vous pouvez choisir entre ces formats en utilisant l'argument approprié lors de l'intégration de Morgan dans votre application, comme indiqué ci-dessous :

 app.use(morgan('combined')); app.use(morgan('common')); app.use(morgan('dev')); app.use(morgan('short')); app.use(morgan('tiny'));

#5. Niveau de journalisation

Avantages au niveau du log

Loglevel est un peu moins populaire que certaines des autres options répertoriées ici, avec 2,4K étoiles sur Github, mais il reste néanmoins une excellente bibliothèque de journalisation légère. Voici quelques raisons pour lesquelles loglevel est une bibliothèque de journalisation unique pour Node.js :

1. Empreinte de code minimale - loglevel est une bibliothèque très légère, ce qui la rend idéale pour les situations où vous avez besoin d'une quantité minimale de surcharge de code.
2. Niveaux de journalisation dynamiques - loglevel fournit des niveaux de journalisation dynamiques, ce qui vous permet de modifier le niveau de journalisation au moment de l'exécution, ce qui facilite le basculement entre différents niveaux de détails de journalisation sans avoir à modifier le code.
3. API simple - l'API de loglevel est simple, offrant un moyen facile à utiliser et flexible de consigner les messages.
4. Compatibilité du navigateur - loglevel est compatible avec les navigateurs Node.js et Web, ce qui en fait un choix polyvalent pour la journalisation dans une variété d'environnements.
5. Compatibilité multiplateforme - loglevel est construit sur log4js, qui est une bibliothèque de journalisation largement utilisée, assurant la compatibilité entre différentes plateformes.

Installation de Loglevel

Pour configurer loglevel, vous devez d'abord l'installer à l'aide de npm :

 npm install loglevel

Utilisation du niveau de journalisation

Une fois installé, vous pouvez l'importer dans votre projet Node.js et commencer à l'utiliser en définissant le niveau de journal :

 const log = require('loglevel'); log.setLevel(log.levels.ERROR);

En définissant le niveau de journalisation sur ERROR, vous spécifiez que seuls les messages de journal avec un niveau de gravité ERROR seront consignés. Après avoir défini le niveau de journalisation, vous pouvez utiliser les méthodes suivantes pour consigner les messages à différents niveaux :

 log.trace('This is a trace message'); log.debug('This is a debug message'); log.info('This is an info message'); log.warn('This is a warning message'); log.error('This is an error message');

Le niveau de journalisation que vous définissez déterminera quels messages seront consignés et lesquels seront ignorés. Par exemple, si le niveau de journalisation est défini sur info, seuls les messages consignés à l'aide de log.info et log.warn ou log.error seront affichés.

#6. Log4js

Avantages de Log4js

Bien sûr, nous ne pouvions pas mentionner loglevel sans mentionner également son grand frère, Log4js. Log4js est une bibliothèque de journalisation JavaScript qui a été lancée en tant que portage de la populaire bibliothèque de journalisation Java Log4j. Il a été créé pour fournir une solution de journalisation similaire pour les applications JavaScript et a depuis évolué pour fournir des capacités et des fonctionnalités de journalisation avancées. Avec plus de 5 600 étoiles sur Github, voici quelques-unes des raisons pour lesquelles Log4js est si populaire :

• Flexibilité dans la configuration - Log4js offre une gamme d'options pour la journalisation, y compris les niveaux de journalisation, différents types d'appenders (par exemple, console, fichier, réseau) et la possibilité de spécifier différentes configurations de journalisation pour différentes parties de l'application.
• Appenders personnalisés - Log4js prend en charge la création d'appenders personnalisés, permettant aux développeurs d'étendre la bibliothèque pour répondre à leurs besoins de journalisation spécifiques.
• Prise en charge du contexte de journal - Log4js permet aux développeurs d'associer des messages de journal à des informations contextuelles supplémentaires, telles que les données de demande de l'utilisateur, afin de rendre les messages de journal plus utiles pour le débogage.
• Configuration dynamique du niveau de journalisation - Log4js prend en charge la modification du niveau de journalisation au moment de l'exécution, ce qui facilite la gestion de la journalisation dans un environnement de production.
• Intégration avec d'autres outils - Log4js a un support intégré pour les outils populaires, tels que Logstash et Graylog, ce qui facilite l'intégration de la journalisation dans un flux de travail plus large de surveillance et d'analyse des applications.

Installation de Log4js

Pour installer Log4js, vous pouvez utiliser le gestionnaire de packages npm en exécutant la commande suivante dans votre terminal :

 npm install log4js

Cela installera la dernière version de Log4js et ses dépendances. Vous pouvez ensuite exiger la bibliothèque dans votre application Node.js et commencer à l'utiliser pour consigner les messages.

Utilisation de Log4js

Pour commencer à utiliser Log4js, exigez-le d'abord dans votre code et configurez-le :

 const log4js = require('log4js'); log4js.configure({ appenders: { console: { type: 'console' } }, categories: { default: { appenders: ['console'], level: 'info' } } }); const logger = log4js.getLogger();

Vous pouvez ensuite utiliser l'enregistreur pour consigner les messages à différents niveaux :

 logger.trace('Entering cheese testing'); logger.debug('Got cheese.'); logger.info('Cheese is Gouda.'); logger.warn('Cheese is quite smelly.'); logger.error('Cheese is too ripe!'); logger.fatal('Cheese was breeding ground for listeria.');

Voici un exemple d'utilisation de Log4js pour consigner des messages dans plusieurs appenders (console et fichier) avec différents niveaux de journal :

 const log4js = require('log4js'); log4js.configure({ appenders: { console: { type: 'console' }, file: { type: 'file', filename: 'app.log' } }, categories: { default: { appenders: ['console'], level: 'info' }, file: { appenders: ['file'], level: 'error' } } }); const logger = log4js.getLogger(); const fileLogger = log4js.getLogger('file'); logger.info('This is an informational message'); fileLogger.error('This is an error message');

Dans cet exemple, l'enregistreur avec la catégorie "par défaut" est configuré pour consigner les messages avec des informations de niveau ou supérieur sur la console. L'enregistreur avec la catégorie "fichier" est configuré pour consigner les messages avec erreur de niveau ou supérieur dans le fichier. Les deux enregistreurs peuvent être utilisés de manière interchangeable pour consigner les messages dans leurs annexes respectives.

#7. NpmlogName

Avantages de Npmlog

La valeur unique de npmlog réside dans sa simplicité et sa surcharge minimale, ce qui le rend bien adapté à une utilisation dans des projets à petite échelle ou sensibles aux performances. Il est facile à configurer et s'intègre de manière transparente à l'écosystème npm (ce qui n'est pas surprenant depuis l'utilitaire de journalisation officiel de son npm), ce qui en fait un choix populaire pour les développeurs à la recherche d'une solution de journalisation légère. Voici quelques raisons pour lesquelles npmlog a fait la liste :

1. Léger - npmlog a une petite base de code et une surcharge minimale, ce qui le rend bien adapté aux projets à petite échelle ou sensibles aux performances.
2. Intégration facile avec npm - npmlog est spécialement conçu pour être utilisé dans l'écosystème npm, ce qui facilite l'intégration avec d'autres packages et outils npm.
3. Personnalisable - npmlog vous permet de personnaliser le niveau de journalisation, le flux et le préfixe, vous donnant un contrôle total sur la façon dont vos journaux sont générés et affichés.
4. Polyvalent - npmlog convient à un large éventail de projets, des petits scripts aux grandes applications, ce qui en fait un outil de journalisation polyvalent et flexible.
5. Simple à utiliser - npmlog possède une API simple et nécessite une configuration minimale, ce qui permet de démarrer rapidement et facilement la journalisation dans votre projet Node.js.

Installation de Npmlog

Pour installer npmlog, vous devez avoir installé Node.js et npm (Node Package Manager) sur votre machine. Ensuite, vous pouvez exécuter la commande suivante dans votre terminal ou invite de commande :

 npm install npmlog

Cela téléchargera et installera la dernière version de npmlog et de ses dépendances, vous permettant de l'utiliser dans votre projet Node.js.

Utilisation de Npmlog

Voici un exemple d'utilisation de npmlog dans un projet Node.js :

 const log = require('npmlog'); log.level = 'verbose'; log.verbose('This is a verbose message'); log.info('This is an informational message'); log.warn('This is a warning'); log.error('This is an error');

Dans cet exemple, nous commençons par exiger le module npmlog et l'assignons à une variable. Ensuite, nous définissons le niveau de journalisation sur verbose , ce qui signifie que les messages avec un niveau de journalisation de verbose , info , warn et error seront affichés. Nous enregistrons ensuite les messages à différents niveaux à l'aide des verbose , info , warn et error .

Notez que par défaut, npmlog écrit dans process.stderr . Si vous devez écrire dans process.stdout , vous pouvez utiliser la propriété log.stream .

#8. Rugir

Avantages du rugissement

La bibliothèque roarr est un outil de journalisation Node.js conçu pour produire des données structurées sans nécessiter d'initialisation. Il dispose d'une interface de ligne de commande (CLI) et prend en charge les variables environnementales, ce qui le rend polyvalent et facile à utiliser. De plus, roarr est compatible avec les environnements Node.js et de navigateur, ce qui en fait une solution de journalisation polyvalente pour un large éventail d'applications.

Voici quelques points clés qui mettent en évidence la valeur unique de la bibliothèque roarr :

1. Journalisation structurée - la bibliothèque produit des journaux dans un format structuré, ce qui facilite le traitement et l'analyse des journaux à l'aide d'outils lisibles par machine.
2. Métadonnées riches - roarr fournit un ensemble riche de métadonnées, telles que des informations sur les demandes et les réponses, qui peuvent être utilisées pour diagnostiquer les problèmes et améliorer la qualité globale de vos journaux.
3. Lisible par l'homme - malgré son format structuré, les journaux roarr sont également conçus pour être lisibles par l'homme, ce qui facilite la compréhension du contexte et du contenu de vos journaux.
4. Facile à utiliser - la bibliothèque fournit une API simple et intuitive pour la journalisation, sans complexité inutile.
5. Personnalisable - la bibliothèque roarr vous permet de personnaliser l'apparence et le contenu de vos journaux, y compris les options de personnalisation du niveau de journal, du flux et des métadonnées.

Installation de Roarr

Tout d'abord, installez roarr en utilisant npm :

 npm install roarr

Utiliser le rugissement

Ensuite, importez roarr dans votre code et créez un logger :

 const Roarr = require('roarr').default; const logger = new Roarr({ context: { service: 'my-service' } });

Journaliser les messages à l'aide de la méthode log :

 logger.info('Hello, world!');

Par défaut, les journaux roarr seront envoyés à la console. Vous pouvez personnaliser la sortie du journal en spécifiant un flux différent, tel qu'un fichier, à l'aide de l'option stream :

 const Roarr = require('roarr').default; const fs = require('fs'); const logger = new Roarr({ context: { service: 'my-service' }, stream: fs.createWriteStream('./my-service.log') });

Ceci est juste un exemple de base de la façon d'utiliser roarr. Il existe de nombreuses autres options et fonctionnalités disponibles, alors assurez-vous de vous référer à la documentation officielle de roarr pour plus d'informations.

#9. Traceur

Avantages du traceur

Tracer est une bibliothèque de journalisation open source pour les applications Node.js, développée par la communauté Node.js. Il est conçu pour fournir un moyen efficace et flexible de consigner les messages et les informations de débogage dans les applications Node.js. Tracer a été activement maintenu et développé par une équipe de bénévoles et est disponible pour quiconque peut l'utiliser et y contribuer sur Github. Voici quelques-unes des fonctionnalités qui en font une bibliothèque de journalisation unique :

1. Journalisation asynchrone - Tracer utilise la journalisation asynchrone, ce qui signifie que les journaux ne bloquent pas l'exécution du programme.
2. Journalisation structurée - Tracer fournit une journalisation structurée, ce qui signifie que les journaux sont organisés en paires clé-valeur, ce qui facilite la recherche, l'analyse et la visualisation des données de journal.
3. Sortie personnalisable - Tracer fournit un format de sortie personnalisable, permettant aux développeurs de choisir le format et la destination de leurs journaux, y compris la console, les fichiers ou les services basés sur le cloud comme AWS CloudWatch.
4. Contexte de journalisation riche - Tracer fournit un contexte de journalisation riche, y compris la possibilité de joindre des métadonnées telles que les ID de demande, les ID utilisateur et d'autres informations aux journaux.
5. Prise en charge du middleware - Tracer fournit une prise en charge du middleware, permettant aux développeurs d'ajouter facilement la journalisation à leurs applications Express.js ou Koa.js.

Installation du traceur

Tracer peut être installé à l'aide de Node Package Manager (npm). Voici les étapes pour installer Tracer :

1. Ouvrez votre terminal ou invite de commande
2. Remplacez votre répertoire actuel par le répertoire de votre projet Node.js
3. Exécutez la commande suivante pour installer Tracer :

 npm install tracer

Cela installera Tracer en tant que dépendance dans votre projet. Vous pouvez ensuite l'exiger dans votre code et commencer à l'utiliser pour consigner les messages.

Utilisation du traceur

Voici un exemple d'utilisation de Tracer dans votre code :

 const tracer = require('tracer'); const logger = tracer.console(); logger.info('Starting the application...');

Dans cet exemple, nous avons d'abord besoin de la bibliothèque Tracer, puis créons un enregistreur de console à l'aide de la méthode tracer.console() . Enfin, nous enregistrons un message d'information à l'aide de la méthode info sur l'objet logger.

Voici un autre exemple d'utilisation de Tracer :

 const tracer = require('tracer'); const logger = tracer.dailyfile({root: './logs', maxLogFiles: 10}); logger.error('An error has occurred:', new Error('Something went wrong'));

Dans cet exemple, nous utilisons la méthode tracer.dailyfile pour créer un enregistreur de fichiers qui écrit des journaux dans un fichier rotatif quotidien. L'option root spécifie le répertoire dans lequel les fichiers journaux seront stockés et l'option maxLogFiles limite le nombre de fichiers journaux qui seront conservés.

Enfin, nous enregistrons un message d'erreur à l'aide de la méthode error sur l'objet logger, ainsi qu'un objet error, fournissant plus d'informations sur l'erreur qui s'est produite.

#dix. Signaux

Avantages Signale

Sa page Github se vante d'être "piratable et configurable jusqu'au cœur", et c'est une partie importante de ce qui fait de Signale une bibliothèque de journalisation si appréciée dans la communauté Node.js. La bibliothèque a été créée pour résoudre les difficultés rencontrées par les développeurs lorsqu'ils tentent de consigner des messages dans les applications Node.js, tels que des journaux encombrés et difficiles à lire. Voici ce qui le distingue du lot :

1. Sorties de journal personnalisables - Signale propose une variété de sorties de journal personnalisables, permettant aux développeurs de choisir la sortie qui correspond le mieux à leurs besoins, des sorties de console simples aux sorties plus avancées comme JSON et Logfmt.
2. API intuitive - Signale dispose d'une API simple et intuitive, ce qui facilite l'utilisation et la compréhension des développeurs, même pour ceux qui débutent dans la journalisation.
3. Sortie stylisée - Signale fournit des sorties stylisées, rendant les journaux plus lisibles et visuellement attrayants, ce qui facilite l'identification rapide des messages de journal importants.
4. Contexte de journal riche - Signale fournit un contexte de journal riche, tel que des horodatages et des niveaux de journal, ce qui facilite l'analyse et la compréhension des journaux.
5. Communauté active - Signale dispose d'une communauté importante et active de développeurs et de contributeurs, garantissant que la bibliothèque est bien entretenue et à jour avec les dernières technologies et les meilleures pratiques.

Installer Signale

Pour installer Signale, vous pouvez utiliser npm, le gestionnaire de packages Node.js, en exécutant la commande suivante dans votre terminal :

 npm install signale

Alternativement, vous pouvez également utiliser yarn pour installer Signale en exécutant la commande suivante dans votre terminal :

 yarn add signale

Une fois installé, vous pouvez importer Signale dans votre application Node.js et commencer à l'utiliser pour consigner les messages et les informations de débogage.

Utilisation de Signal

Voici un exemple d'importation de Signale dans votre application Node.js et de son utilisation pour consigner les messages :

 const signale = require('signale'); // Log an info message signale.info('Starting up the server'); // Log a success message signale.success('Server started successfully'); // Log a warning message signale.warn('Low memory warning'); // Log an error message signale.error(new Error('An error occurred while processing data'));

Dans cet exemple, nous importons Signale dans notre application Node.js à l'aide de la fonction require . Ensuite, nous utilisons les différentes méthodes de journalisation fournies par Signale, telles que info , success , warn et error , pour enregistrer différents types de messages. Chacune de ces méthodes a un symbole et une couleur distincts, ce qui facilite l'identification rapide du type de message de journal.

Vous pouvez trouver plus d'informations sur l'utilisation de Signale, y compris des méthodes de journalisation supplémentaires et des options de personnalisation, dans la documentation de Signale .

Optimisez votre processus de débogage avec les bibliothèques de journaux Node.js

A la recherche d'une méthode rapide et efficace pour déboguer vos applications Node.js ? Découvrez une ou plusieurs des bibliothèques mentionnées dans cet article, chacune d'entre elles est une excellente option. Pino, cependant, est notre bibliothèque de journalisation personnelle de choix pour ce que cela vaut 😉

Ces bibliothèques de journalisation se sont avérées cruciales lors du débogage des applications Node.js à la fois dans les environnements de test/développement et dans la production.

De plus, en les intégrant à une solution de surveillance telle que PlayerZero, vous pouvez obtenir des informations encore plus détaillées sur les performances de vos applications Node.js.

Réservez une démo pour en savoir plus sur la façon dont PlayerZero peut vous aider à optimiser les performances de votre application backend dès aujourd'hui !