---
title: "Node.js-Logging mit Pino oder Winston einrichten und keinen Fehler verlieren"
description: "Pino und Winston verlieren beide bei manchen Aufrufen den Fehler. Hier findest du die Einrichtung jedes Node.js-Loggers, die Log-Level und die Aufrufe, die den Stack behalten, getestet mit Node.js 22."
canonical: "https://logbrew.co/de/guides/node-logging"
last_updated: "2026-11-20"
---

# Node.js-Logging mit Pino oder Winston einrichten und keinen Fehler verlieren

Pino und Winston verlieren beide bei manchen Aufrufen den Fehler. Hier findest du die Einrichtung jedes Node.js-Loggers, die Log-Level und die Aufrufe, die den Stack behalten, getestet mit Node.js 22.

Getestet am 20. November 2026 mit 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 und @logbrew/express 0.1.14

Von [Furkan Erday](https://github.com/furkanerday). Furkan Erday hat LogBrew gegründet. Er entwickelt LogBrew jeden Tag mit Claude Code und Codex.

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

## Welcher Fehleraufruf den Fehler behält, in der Ausgabe und in LogBrew

| Log-Aufruf | Ausgegeben | In LogBrew |
| --- | --- | --- |
| Pino `error(err, msg)` | Nachricht und Stack | Name und Nachricht |
| Pino `error(msg, err)` | Verloren | Verloren |
| Winston `error(err)` | `{"level":"error"}` | Name und Nachricht |
| Winston `error(err, msg)` | `"message":{}` | Verloren |
| Winston `error(msg, { err })` | `"err":{}` | Name und Nachricht |
| Winston `error(msg, err)` | Nachricht und Stack | Name und Nachricht |

6 Aufrufe mit `new Error("keg empty")` in Pino 10.4 und in Winston 3.19 ohne Format.

## Einen Pino-Logger einrichten

### 1 Logger erstellen und JSON ausgeben lassen

`pino()` loggt ab `info` und gibt pro Aufruf 1 JSON-Zeile aus, mit numerischem `level`, `time`, `pid` und `hostname`. Der `debug`-Aufruf gab nichts aus. Den Hostnamen in der Ausgabe haben wir ersetzt.

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

Ausgabe

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

### Das Level aus der Umgebung lesen

Starte das Skript mit `LOG_LEVEL=debug`, und die `debug`-Zeile erscheint ohne Codeänderung. Ein leeres `LOG_LEVEL` beendet den Prozess. `??` behält den leeren Text, und Pino wirft `default level: must be included in custom levels`. Nimm `||`, wenn die Variable leer sein kann.

```bash
import pino from "pino";

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

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

Ausgabe

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

### Erst den Fehler übergeben, dann die Nachricht

Pino macht aus einem `Error` im ersten Argument oder in einem `err`-Feld ein `err` mit `type`, `message` und `stack`. Ein Fehler nach der Nachricht geht ohne Warnung verloren. Die dritte Zeile hat kein `err`. Jeden Stack haben wir nach der ersten Zeile gekürzt.

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

Ausgabe

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

## Einen Winston-Logger einrichten

### Den Logger mit einem Console-Transport erstellen

Ohne Optionen loggt `winston.createLogger()` ab `info` und gibt JSON aus. Der `debug`-Aufruf gab nichts aus, und die Zeilen haben keine Uhrzeit, bis du `winston.format.timestamp()` hinzufügst.

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

Ausgabe

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

### format.errors() vor format.json() setzen

Ohne Format gibt `logger.error(err)` nur `{"level":"error"}` aus. Das JSON-Format überspringt Nachricht und Stack eines `Error`. Setz `winston.format.errors({ stack: true })` an den Anfang, dann gibt derselbe Aufruf beides aus.

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

Ausgabe

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

### Erst die Nachricht übergeben, dann den Fehler

`logger.error(err, "pour failed")` verliert deine Nachricht. `logger.error("pour failed", { err })` gibt `"err":{}` aus. `logger.error("pour failed", err)` behält beides und hängt die Fehlermeldung an deine an, 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);
```

Ausgabe

```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- und Winston-Logs an LogBrew senden

### Pakete installieren und den Key setzen

`@logbrew/node` erfasst Pino-Logs, `@logbrew/sdk` enthält den Winston-Transport, und `@logbrew/express` ergänzt die Traces der Anfragen. `createLogBrewNodeClient()` liest den Key aus `LOGBREW_SERVER_API_KEY`.

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

### Rufe installLogBrewPinoInstrumentation() einmal auf

Ruf es vor dem ersten Log auf. Pino gibt seine Zeilen weiter selbst aus, und LogBrew bekommt jeden Eintrag mit `pinoLevel`, `pinoLevelNumber` und deinen Feldern. LogBrew behält nur flache Felder, darum blieb das Objekt `card` draußen. `RecordingTransport` hält fest, was das SDK gesendet hat, damit wir es ausgeben können. In deiner App lässt du `transport` weg.

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

Ausgabe

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

### Füge Winston createLogBrewWinstonTransport() hinzu

Füg den Transport neben Console ein. Jeder Eintrag kommt mit `winstonLevel`, deinem `defaultMeta` und deinen Feldern an, bei einem Fehler auch mit `errorName` und `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 }));
}
```

Ausgabe

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

### Verknüpfe jedes Log mit seiner Express-Anfrage

`logbrewMiddleware()` öffnet pro Anfrage 1 Span, und `logbrewErrorHandler()` macht aus einem geworfenen Fehler ein Issue mit seinen Stack-Frames. Ein Pino-Log in der Anfrage bekommt dieselbe Trace-ID. Die letzte Spalte zeigt den Anfang dieser 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));
    }
  }
});
```

