Les 4 meilleurs packages pour se connecter à Node.js

Une bonne journalisation est un aspect essentiel de la création et de la maintenance d'applications Web fonctionnelles. Il peut vous aider à suivre les erreurs, à diagnostiquer les problèmes de performances et à comprendre comment les utilisateurs interagissent avec votre application.

Node.js propose de nombreux packages de journalisation pour vous aider à créer et à gérer des journaux structurés. Ici, vous explorerez les principaux packages de journalisation actuellement disponibles dans l'écosystème Node.js et comment les utiliser.

1. Winston

Winston est une bibliothèque Node.js qui fournit une fonctionnalité de journalisation flexible, y compris plusieurs transports. Un « transport » est un support de stockage pour vos logs.

Winston prend en charge les transports de console, de fichiers et de réseau. Cela signifie que vous pouvez imprimer vos journaux sur la console, les écrire dans un fichier ou les envoyer sur un réseau. À l'aide des niveaux de journalisation de Winston, vous pouvez créer des transports personnalisés et filtrer les journaux en fonction de la gravité.

Vous pouvez installer Winston en tant que dépendance dans votre répertoire de projet en utilisant npm, le gestionnaire de packages JavaScript. Exécutez cette commande :

npm installer winston

Le bloc de code ci-dessous montre comment configurer un système de journalisation de base à l'aide de Winston. Vous pouvez définir des journaux pour différents emplacements et différents niveaux de gravité.

