---
title: "Node.js-logging instellen met Pino of Winston zonder één fout te missen"
description: "Pino en Winston verliezen allebei bij sommige aanroepen de fout. Hier lees je hoe je elke Node.js-logger instelt, welke logniveaus er zijn en welke aanroepen de stack behouden, getest op Node.js 22."
canonical: "https://logbrew.co/nl/guides/node-logging"
last_updated: "2026-11-20"
---

# Node.js-logging instellen met Pino of Winston zonder één fout te missen

Pino en Winston verliezen allebei bij sommige aanroepen de fout. Hier lees je hoe je elke Node.js-logger instelt, welke logniveaus er zijn en welke aanroepen de stack behouden, getest op Node.js 22.

Getest op 20 november 2026 met 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 en @logbrew/express 0.1.14

Door [Furkan Erday](https://github.com/furkanerday). Furkan Erday is de oprichter van LogBrew. Hij bouwt LogBrew elke dag met Claude Code en Codex.

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

## Welke aanroep de fout houdt, op het scherm en in LogBrew

| Logaanroep | Geschreven | In LogBrew |
| --- | --- | --- |
| Pino `error(err, msg)` | Bericht en stack | Naam en bericht |
| Pino `error(msg, err)` | Kwijt | Kwijt |
| Winston `error(err)` | `{"level":"error"}` | Naam en bericht |
| Winston `error(err, msg)` | `"message":{}` | Kwijt |
| Winston `error(msg, { err })` | `"err":{}` | Naam en bericht |
| Winston `error(msg, err)` | Bericht en stack | Naam en bericht |

6 aanroepen met `new Error("keg empty")` in Pino 10.4 en in Winston 3.19 zonder format.

## Een Pino-logger instellen

### Maak 1 logger en laat hem JSON schrijven

`pino()` logt vanaf `info` en schrijft 1 JSON-regel per aanroep, met een numeriek `level`, `time`, `pid` en `hostname`. De `debug`-aanroep schreef niets. De hostnaam in de uitvoer hebben we vervangen.

```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");
```

Uitvoer

```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"}
```

### Lees het niveau uit de omgeving

Start dit met `LOG_LEVEL=debug` en de `debug`-regel verschijnt, zonder codewijziging. Een lege `LOG_LEVEL` stopt het proces. `??` houdt de lege tekst en Pino gooit `default level: must be included in custom levels`. Gebruik `||` als de variabele leeg kan zijn.

```bash
import pino from "pino";

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

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

Uitvoer

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

### Geef eerst de fout mee, dan het bericht

Pino maakt van een `Error` als eerste argument, of in een `err`-veld, een `err` met `type`, `message` en `stack`. Een fout na het bericht raakt zonder waarschuwing kwijt. De derde regel heeft geen `err`. Elke stack hebben we na de eerste regel afgekapt.

```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);
```

Uitvoer

```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"}
```

## Een Winston-logger instellen

### Maak de logger met een Console-transport

Zonder opties logt `winston.createLogger()` vanaf `info` en schrijft JSON. De `debug`-aanroep schreef niets, en de regels hebben geen tijd tot je `winston.format.timestamp()` toevoegt.

```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");
```

Uitvoer

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

### Zet het foutformat vóór format.json()

Zonder format schrijft `logger.error(err)` alleen `{"level":"error"}`. Het JSON-format slaat het bericht en de stack van een `Error` over. Zet `winston.format.errors({ stack: true })` vooraan, en dezelfde aanroep schrijft allebei.

```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);
```

Uitvoer

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

### Geef eerst het bericht mee, dan de fout

`logger.error(err, "pour failed")` verliest je bericht. `logger.error("pour failed", { err })` schrijft `"err":{}`. `logger.error("pour failed", err)` houdt allebei en plakt de foutmelding achter de jouwe, als `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);
```

Uitvoer

```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 …"}
```

## Pino- en Winston-logs naar LogBrew sturen

### Installeer de pakketten en stel de sleutel in

`@logbrew/node` vangt Pino-logs op, `@logbrew/sdk` bevat het Winston-transport en `@logbrew/express` voegt de traces van requests toe. `createLogBrewNodeClient()` leest de sleutel uit `LOGBREW_SERVER_API_KEY`.

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

### Roep installLogBrewPinoInstrumentation() één keer aan

Roep het aan vóór de eerste log. Pino schrijft zijn eigen regels nog steeds, en LogBrew krijgt elk record met `pinoLevel`, `pinoLevelNumber` en je velden. LogBrew houdt alleen platte velden, dus het object `card` bleef buiten. `RecordingTransport` bewaart wat de SDK stuurde, zodat we het kunnen tonen. Laat `transport` weg in je app.

```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 }));
}
```

Uitvoer

```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"}
```

### Voeg createLogBrewWinstonTransport() toe aan Winston

Zet het transport naast Console. Elk record komt binnen met `winstonLevel`, je `defaultMeta` en je velden, en bij een fout met `errorName` en `errorMessage`.

```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 }));
}
```

Uitvoer

```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"}}
```

### Koppel elke log aan zijn Express-request

`logbrewMiddleware()` opent 1 span per request, en `logbrewErrorHandler()` maakt van een gegooide fout een issue met zijn stackframes. Een Pino-log binnen het request krijgt dezelfde trace-ID. De laatste kolom is het begin van die 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));
    }
  }
});
```

Uitvoer

```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
```

## Wat we zagen in onze test

We draaiden elk script op deze pagina met Node.js 22.18.0, Pino 10.4.0, Winston 3.19.0 en Express 5.3.0. De uitvoer toont elke payload die de LogBrew-SDK bouwde. In een tweede run stuurden we dezelfde logs naar een LogBrew-server en lazen we ze terug.