Ausgabe

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

## Was wir beim Testen gesehen haben

Wir haben jedes Skript auf dieser Seite mit Node.js 22.18.0, Pino 10.4.0, Winston 3.19.0 und Express 5.3.0 ausgeführt. Die Ausgaben zeigen jede Nutzlast, die das LogBrew SDK gebaut hat. In einem zweiten Lauf gingen dieselben Logs an einen LogBrew-Server, und wir haben sie wieder ausgelesen.

Das LogBrew SDK liest den Fehler aus dem Log-Eintrag, nicht aus der ausgegebenen Zeile. Ein Aufruf kann also keinen Fehler ausgeben und ihn trotzdem senden. Verwirft der Logger den Fehler, bevor er den Eintrag baut, oder macht er den Fehler zur Nachricht, holt ihn kein Transport zurück.

|  | Pino | Winston |
| --- | --- | --- |
| `level: ""` | Stoppt beim Start mit einem Fehler | Loggt jedes Level, auch `debug` |
| Ein neues `logger.level` wirkt sofort | Ja | Ja |

## Pino oder Winston, was du nehmen solltest

Bleib bei dem Logger, den deine App schon nutzt. LogBrew nimmt Einträge von beiden an.

Winston hat keine eingebaute Schwärzung, dafür schreibst du ein eigenes Format.

|  | Pino | Winston |
| --- | --- | --- |
| Reihenfolge der Argumente | `error(err, msg)` | `error(msg, err)` |
| Zeit in jeder Zeile | Ja | Mit `format.timestamp()` |
| Stack aus `error(err)` | Ja | Mit `format.errors()` |
| Eingebaute Schwärzung | `redact` | Nein |

## Node.js-Log-Level in Pino und Winston

Pino nummeriert seine Level von `trace` 10 bis `fatal` 60, eine höhere Zahl ist schwerwiegender. Winston nummeriert seine Level von `error` 0 bis `silly` 6, eine niedrigere Zahl ist schwerwiegender.

Beide loggen standardmäßig ab `info`. Setz `logger.level = "debug"`, um das Level im laufenden Prozess zu ändern.

Das ursprüngliche Level bleibt in `pinoLevel` oder `winstonLevel` erhalten.

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

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

Ausgabe

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

## Was LogBrew speichert