constante winson = exiger("Winston");
// Enregistreur Winston
constante enregistreur = winston.createLogger({
 niveau: 'Info',
 format: winston.format.json(),
 méta par défaut: { service: 'mon service' },
 les transports: [
nouveau winston.transports. Console(),
nouveau winston.transports. Déposer({ nom de fichier: 'error.log', niveau: 'erreur' }),
nouveau winston.transports. Déposer({ nom de fichier: 'log.combiné' })
 ]
});
logger.info("Bonjour Winston !");
logger.warn('Attention: quelque chose ne va pas.');
logger.error('Une erreur s'est produite.');

Ce code configure un enregistreur avec trois transports. Le premier est un transport de console, qui enverra des messages de journal à la console. Le second est un transport de fichiers qui écrira des journaux avec un niveau "error" dans un fichier "error.log". Le troisième est un transport de fichiers qui écrira tous les journaux dans un fichier "combiné.log".

L'enregistreur est configuré pour enregistrer au niveau "info" par défaut et inclut un objet de métadonnées par défaut avec un champ "service" défini sur "my-service".

Le code enregistre ensuite trois messages à l'aide de l'enregistreur aux niveaux "info", "warn" et "error", respectivement. Ces messages seront envoyés à la console et aux fichiers journaux appropriés en fonction de la configuration des transports.

2. Morgan

Morgan est un middleware de journalisation pour Node.js qui fournit des fonctionnalités de base de journalisation des demandes. Il est conçu pour être léger et facile à utiliser. Morgan fonctionne en interceptant les requêtes HTTP et en enregistrant les informations pertinentes, telles que la méthode de requête, l'URL, le code d'état, etc.

L'un des principaux avantages de Morgan est sa simplicité. Vous pouvez l'ajouter à une application Node.js avec quelques lignes de code, car il ne nécessite aucune configuration supplémentaire à mettre en place.

Morgan prend en charge plusieurs formats de journalisation, y compris le commun, combiné, court, minuscule, et développeur formats, vous permettant de choisir celui qui convient le mieux à vos besoins.

Vous pouvez installer Morgan en tant que dépendance dans le répertoire de votre projet en exécutant cette commande :

npm installer morgan

Ce code montre comment utiliser Morgan dans une demande Express:

constante exprimer = exiger("exprimer");
constante Morgan = exiger("Morgan");
constante app = express();
app.use (morgan("dev"));
app.get("/", (req, res) => {
 res.send("Bonjour le monde!");
});
app.listen(3000, () => console.enregistrer("Application démarrée"));

Le code initialise Morgan en utilisant le développeur format. Lorsque vous effectuez une requête GET sur la route racine (/), Morgan consigne les détails de cette requête dans la console.

Malgré sa simplicité, Morgan est un package de journalisation puissant qui fournit des fonctionnalités essentielles de journalisation des demandes pour les applications Node.js.

3. pino

Pino est un package de journalisation populaire et léger pour les applications Node.js qui offre des performances rapides et une faible surcharge, comme indiqué dans leurs repères.

Pino prend en charge plusieurs types de transport, facilement étendus avec des transports personnalisés. L'une des principales caractéristiques de Pino est sa capacité à consigner les messages au format JSON, ce qui les rend faciles à analyser et à analyser.

L'utilisation de Pino varie selon le framework Node.js; vous pouvez installer Pino en tant que dépendance dans votre répertoire de projet Express en exécutant la commande ci-dessous :

npm installer pino-http

Pour différents frameworks, vérifiez le Documentation Pino.

Ce bloc de code montre l'utilisation de Pino dans une application Express :

constante exprimer = exiger("exprimer");
constante app = express();
constante pino = exiger('pino-http')()
app.use (pino)
app.get("/", (req, res) => {
 pino (req, res) // enregistre la requête et la réponse
 req.log.info('route racine') // enregistre des informations supplémentaires
 res.send("Bonjour le monde!");
});
app.listen(3000, () => console.enregistrer("Application démarrée"));

Ce code initialise Pino et l'enregistre en tant que middleware. Lorsque vous effectuez une requête GET sur la route racine (/), Pino enregistre les détails de votre requête et sa réponse dans la console.

4. Déboguer

Debug est un package de journalisation pour Node.js inspiré de la technique de débogage du noyau Node.js. Il fournit une solution de journalisation légère qui vous permet d'activer ou de désactiver la journalisation de manière sélective sans modifier le code, ce qui facilite le débogage et la résolution des problèmes.

Le débogage vous permet également de définir des espaces de noms de journaux, qui fournissent une structure hiérarchique à vos journaux en fonction des composants et des modules de votre application, ce qui facilite leur filtrage et leur recherche. De plus, Debug propose différents niveaux de journalisation, tels que les erreurs, les avertissements et les informations, que vous pouvez utiliser pour hiérarchiser et filtrer leurs journaux.

Vous pouvez installer Debug en tant que dépendance dans le répertoire de votre projet avec cette commande :

débogage d'installation npm

Ce code montre l'utilisation de Debug dans une application Express :

constante exprimer = exiger('exprimer');
// Importer le débogage et créer un espace de noms
constante déboguer = exiger('déboguer')('monapp: serveur');
constante app = express();
constante port = processus.env. PORT || 3000;
app.get('/', (req, res) => {
 déboguer('Demande reçue pour /');
 res.send('Bonjour le monde!');
});
app.listen (port, () => {
 déboguer(`Serveur en écoute sur le port ${port}`);
});

Le code crée un espace de noms, monapp: serveur. Cet espace de noms distinguera les journaux liés à votre "serveur” module de ceux associés à d'autres modules avec un espace de noms différent dans votre application.

Exécutez cette commande pour démarrer le débogage :

DEBUG=myapp:* node server.js

Cette commande ci-dessus correspondra à tout message de journal avec un espace de noms commençant par mon appli :. Si vous souhaitez uniquement voir les journaux liés à votre serveur module, vous pouvez définir le DÉBOGUER variable d'environnement à monapp: serveur.

Un autre avantage de Debug est sa compatibilité avec d'autres packages de journalisation, tels que Winston.

Choisir un package de journalisation

Le choix d'un package de journalisation est une décision importante qui peut avoir un impact significatif sur l'efficience et l'efficacité de votre processus de débogage. Il est essentiel de prendre en compte des facteurs tels que les caractéristiques et les capacités du package, son compatibilité avec votre langage de programmation et votre environnement de développement, et sa facilité d'utilisation et configuration.

En fin de compte, le choix du package de journalisation dépendra des besoins et des exigences spécifiques de votre projet.