---
title: "Configurer le logging Node.js avec Pino ou Winston sans perdre une seule erreur"
description: "Pino et Winston perdent tous deux l’erreur dans certains appels. Voici la configuration de chaque logger Node.js, les niveaux de log et les appels qui gardent la stack, testés sur Node.js 22."
canonical: "https://logbrew.co/fr/guides/node-logging"
last_updated: "2026-11-20"
---

# Configurer le logging Node.js avec Pino ou Winston sans perdre une seule erreur

Pino et Winston perdent tous deux l’erreur dans certains appels. Voici la configuration de chaque logger Node.js, les niveaux de log et les appels qui gardent la stack, testés sur Node.js 22.

Testé le 20 novembre 2026 avec Node.js 22.18.0, Pino 10.4.0, Winston 3.19.0, Express 5.3.0, @logbrew/node 0.1.30, @logbrew/sdk 0.1.47 et @logbrew/express 0.1.14

Par [Furkan Erday](https://github.com/furkanerday). Furkan Erday est le fondateur de LogBrew. Il développe LogBrew avec Claude Code et Codex tous les jours.

Canonical: https://logbrew.co/fr/guides/node-logging

## Quel appel garde l’erreur, à l’écran et dans LogBrew

| Appel de log | Écrit | Dans LogBrew |
| --- | --- | --- |
| Pino `error(err, msg)` | Message et stack | Nom et message |
| Pino `error(msg, err)` | Perdue | Perdue |
| Winston `error(err)` | `{"level":"error"}` | Nom et message |
| Winston `error(err, msg)` | `"message":{}` | Perdue |
| Winston `error(msg, { err })` | `"err":{}` | Nom et message |
| Winston `error(msg, err)` | Message et stack | Nom et message |

6 appels avec `new Error("keg empty")` dans Pino 10.4 et dans Winston 3.19 sans format.

## Configurer un logger Pino

### Créez 1 logger et laissez-le écrire du JSON

`pino()` journalise à partir de `info` et écrit 1 ligne JSON par appel, avec un `level` numérique, `time`, `pid` et `hostname`. L’appel `debug` n’a rien écrit. Nous avons remplacé le nom d’hôte dans la sortie.

```bash
import pino from "pino";

const logger = pino();

logger.debug("keg pressure read");
logger.info("tap opened");
logger.warn("keg below 10%");
logger.error("keg empty");
logger.fatal("cooler offline");
```

Sortie

```text
{"level":30,"time":1795160014210,"pid":27152,"hostname":"taproom","msg":"tap opened"}
{"level":40,"time":1795160014211,"pid":27152,"hostname":"taproom","msg":"keg below 10%"}
{"level":50,"time":1795160014211,"pid":27152,"hostname":"taproom","msg":"keg empty"}
{"level":60,"time":1795160014211,"pid":27152,"hostname":"taproom","msg":"cooler offline"}
```

### Lisez le niveau dans l’environnement

Lancez ce code avec `LOG_LEVEL=debug` et la ligne `debug` apparaît, sans changer le code. Un `LOG_LEVEL` vide arrête le processus. `??` garde le texte vide et Pino lève `default level: must be included in custom levels`. Utilisez `||` si la variable peut être vide.

```bash
import pino from "pino";

const logger = pino({ level: process.env.LOG_LEVEL ?? "info" });

logger.debug("keg pressure read");
logger.info("tap opened");
```

Sortie

```text
{"level":20,"time":1795160014268,"pid":27166,"hostname":"taproom","msg":"keg pressure read"}
{"level":30,"time":1795160014268,"pid":27166,"hostname":"taproom","msg":"tap opened"}
```

### Passez d’abord l’erreur, puis le message

Pino transforme un `Error` placé en premier argument, ou dans un champ `err`, en `err` avec son `type`, son `message` et sa `stack`. Une erreur placée après le message disparaît sans avertissement. La troisième ligne n’a pas de `err`. Nous avons coupé chaque stack après sa première ligne.

```bash
import pino from "pino";

const logger = pino();
const err = new Error("keg empty");

logger.error(err, "pour failed");
logger.error({ err, orderId: "ord_42" }, "pour failed");
logger.error("pour failed", err);
```

Sortie

```text
{"level":50,"time":1795160014336,"pid":27169,"hostname":"taproom","err":{"type":"Error","message":"keg empty","stack":"Error: keg empty\n    at …"},"msg":"pour failed"}
{"level":50,"time":1795160014337,"pid":27169,"hostname":"taproom","err":{"type":"Error","message":"keg empty","stack":"Error: keg empty\n    at …"},"orderId":"ord_42","msg":"pour failed"}
{"level":50,"time":1795160014337,"pid":27169,"hostname":"taproom","msg":"pour failed"}
```

## Configurer un logger Winston

### Créez le logger avec un transport Console

Sans option, `winston.createLogger()` journalise à partir de `info` et écrit du JSON. L’appel `debug` n’a rien écrit, et les lignes n’ont pas d’heure tant que vous n’ajoutez pas `winston.format.timestamp()`.

```bash
import winston from "winston";

const logger = winston.createLogger({
  transports: [new winston.transports.Console()]
});

logger.debug("keg pressure read");
logger.info("tap opened");
logger.warn("keg below 10%");
logger.error("keg empty");
```

Sortie

```text
{"level":"info","message":"tap opened"}
{"level":"warn","message":"keg below 10%"}
{"level":"error","message":"keg empty"}
```

### Ajoutez format.errors() avant format.json()

Sans format, `logger.error(err)` écrit `{"level":"error"}`. Le format JSON ignore le message et la stack d’un `Error`. Placez `winston.format.errors({ stack: true })` en premier, et le même appel écrit les deux.

```bash
import winston from "winston";

const err = new Error("keg empty");
const plain = winston.createLogger({
  transports: [new winston.transports.Console()]
});
plain.error(err);

const logger = winston.createLogger({
  format: winston.format.combine(
    winston.format.errors({ stack: true }),
    winston.format.json()
  ),
  transports: [new winston.transports.Console()]
});
logger.error(err);
```

Sortie

```text
{"level":"error"}
{"level":"error","message":"keg empty","stack":"Error: keg empty\n    at …"}
```

### Passez d’abord le message, puis l’erreur

`logger.error(err, "pour failed")` perd votre message. `logger.error("pour failed", { err })` écrit `"err":{}`. `logger.error("pour failed", err)` garde les deux et ajoute le message de l’erreur au vôtre, sous la forme `pour failed keg empty`.

```bash
import winston from "winston";

const logger = winston.createLogger({
  format: winston.format.combine(
    winston.format.errors({ stack: true }),
    winston.format.json()
  ),
  transports: [new winston.transports.Console()]
});
const err = new Error("keg empty");

logger.error(err, "pour failed");
logger.error("pour failed", { err });
logger.error("pour failed", err);
```

Sortie

```text
{"level":"error","message":"keg empty","stack":"Error: keg empty\n    at …"}
{"err":{},"level":"error","message":"pour failed"}
{"level":"error","message":"pour failed keg empty","stack":"Error: keg empty\n    at …"}
```

## Envoyer les logs Pino et Winston à LogBrew

### Installez les paquets et définissez la clé

`@logbrew/node` capture les logs Pino, `@logbrew/sdk` contient le transport Winston et `@logbrew/express` ajoute les traces des requêtes. `createLogBrewNodeClient()` lit la clé dans `LOGBREW_SERVER_API_KEY`.

```bash
npm install pino winston express @logbrew/node @logbrew/sdk @logbrew/express
```

### Appelez installLogBrewPinoInstrumentation() une fois

Appelez-la avant le premier log. Pino écrit toujours ses propres lignes, et LogBrew reçoit chaque entrée avec `pinoLevel`, `pinoLevelNumber` et vos champs. LogBrew ne garde que les champs simples, donc l’objet `card` est resté dehors. `RecordingTransport` garde ce que le SDK a envoyé pour que nous puissions l’afficher. Dans votre app, retirez `transport`.

```bash
import pino from "pino";
import { RecordingTransport } from "@logbrew/sdk";
import { createLogBrewNodeClient, installLogBrewPinoInstrumentation } from "@logbrew/node";

const transport = RecordingTransport.alwaysAccept();
const client = createLogBrewNodeClient({ transport });
installLogBrewPinoInstrumentation({ client });

const logger = pino({ redact: ["card.number"] }).child({ service: "taproom" });
logger.info({ orderId: "ord_42", card: { number: "4242424242424242" } }, "order paid");
logger.error(new Error("keg empty"), "pour failed");

await client.shutdown();
for (const { attributes: { level, message, metadata } } of JSON.parse(transport.lastBody()).events) {
  console.log(JSON.stringify({ level, message, metadata }));
}
```

Sortie

```text
{"level":30,"time":1795160014692,"pid":27178,"hostname":"taproom","service":"taproom","orderId":"ord_42","card":{"number":"[Redacted]"},"msg":"order paid"}
{"level":"info","message":"order paid","metadata":{"pinoLevel":"info","context.service":"taproom","context.orderId":"ord_42","pinoLevelNumber":30}}
{"level":"error","message":"pour failed","metadata":{"pinoLevel":"error","context.service":"taproom","pinoLevelNumber":50,"errorName":"Error","errorMessage":"keg empty"}}
{"level":50,"time":1795160014700,"pid":27178,"hostname":"taproom","service":"taproom","err":{"type":"Error","message":"keg empty","stack":"Error: keg empty\n    at …"},"msg":"pour failed"}
```

### Ajoutez createLogBrewWinstonTransport() à Winston

Ajoutez le transport à côté de Console. Chaque entrée arrive avec `winstonLevel`, votre `defaultMeta` et vos champs, ainsi que le `errorName` et le `errorMessage` d’une erreur.

```bash
import winston from "winston";
import { RecordingTransport, createLogBrewWinstonTransport } from "@logbrew/sdk";
import { createLogBrewNodeClient } from "@logbrew/node";

const transport = RecordingTransport.alwaysAccept();
const client = createLogBrewNodeClient({ transport });

const logger = winston.createLogger({
  format: winston.format.combine(
    winston.format.errors({ stack: true }),
    winston.format.json()
  ),
  defaultMeta: { service: "taproom" },
  transports: [new winston.transports.Console(), createLogBrewWinstonTransport({ client })]
});
logger.info("order paid", { orderId: "ord_42" });
logger.error(new Error("keg empty"));

await client.shutdown();
for (const { attributes: { level, message, metadata } } of JSON.parse(transport.lastBody()).events) {
  console.log(JSON.stringify({ level, message, metadata }));
}
```

Sortie

```text
{"level":"info","message":"order paid","orderId":"ord_42","service":"taproom"}
{"level":"error","message":"keg empty","service":"taproom","stack":"Error: keg empty\n    at …"}
{"level":"info","message":"order paid","metadata":{"winstonLevel":"info","context.service":"taproom","context.orderId":"ord_42"}}
{"level":"error","message":"keg empty","metadata":{"winstonLevel":"error","context.service":"taproom","errorName":"Error","errorMessage":"keg empty"}}
```

### Reliez chaque log à sa requête Express

`logbrewMiddleware()` ouvre 1 span par requête, et `logbrewErrorHandler()` transforme une erreur levée en problème avec ses frames de stack. Un log Pino dans la requête reçoit le même ID de trace. La dernière colonne montre le début de cet ID.

```bash
import express from "express";
import pino from "pino";
import { RecordingTransport } from "@logbrew/sdk";
import { logbrewErrorHandler, logbrewMiddleware } from "@logbrew/express";
import { createLogBrewNodeClient, installLogBrewPinoInstrumentation } from "@logbrew/node";

const transport = RecordingTransport.alwaysAccept();
const client = createLogBrewNodeClient({ transport });
installLogBrewPinoInstrumentation({ client });
const logger = pino();

const app = express();
app.use(logbrewMiddleware({ client }));
app.get("/taps/:tap", (req, res) => {
  logger.info({ tap: req.params.tap }, "tap opened");
  res.json({ ok: true });
});
app.get("/kegs/:keg", () => {
  throw new Error("keg empty");
});
app.use(logbrewErrorHandler({ client }));
app.use((err, req, res, next) => {
  logger.error(err, "request failed");
  res.status(500).json({ error: "internal" });
});

const server = app.listen(3001, async () => {
  await fetch("http://127.0.0.1:3001/taps/ipa");
  await fetch("http://127.0.0.1:3001/kegs/stout");
  server.close();
  await client.shutdown();
  for (const body of transport.sentBodies) {
    for (const { type, attributes: a } of JSON.parse(body).events) {
      console.log(type, a.title ?? a.name ?? a.message, a.status ?? a.level, (a.traceId ?? a.context.trace.traceId).slice(0, 8));
    }
  }
});
```

Sortie

```text
{"level":30,"time":1795160015082,"pid":27185,"hostname":"taproom","tap":"ipa","msg":"tap opened"}
{"level":50,"time":1795160015140,"pid":27185,"hostname":"taproom","err":{"type":"Error","message":"keg empty","stack":"Error: keg empty\n    at …"},"msg":"request failed"}
log tap opened info 3dc57c32
span GET /taps/:tap ok 3dc57c32
issue GET /kegs/:keg failed error 49e1920b
log request failed error 49e1920b
span GET /kegs/:keg error 49e1920b
```

## Ce que nous avons constaté en testant

Nous avons lancé chaque script de cette page avec Node.js 22.18.0, Pino 10.4.0, Winston 3.19.0 et Express 5.3.0. Les sorties montrent chaque charge préparée par le SDK LogBrew. Un second essai a envoyé les mêmes logs à un serveur LogBrew, puis nous les avons relus.

Le SDK LogBrew lit l’erreur dans l’enregistrement du log, pas dans la ligne affichée. Un appel peut donc n’afficher aucune erreur et l’envoyer quand même. Si le logger jette l’erreur avant de créer l’enregistrement, ou en fait son message, aucun transport ne peut la récupérer.

|  | Pino | Winston |
| --- | --- | --- |
| `level: ""` | S’arrête au démarrage avec une erreur | Journalise tous les niveaux, `debug` compris |
| Un nouveau `logger.level` s’applique tout de suite | Oui | Oui |

## Pino ou Winston, lequel choisir

Gardez le logger que votre app utilise déjà. LogBrew reçoit les entrées des deux.

Winston n’a pas de masquage intégré. Vous écrivez votre propre format pour cela.

|  | Pino | Winston |
| --- | --- | --- |
| Ordre des arguments | `error(err, msg)` | `error(msg, err)` |
| Heure sur chaque ligne | Oui | Avec `format.timestamp()` |
| Stack de `error(err)` | Oui | Avec `format.errors()` |
| Masquage intégré | `redact` | Non |

## Les niveaux de log Node.js dans Pino et Winston

Pino numérote ses niveaux de `trace` 10 à `fatal` 60, et un nombre plus élevé est plus grave. Winston numérote ses niveaux de `error` 0 à `silly` 6, et un nombre plus bas est plus grave.

Les deux journalisent à partir de `info` par défaut. Écrivez `logger.level = "debug"` pour changer le niveau pendant que le processus tourne.

Le niveau d’origine reste dans `pinoLevel` ou `winstonLevel`.

```bash
import pino from "pino";
import winston from "winston";

console.log(pino().levels.values);
console.log(winston.createLogger().levels);
```

Sortie

```text
{ trace: 10, debug: 20, info: 30, warn: 40, error: 50, fatal: 60 }
{ error: 0, warn: 1, info: 2, http: 3, verbose: 4, debug: 5, silly: 6 }
```

| LogBrew | Pino | Winston |
| --- | --- | --- |
| `info` | `trace` `debug` `info` | `silly` `debug` `verbose` `http` `info` |
| `warning` | `warn` | `warn` |
| `error` | `error` | `error` |
| `critical` | `fatal` | Non |

## Ce que LogBrew enregistre

Chaque entrée Pino ou Winston devient 1 log avec son niveau, son message, son niveau d’origine et vos champs. Les champs d’un logger enfant ou de `defaultMeta` suivent, comme `context.service` plus haut.

Une erreur dans l’entrée ajoute `errorName` et `errorMessage`. Définissez `includeErrorStack: true` sur l’une ou l’autre intégration pour envoyer aussi la stack dans `errorStack`.

L’intégration Pino écarte les champs comme `token`, `password` et `cookie` avant d’envoyer un log. Le transport Winston les envoie tels quels, donc retire-les d’abord dans un format Winston.

Avec le middleware Express, chaque log porte l’ID de trace de sa requête. Le problème, le span et les logs d’1 requête en échec partagent cet ID.

- `installLogBrewPinoInstrumentation()`
  - `pinoLevel`: `error`
  - `pinoLevelNumber`: `50`
  - `context.service`: `taproom`
  - `errorName`: `Error`
  - `errorMessage`: `keg empty`
- `createLogBrewWinstonTransport()`
  - `winstonLevel`: `error`
  - `context.service`: `taproom`
  - `errorName`: `Error`
  - `errorMessage`: `keg empty`
- `logbrewErrorHandler()`
  - Problème: `GET /kegs/:keg failed`
  - `exception.type`: `Error`
  - `mechanism`: `express.middleware`
  - `handled`: `false`
  - Frames de stack trace: 10

## Questions fréquentes

### Quel est le niveau de log par défaut de Pino ?

`info`. `pino()` écrit `info`, `warn`, `error` et `fatal`, et ignore `debug` et `trace`. Passez `level` à `pino()` ou modifiez `logger.level` pour le changer.

### Pourquoi Winston journalise-t-il un message vide pour une erreur ?

Le format JSON ignore `message` et `stack` d’un `Error`, car ces propriétés ne sont pas énumérables. Ajoutez `winston.format.errors({ stack: true })` avant `winston.format.json()`.

### Comment journaliser une erreur avec Pino ?

Passez-la en premier, avec `logger.error(err, "pour failed")`, ou dans un champ, avec `logger.error({ err }, "pour failed")`. Pino ignore une erreur placée après le message.

### Faut-il choisir Pino ou Winston ?

Gardez celui que votre app utilise. Pino écrit du JSON sans configuration et masque les données sensibles nativement. Winston construit la ligne avec les formats que vous choisissez. LogBrew reçoit les logs des deux.

### Pourquoi Pino lève-t-il default level must be included in custom levels ?

Le niveau passé n’est pas un niveau Pino, souvent un `LOG_LEVEL` vide. Écrivez `process.env.LOG_LEVEL || "info"` pour qu’une valeur vide revienne à `info`.

## Voyez chaque erreur Node.js avec sa requête

Le SDK Node de LogBrew envoie chaque log Pino ou Winston avec son niveau et ses champs, et le relie à la trace de la requête et au problème. Commencez avec le forfait Free généreux, sans carte bancaire.

[Commencer gratuitement](https://logbrew.co/fr)

## Sources

- [Pino docs, Logging method parameters](https://github.com/pinojs/pino/blob/main/docs/api.md#logging-method-parameters)
- [Pino docs, Redaction](https://github.com/pinojs/pino/blob/main/docs/redaction.md)
- [Winston docs, Logging levels](https://github.com/winstonjs/winston/blob/master/README.md#logging-levels)
- [Winston docs, Formats](https://github.com/winstonjs/winston/blob/master/README.md#formats)
- [Express docs, Error handling](https://expressjs.com/en/guide/error-handling/)
- [winstonjs/winston#1338](https://github.com/winstonjs/winston/issues/1338)

## Autres guides pour les agents, Python, Node.js et React

- [Ajouter un serveur MCP à Claude Code et Codex](https://logbrew.co/fr/guides/mcp-server-claude-code-codex)
- [Utiliser AGENTS.md dans Claude Code et Codex](https://logbrew.co/fr/guides/agents-md)
- [Corriger l’erreur Claude overloaded 529 et l’erreur rate limit 429](https://logbrew.co/fr/guides/claude-overloaded-rate-limit-error)
- [Configurer le module Python logging avec les bons niveaux de log et la capture des exceptions](https://logbrew.co/fr/guides/python-logging)
- [Structured logging avec un format de log et des niveaux que vous cherchez par champ](https://logbrew.co/fr/guides/structured-logging)
- [Configurez le logging Django et gardez la stack trace de chaque erreur 500](https://logbrew.co/fr/guides/django-logging)
- [Configurez le logging FastAPI et gérez les erreurs sans perdre la stack trace](https://logbrew.co/fr/guides/fastapi-logging)
- [Ajoutez un périmètre d’erreur React et loggez les erreurs qu’il laisse passer](https://logbrew.co/fr/guides/react-error-boundary)
- [Trace ID vs span ID, décodés depuis un vrai en-tête traceparent](https://logbrew.co/fr/guides/trace-id)
- [Guides sur les erreurs, logs, traces, métriques et versions](https://logbrew.co/fr/guides)
