Logging centralisé & gestion des erreurs

Structured logging · Winston · Correlation ID · Docker logs · Error tracking

Bootcode IWA-S04 — DevOps, Semaine 4, Jour 3

Objectifs de la leçon

1. Logs vs métriques

Les métriques disent QUE ça ne va pas, les logs disent POURQUOI

2. Structured logging

Logs JSON parsables avec Winston ou Pino — pas du texte brut

3. Niveaux de log

debug, info, warn, error — quand utiliser lequel

4. Centralisation Docker

Drivers de logging, rotation, docker compose logs | jq

5. Correlation ID + error tracking

Tracer une requĂȘte de bout en bout — et les bases de Sentry

Plan du cours

1

Métriques vs logs

Rappel d'hier : Prometheus dit QUE, les logs disent POURQUOI

2

Structured logging : pourquoi JSON

Parsable par des outils, filtrable, recherchable

3

Log levels + Winston/Pino

debug, info, warn, error — config, transports, formatters

4

Docker logging

Drivers (json-file, syslog), centralisation, rotation

5

Live coding

Winston dans l'app, logs métier, simuler et diagnostiquer une erreur

Ce qu'un log doit raconter

QUI

user id, IP

QUOI

l'action

QUAND

timestamp ISO

OÙ

service, endpoint

RÉSULTAT

succĂšs / erreur

❌ Texte brut

user logged in stuff happened ok

Impossible Ă  filtrer, impossible Ă  agrĂ©ger — bonne chance pour retrouver une erreur.

✅ JSON structurĂ©

{"level":"info","requestId":"abc-123",

 "userId":42,"action":"login","status":200}

Chaque champ est filtrable : jq 'select(.level=="error")'

Les niveaux de log

debug

DĂ©tail technique pour le dev — dĂ©sactivĂ© en prod (LOG_LEVEL=info)

info

ÉvĂ©nement normal mais significatif : requĂȘte reçue, user inscrit, job terminĂ©

warn

Anormal mais gĂ©rĂ© : deprecation, retry, quota proche — ça mĂ©rite un Ɠil

error

Échec qui impacte : 500, exception, appel externe ratĂ© — avec stack trace !

fatal

L'app ne peut plus fonctionner : DB inaccessible au boot → exit

La bonne granularité : trop de logs = bruit + perf. Pas assez = aveugle en cas d'incident. Logger les événements métier et les erreurs, pas chaque ligne de code.

Winston : logger JSON + rotation

// src/infrastructure/logging/logger.ts

import winston from 'winston';

export const logger = winston.createLogger({

  level: process.env.LOG_LEVEL ?? 'info',

  format: winston.format.combine(

    winston.format.timestamp(),

    winston.format.errors({ stack: true }),

    winston.format.json()

  ),

  defaultMeta: { service: 'bootcode-api' },

  transports: [new winston.transports.Console()],

});

// usage :

logger.info('User registered', { userId: 42, email: masked });

logger.error('Payment failed', { error: err.message, stack: err.stack });

stdout = la voie Docker

En conteneur, on logue sur stdout — Docker capture et centralise. Pas de fichiers dans le conteneur.

Pino = l'alternative rapide

MĂȘme principe, plus performant. Les deux produisent du JSON — le choix est secondaire.

Le correlation ID : suivre une requĂȘte

Une requĂȘte traverse middleware → use case → DB → rĂ©ponse. Sans ID commun, impossible de regrouper ses logs.

Un middleware gĂ©nĂšre un requestId (uuid) au dĂ©but, tous les logs de cette requĂȘte le portent.

Filtrer par requĂȘte

docker compose logs app | jq 'select(.requestId=="abc-123")'

→ toute la vie de cette requĂȘte, chronologique.

// http-logger.ts

import { v4 as uuid } from 'uuid';

export const httpLogger = (req, res, next) => {

  const requestId = uuid();

  req.requestId = requestId;

  const start = Date.now();

  res.on('finish', () => {

    logger.info('http', {

      requestId, method: req.method,

      path: req.path, status: res.statusCode,

      durationMs: Date.now() - start,

    });

  });

  next();

};

Docker logging + données sensibles

# docker-compose.yml — rotation !

logging:

  driver: "json-file"

  options:

    max-size: "10m"

    max-file: "3"

Sans rotation, docker logs remplit le disque du VPS en quelques semaines. max-size + max-file = obligation en prod.

docker compose logs app | jq .

docker compose logs app | jq 'select(.level=="error")'

đŸš« Jamais dans les logs

  • Mots de passe (mĂȘme hashĂ©s)
  • Tokens JWT / API keys
  • Cartes bancaires
  • PII non nĂ©cessaire (emails → masquer)

// sanitize.ts

const SENSITIVE = ['password','token'];

sanitize = obj => mask(SENSITIVE);

// email: "a***@ex.com"

Error tracking : au-delĂ  des logs

Les logs sont atomiques — un outil comme Sentry agrùge les erreurs :

  • Groupe les occurrences identiques (1 bug = 1 issue)
  • Stack trace + contexte (request, user, release)
  • Alerte quand une nouvelle erreur apparaĂźt
  • Suit la frĂ©quence et la rĂ©gression entre releases

// init tĂŽt, avant les routes

import * as Sentry from '@sentry/node';

Sentry.init({ dsn: process.env.SENTRY_DSN });

Alternative maison

L'exercice : un script qui surveille les logs JSON et alerte sur Slack quand level=="error" — le principe est le mĂȘme.

PiĂšges courants

❌ console.log en production

Pas de niveaux, pas de format, pas de filtrage, pas de rotation — un logger est non nĂ©gociable.

❌ Trop ou pas assez logger

Chaque ligne de code → bruit et perf. Rien → aveugle. Logger Ă©vĂ©nements mĂ©tier + erreurs.

❌ Pas de correlation ID

Impossible de regrouper les logs d'une mĂȘme requĂȘte dans un systĂšme multi-services.

❌ DonnĂ©es sensibles loguĂ©es

Password, token, PII dans les logs = fuite de sécurité. Sanitize avant de logger, toujours.

Exercice E4.3 — ~4h

Logging structuré pour Bootcode Hub

Winston JSON, correlation ID, rotation Docker et alertes sur les erreurs critiques.

À implĂ©menter

  • 1ïžâƒŁ logger.ts — Winston JSON + niveaux
  • 2ïžâƒŁ http-logger.ts — middleware + requestId
  • 3ïžâƒŁ sanitize.ts — masquage donnĂ©es sensibles
  • 4ïžâƒŁ Logs mĂ©tier (inscription, soumission, erreur)
  • 5ïžâƒŁ Docker : driver json-file + rotation
  • 6ïžâƒŁ Script alerte Slack sur erreurs

Vérifier avec

docker compose logs app | jq .

... | jq 'select(.level=="error")'

... | jq 'select(.requestId=="abc")'

  • ✅ JSON parsĂ© par jq
  • ✅ requestId unique par requĂȘte
  • ✅ 500 loguĂ©es en error + stack
  • ✅ DonnĂ©es sensibles masquĂ©es

À retenir !

📊 vs 📜

Les métriques alertent, les logs expliquent. Les deux se complÚtent.

{} JSON ou rien

Des logs structurés = filtrables avec jq, agrégables par des outils. Le texte brut ne l'est pas.

🔗 requestId partout

Le correlation ID relie tous les logs d'une requĂȘte — indispensable dĂšs qu'il y a plusieurs services.

đŸš« Jamais de secrets dans les logs

Sanitize les donnĂ©es sensibles — un log est un artefact de sĂ©curitĂ© autant que de debug.