Jeder Pino- oder Winston-Eintrag wird 1 Log mit Level, Nachricht, ursprünglichem Level und deinen Feldern. Felder aus einem Child-Logger oder aus `defaultMeta` kommen mit, wie `context.service` oben.

Ein Fehler im Eintrag ergänzt `errorName` und `errorMessage`. Setz `includeErrorStack: true` an einer der beiden Integrationen, um auch den Stack als `errorStack` zu senden.

Die Pino-Integration verwirft Felder wie `token`, `password` und `cookie`, bevor sie ein Log sendet. Der Winston-Transport sendet sie unverändert. Entferne sie also vorher in einem Winston-Format.

Mit der Express-Middleware trägt jedes Log die Trace-ID seiner Anfrage. Issue, Span und Logs einer fehlgeschlagenen Anfrage teilen diese 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

## Häufige Fragen

### Was ist das Standard-Log-Level in Pino?

`info`. `pino()` gibt `info`, `warn`, `error` und `fatal` aus und verwirft `debug` und `trace`. Übergib `level` an `pino()` oder setz `logger.level`, um es zu ändern.

### Warum loggt Winston bei einem Fehler eine leere Nachricht?

Das JSON-Format überspringt `message` und `stack` eines `Error`, weil sie nicht aufzählbar sind. Füg `winston.format.errors({ stack: true })` vor `winston.format.json()` ein.

### Wie logge ich einen Fehler mit Pino?

Übergib ihn zuerst, als `logger.error(err, "pour failed")`, oder in einem Feld, als `logger.error({ err }, "pour failed")`. Pino verwirft einen Fehler, der nach der Nachricht kommt.

### Soll ich Pino oder Winston nehmen?

Bleib bei dem, den deine App nutzt. Pino gibt ohne Einrichtung JSON aus und schwärzt Felder von Haus aus. Winston baut die Zeile aus Formaten, die du wählst. LogBrew nimmt Logs von beiden an.

### Warum wirft Pino default level must be included in custom levels?

Das übergebene Level ist kein Pino-Level, oft ein leeres `LOG_LEVEL`. Schreib `process.env.LOG_LEVEL || "info"`, damit ein leerer Wert auf `info` zurückfällt.

## Jeden Node.js-Fehler mit seiner Anfrage sehen

Das LogBrew Node SDK sendet jedes Pino- oder Winston-Log mit Level und Feldern und verknüpft es mit dem Trace der Anfrage und dem Issue. Starte mit dem großzügigen kostenlosen Plan, ohne Kreditkarte.

[Kostenlos starten](https://logbrew.co/de)

## Quellen

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

## Weitere Anleitungen für Agenten, Python, Node.js und React

- [MCP-Server in Claude Code und Codex hinzufügen](https://logbrew.co/de/guides/mcp-server-claude-code-codex)
- [AGENTS.md in Claude Code und Codex nutzen](https://logbrew.co/de/guides/agents-md)
- [Claude-Fehler 529 overloaded und 429 Rate Limit beheben](https://logbrew.co/de/guides/claude-overloaded-rate-limit-error)
- [Python-Logging einrichten mit den richtigen Log-Leveln und Exception-Erfassung](https://logbrew.co/de/guides/python-logging)
- [Structured Logging mit Log-Format und Log-Leveln, die du nach Feld durchsuchst](https://logbrew.co/de/guides/structured-logging)
- [Django-Logging einrichten und den Traceback jedes 500-Fehlers behalten](https://logbrew.co/de/guides/django-logging)
- [FastAPI-Logging einrichten und Fehler behandeln, ohne den Traceback zu verlieren](https://logbrew.co/de/guides/fastapi-logging)
- [Eine React Error Boundary bauen und die Fehler loggen, die sie verpasst](https://logbrew.co/de/guides/react-error-boundary)
- [Trace-ID vs. Span-ID, an einem echten traceparent-Header erklärt](https://logbrew.co/de/guides/trace-id)
- [Anleitungen zu Fehlern, Logs, Traces, Metriken und Releases](https://logbrew.co/de/guides)