De LogBrew-SDK leest de fout uit het logrecord, niet uit de geschreven regel. Een aanroep kan dus geen fout schrijven en hem toch sturen. Laat de logger de fout vallen voordat hij het record bouwt, of maakt hij de fout tot bericht, dan haalt geen transport hem terug.

|  | Pino | Winston |
| --- | --- | --- |
| `level: ""` | Stopt bij de start met een fout | Logt elk niveau, ook `debug` |
| Een nieuwe `logger.level` werkt meteen | Ja | Ja |

## Pino of Winston, welke kies je

Houd de logger die je app al gebruikt. LogBrew neemt records van allebei aan.

Winston heeft geen ingebouwde afscherming, dus daarvoor schrijf je een eigen format.

|  | Pino | Winston |
| --- | --- | --- |
| Volgorde van de argumenten | `error(err, msg)` | `error(msg, err)` |
| Tijd op elke regel | Ja | Met `format.timestamp()` |
| Stack uit `error(err)` | Ja | Met `format.errors()` |
| Ingebouwde afscherming | `redact` | Nee |

## Node.js-logniveaus in Pino en Winston

Pino nummert zijn niveaus van `trace` 10 tot `fatal` 60, en een hoger getal is ernstiger. Winston nummert zijn niveaus van `error` 0 tot `silly` 6, en een lager getal is ernstiger.

Beide loggen standaard vanaf `info`. Zet `logger.level = "debug"` om het niveau te wijzigen terwijl het proces draait.

Het oorspronkelijke niveau blijft in `pinoLevel` of `winstonLevel`.

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

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

Uitvoer

```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` | Nee |

## Wat LogBrew vastlegt

Elk Pino- of Winston-record wordt 1 log met niveau, bericht, oorspronkelijk niveau en je velden. Velden van een child-logger of uit `defaultMeta` komen mee, zoals `context.service` hierboven.

Een fout in het record voegt `errorName` en `errorMessage` toe. Zet `includeErrorStack: true` op een van beide integraties om ook de stack als `errorStack` te sturen.

De Pino-integratie laat velden als `token`, `password` en `cookie` vallen voordat ze een log stuurt. Het Winston-transport stuurt ze ongewijzigd, dus haal ze eerst weg in een Winston-format.

Met de Express-middleware draagt elke log de trace-ID van zijn request. Het issue, de span en de logs van 1 mislukt request delen die 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()`
  - Issue: `GET /kegs/:keg failed`
  - `exception.type`: `Error`
  - `mechanism`: `express.middleware`
  - `handled`: `false`
  - Stackframes: 10

## Veelgestelde vragen

### Wat is het standaard logniveau in Pino?

`info`. `pino()` schrijft `info`, `warn`, `error` en `fatal`, en laat `debug` en `trace` vallen. Geef `level` mee aan `pino()` of zet `logger.level` om het te wijzigen.

### Waarom logt Winston een leeg bericht bij een fout?

Het JSON-format slaat `message` en `stack` van een `Error` over, omdat die niet enumerable zijn. Zet `winston.format.errors({ stack: true })` vóór `winston.format.json()`.

### Hoe log ik een fout met Pino?

Geef hem als eerste mee, als `logger.error(err, "pour failed")`, of in een veld, als `logger.error({ err }, "pour failed")`. Pino laat een fout na het bericht vallen.

### Kies ik Pino of Winston?

Houd de logger die je app gebruikt. Pino schrijft JSON zonder extra instellingen en schermt velden standaard af. Winston bouwt de regel uit formats die jij kiest. LogBrew neemt logs van allebei aan.

### Waarom gooit Pino default level must be included in custom levels?

Het niveau dat je meegaf is geen Pino-niveau, vaak een lege `LOG_LEVEL`. Schrijf `process.env.LOG_LEVEL || "info"`, zodat een lege waarde terugvalt op `info`.

## Zie elke Node.js-fout met zijn request

De LogBrew Node-SDK stuurt elke Pino- of Winston-log met niveau en velden, en koppelt hem aan de trace van het request en aan het issue. Begin met het ruime gratis abonnement, zonder creditcard.

[Gratis beginnen](https://logbrew.co/nl)

## Bronnen

- [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)

## Meer handleidingen voor agents, Python, Node.js en React

- [Een MCP-server toevoegen aan Claude Code en Codex](https://logbrew.co/nl/guides/mcp-server-claude-code-codex)
- [AGENTS.md gebruiken in Claude Code en Codex](https://logbrew.co/nl/guides/agents-md)
- [Claude overloaded error 529 en rate limit error 429 oplossen](https://logbrew.co/nl/guides/claude-overloaded-rate-limit-error)
- [Python-logging instellen met de juiste logniveaus en exceptions met traceback](https://logbrew.co/nl/guides/python-logging)
- [Structured logging met een logformaat en logniveaus die je per veld doorzoekt](https://logbrew.co/nl/guides/structured-logging)
- [Stel Django-logging in en bewaar de stacktrace van elke 500-fout](https://logbrew.co/nl/guides/django-logging)
- [Stel FastAPI-logging in en handel fouten af zonder de stacktrace te verliezen](https://logbrew.co/nl/guides/fastapi-logging)
- [Voeg een React error boundary toe en log de fouten die hij mist](https://logbrew.co/nl/guides/react-error-boundary)
- [Trace-ID vs span-ID, ontleed in een echte traceparent-header](https://logbrew.co/nl/guides/trace-id)
- [Handleidingen voor fouten, logs, traces, metrics en releases](https://logbrew.co/nl/guides)
