Journalisation dans les applications TypeScript : meilleures pratiques et outils

Introduction : pourquoi la journalisation est importante en TypeScript

La journalisation ne consiste pas simplement à enregistrer des événements dans un fichier. Dans les applications TypeScript modernes, une journalisation correctement configurée constitue la base du débogage, de la surveillance et de l'analyse des performances. Sans journaux de qualité, un développeur passe des heures à reproduire des erreurs, et l'équipe d'exploitation ne peut pas identifier rapidement les goulots d'étranglement.

TypeScript, en tant que surcouche de JavaScript, offre un typage strict, ce qui permet de créer des systèmes de journalisation plus prévisibles et plus sûrs. Cependant, utiliser un simple console.log() en production est un anti-patron qui génère du bruit informationnel et une perte de données importantes.

Dans cet article, nous examinerons les meilleures pratiques de journalisation en TypeScript : du choix de la bibliothèque à la structuration des journaux et au travail avec le contexte.

Choix d'une bibliothèque de journalisation

Dans l'écosystème TypeScript/Node.js, il existe plusieurs bibliothèques populaires. Examinons trois options principales :

• Winston — la bibliothèque la plus populaire avec une configuration flexible des transports (sortie vers console, fichier, base de données). Elle prend en charge les niveaux de journalisation et le formatage.
• Pino — une bibliothèque moderne axée sur les performances. Idéale pour les systèmes à forte charge.
• Bunyan — une option moins populaire mais stable. Tous les enregistreurs produisent des données au format JSON.

Pour une application TypeScript typique, nous recommandons Winston ou Pino. Exemple de configuration de Winston avec TypeScript :

import winston from 'winston';

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

logger.info('Serveur démarré', { port: 3000 });

Intégration avec TypeScript : types et interfaces

Pour tirer le meilleur parti du typage, créez une enveloppe pour l'enregistreur en utilisant des interfaces :

interface LoggerOptions {  level?: string;  service?: string;}

interface ILogger {  info(message: string, meta?: unknown): void;  error(message: string, error?: Error): void;  warn(message: string, meta?: unknown): void;}

Cela vous permettra de contrôler strictement les types de données transmises et d'éviter les erreurs lors de la phase de compilation.

Niveaux de journalisation et leur utilisation correcte

Les niveaux de journalisation standard (du plus critique au moins critique) : error, warn, info, debug, trace. Il est important de respecter une sémantique unifiée :

• error — uniquement pour les erreurs irrécupérables nécessitant l'attention du développeur.
• warn — pour les situations potentiellement problématiques qui ne perturbent pas le fonctionnement de l'application.
• info — pour les événements clés : démarrage du serveur, traitement d'une requête, authentification réussie.
• debug — pour le débogage pendant le développement. N'activez pas ce niveau en production.

Exemple de changement dynamique de niveau en fonction de l'environnement :

const logLevel = process.env.NODE_ENV === 'production' ? 'warn' : 'debug';const logger = winston.createLogger({ level: logLevel });

Journaux structurés et contexte

Au lieu de messages textuels, utilisez des journaux structurés au format JSON. Cela permet d'analyser facilement les journaux avec la pile ELK (Elasticsearch, Logstash, Kibana) ou d'autres systèmes.

Ajoutez obligatoirement des informations contextuelles : ID de requête, nom d'utilisateur, nom du service, horodatage. Exemple avec Pino :

import pino from 'pino';

const logger = pino({  level: 'info',  mixin() {    return { service: 'my-api' };  },});

// Ajout au c