Journalisation dans les applications TypeScript : bonnes pratiques pour débutants

Introduction à la journalisation des applications TypeScript

La journalisation est le processus d'enregistrement des événements qui se produisent pendant l'exécution d'un programme. Pour les applications TypeScript, en particulier celles fonctionnant dans l'environnement Node.js, une journalisation correctement configurée n'est pas seulement une bonne pratique, mais un outil essentiel pour le débogage, la surveillance et l'analyse des erreurs.

De nombreux développeurs débutants se limitent à utiliser console.log(). Cependant, dans un environnement de production, cette approche est inefficace : elle ne permet pas de gérer flexiblement les niveaux de priorité, de filtrer les messages ou de les enregistrer dans des fichiers. Dans cet article, nous allons voir comment créer un système de journalisation professionnel en TypeScript à partir de zéro.

Pourquoi ne pas utiliser console.log en production ?

Regardons un exemple typique :

// Mauvaise approche — utiliser console.log directement\nfunction processOrder(orderId: string): void {\n  console.log(`Traitement de la commande ${orderId}`);\n  try {\n    // logique métier\n  } catch (error) {\n    console.error(`Erreur lors du traitement de la commande : ${error}`);\n  }\n}\n

Problèmes de cette approche :

\n
• Absence de niveaux de journalisation : impossible de séparer les messages de débogage des erreurs critiques.
\n
• Pas de formatage : difficile de lire de gros volumes de données.
\n
• Impossible de rediriger : tous les messages vont uniquement vers stdout/stderr.
\n
• Problèmes de performance : l'écriture synchrone dans la console peut ralentir l'application.
\n

Bonnes pratiques de journalisation en TypeScript

1. Choix d'une bibliothèque de journalisation

Pour TypeScript, il est recommandé d'utiliser l'une des deux bibliothèques populaires :

\n
• Winston — un logger puissant et flexible avec support des transports (fichier, console, bases de données).
\n
• Pino — un logger ultra-rapide, idéal pour les applications à forte charge.
\n

Installons Winston :

npm install winston\nnpm install @types/winston --save-dev\n

2. Création d'un logger configurable

Créons un module logger.ts :

import winston from 'winston';\n\nconst logger = winston.createLogger({\n  level: process.env.LOG_LEVEL || 'info',\n  format: winston.format.combine(\n    winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),\n    winston.format.errors({ stack: true }),\n    winston.format.json()\n  ),\n  transports: [\n    new winston.transports.Console({\n      format: winston.format.combine(\n        winston.format.colorize(),\n        winston.format.simple()\n      )\n    }),\n    new winston.transports.File({ \n      filename: 'logs/error.log', \n      level: 'error' \n    }),\n    new winston.transports.File({ \n      filename: 'logs/combined.log' \n    })\n  ]\n});\n\nexport default logger;\n

Maintenant, vous pouvez utiliser le logger dans n'importe quel module :

import logger from './logger';\n\nfunction getUser(id: string) {\n  logger.info(`Récupération de l'utilisateur avec l'ID : ${id}`);\n  try {\n    // logique de récupération de l'utilisateur\n    logger.debug('Données utilisateur récupérées avec succès');\n  } catch (error) {\n    logger.error('Échec de la récupération de l'utilisateur', { userId: id, error });\n  }\n}\n

3. Utilisation des niveaux de journalisation

Niveaux standard (du moins important au plus important) :

\n
• debug — informations de débogage détaillées (uniquement pour le développement).
\n
• info — messages d'information standard.
\n
• warn — avertissements concernant des problèmes potentiels.
\n
• error — erreurs nécessitant une attention.
\n

Configurez le niveau de journalisation via les variables d'environnement :

// Dans le fichier .env\nLOG_LEVEL=debug  # pour le développement\nLOG_LEVEL=warn   # pour la production\n

4. Journalisation structurée

Transmettez des informations supplémentaires