---
title: "Skonfiguruj logowanie w Node.js z Pino lub Winston i nie zgub żadnego błędu"
description: "Pino i Winston gubią błąd w niektórych wywołaniach. Oto konfiguracja każdego loggera Node.js, poziomy logów i wywołania, które zachowują stos, sprawdzone na Node.js 22."
canonical: "https://logbrew.co/pl/guides/node-logging"
last_updated: "2026-11-20"
---

# Skonfiguruj logowanie w Node.js z Pino lub Winston i nie zgub żadnego błędu

Pino i Winston gubią błąd w niektórych wywołaniach. Oto konfiguracja każdego loggera Node.js, poziomy logów i wywołania, które zachowują stos, sprawdzone na Node.js 22.

Przetestowane 20 listopada 2026 z użyciem 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 i @logbrew/express 0.1.14

Autor [Furkan Erday](https://github.com/furkanerday). Furkan Erday jest założycielem LogBrew. Codziennie rozwija LogBrew z pomocą Claude Code i Codex.

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

## Które wywołanie zachowuje błąd, na ekranie i w LogBrew

| Wywołanie logu | Wypisane | W LogBrew |
| --- | --- | --- |
| Pino `error(err, msg)` | Komunikat i stos | Nazwa i komunikat |
| Pino `error(msg, err)` | Zgubiony | Zgubiony |
| Winston `error(err)` | `{"level":"error"}` | Nazwa i komunikat |
| Winston `error(err, msg)` | `"message":{}` | Zgubiony |
| Winston `error(msg, { err })` | `"err":{}` | Nazwa i komunikat |
| Winston `error(msg, err)` | Komunikat i stos | Nazwa i komunikat |

6 wywołań z `new Error("keg empty")` w Pino 10.4 i w Winston 3.19 bez formatu.

## Skonfiguruj logger Pino

### Utwórz 1 logger i pozwól mu pisać JSON

`pino()` loguje od poziomu `info` w górę i wypisuje 1 linię JSON na wywołanie, z liczbowym `level`, `time`, `pid` i `hostname`. Wywołanie `debug` nic nie wypisało. W wyniku zamieniliśmy nazwę hosta.

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

Wynik

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

### Odczytaj poziom ze zmiennej środowiskowej

Uruchom to z `LOG_LEVEL=debug`, a linia `debug` pojawi się bez zmiany kodu. Pusta zmienna `LOG_LEVEL` zatrzymuje proces. `??` zostawia pusty tekst, a Pino rzuca `default level: must be included in custom levels`. Użyj `||`, jeśli zmienna może być pusta.

```bash
import pino from "pino";

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

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

Wynik

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

### Przekaż najpierw błąd, potem komunikat

Pino zamienia `Error` z pierwszego argumentu albo z pola `err` w `err` z polami `type`, `message` i `stack`. Błąd podany po komunikacie znika bez ostrzeżenia. Trzecia linia nie ma `err`. Każdy stos przycięliśmy po pierwszej linii.

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

Wynik

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

## Skonfiguruj logger Winston

### Utwórz logger z transportem Console

Bez opcji `winston.createLogger()` loguje od poziomu `info` w górę i wypisuje JSON. Wywołanie `debug` nic nie wypisało, a linie nie mają czasu, dopóki nie dodasz `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");
```

Wynik

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

### Dodaj format.errors() przed format.json()

Bez formatu `logger.error(err)` wypisuje `{"level":"error"}`. Format JSON pomija komunikat i stos obiektu `Error`. Wstaw `winston.format.errors({ stack: true })` na początek, a to samo wywołanie wypisze oba.

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

Wynik

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

### Przekaż najpierw komunikat, potem błąd

`logger.error(err, "pour failed")` gubi Twój komunikat. `logger.error("pour failed", { err })` wypisuje `"err":{}`. `logger.error("pour failed", err)` zachowuje oba i dokleja komunikat błędu do Twojego, jako `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);
```

Wynik

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

## Wyślij logi z Pino i Winston do LogBrew

### Zainstaluj pakiety i ustaw klucz

`@logbrew/node` przechwytuje logi Pino, `@logbrew/sdk` zawiera transport dla Winston, a `@logbrew/express` dodaje ślady żądań. `createLogBrewNodeClient()` czyta klucz z `LOGBREW_SERVER_API_KEY`.

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

### Wywołaj installLogBrewPinoInstrumentation() raz

Wywołaj ją przed pierwszym logiem. Pino nadal wypisuje swoje linie, a LogBrew dostaje każdy wpis z `pinoLevel`, `pinoLevelNumber` i Twoimi polami. LogBrew zachowuje tylko płaskie pola, więc obiekt `card` został poza nim. `RecordingTransport` zapisuje to, co wysłało SDK, żebyśmy mogli to wypisać. W swojej aplikacji usuń `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 }));
}
```

Wynik

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

### Dodaj createLogBrewWinstonTransport() do Winston

Dodaj transport obok Console. Każdy wpis przychodzi z `winstonLevel`, Twoim `defaultMeta` i Twoimi polami, a przy błędzie także z `errorName` i `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 }));
}
```

Wynik

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

### Połącz każdy log z jego żądaniem Express

`logbrewMiddleware()` otwiera 1 span na żądanie, a `logbrewErrorHandler()` zamienia rzucony błąd w problem z ramkami stosu. Log z Pino wewnątrz żądania dostaje ten sam identyfikator śladu. Ostatnia kolumna to początek tego identyfikatora.

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

Wynik

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

## Co zobaczyliśmy podczas testu

Każdy skrypt z tej strony uruchomiliśmy na Node.js 22.18.0, Pino 10.4.0, Winston 3.19.0 i Express 5.3.0. Wyniki pokazują każdy ładunek zbudowany przez SDK LogBrew. W drugim uruchomieniu wysłaliśmy te same logi do serwera LogBrew i odczytaliśmy je z powrotem.

SDK LogBrew czyta błąd z wpisu logu, nie z wypisanej linii. Dlatego wywołanie może nie wypisać żadnego błędu, a mimo to go wysłać. Jeśli logger odrzuci błąd, zanim zbuduje wpis, albo zrobi z błędu komunikat, żaden transport go nie odzyska.

|  | Pino | Winston |
| --- | --- | --- |
| `level: ""` | Zatrzymuje się przy starcie z błędem | Loguje każdy poziom, także `debug` |
| Nowe `logger.level` działa od razu | Tak | Tak |

## Pino czy Winston, który wybrać

Zostań przy loggerze, którego używa Twoja aplikacja. LogBrew przyjmuje wpisy z obu.

Winston nie ma wbudowanego ukrywania danych, więc piszesz do tego własny format.

|  | Pino | Winston |
| --- | --- | --- |
| Kolejność argumentów | `error(err, msg)` | `error(msg, err)` |
| Czas w każdej linii | Tak | Z `format.timestamp()` |
| Stos z `error(err)` | Tak | Z `format.errors()` |
| Wbudowane ukrywanie danych | `redact` | Nie |

## Poziomy logów Node.js w Pino i Winston

Pino numeruje poziomy od `trace` 10 do `fatal` 60, a wyższa liczba oznacza poważniejszy wpis. Winston numeruje poziomy od `error` 0 do `silly` 6, a niższa liczba oznacza poważniejszy wpis.

Oba domyślnie logują od poziomu `info` w górę. Ustaw `logger.level = "debug"`, aby zmienić poziom w działającym procesie.

Pierwotny poziom zostaje w `pinoLevel` lub `winstonLevel`.

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

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

Wynik

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

## Co zapisuje LogBrew

Każdy wpis z Pino lub Winston staje się 1 logiem z poziomem, komunikatem, pierwotnym poziomem i Twoimi polami. Pola z loggera potomnego lub z `defaultMeta` też trafiają do LogBrew, jak `context.service` powyżej.

Błąd we wpisie dodaje `errorName` i `errorMessage`. Ustaw `includeErrorStack: true` w jednej z obu integracji, aby wysłać także stos jako `errorStack`.

Integracja Pino odrzuca pola takie jak `token`, `password` i `cookie`, zanim wyśle log. Transport Winston wysyła je bez zmian, więc najpierw usuń je w formacie Winstona.

Z middleware Express każdy log niesie identyfikator śladu swojego żądania. Problem, span i logi 1 nieudanego żądania mają ten sam identyfikator.

- `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()`
  - Problem: `GET /kegs/:keg failed`
  - `exception.type`: `Error`
  - `mechanism`: `express.middleware`
  - `handled`: `false`
  - Ramki stosu: 10

## Najczęściej zadawane pytania

### Jaki jest domyślny poziom logowania w Pino?

`info`. `pino()` wypisuje `info`, `warn`, `error` i `fatal`, a odrzuca `debug` i `trace`. Przekaż `level` do `pino()` albo ustaw `logger.level`, aby to zmienić.

### Dlaczego Winston loguje pusty komunikat dla błędu?

Format JSON pomija `message` i `stack` obiektu `Error`, bo nie są wyliczalne. Dodaj `winston.format.errors({ stack: true })` przed `winston.format.json()`.

### Jak zalogować błąd w Pino?

Przekaż go jako pierwszy, czyli `logger.error(err, "pour failed")`, albo w polu, czyli `logger.error({ err }, "pour failed")`. Pino odrzuca błąd podany po komunikacie.

### Wybrać Pino czy Winston?

Zostań przy tym, którego używa Twoja aplikacja. Pino wypisuje JSON bez konfiguracji i ma wbudowane ukrywanie danych. Winston składa linię z wybranych przez Ciebie formatów. LogBrew przyjmuje logi z obu.

### Dlaczego Pino rzuca default level must be included in custom levels?

Przekazany poziom nie jest poziomem Pino, często to pusta zmienna `LOG_LEVEL`. Napisz `process.env.LOG_LEVEL || "info"`, aby pusta wartość wracała do `info`.

## Zobacz każdy błąd Node.js razem z jego żądaniem

SDK LogBrew dla Node wysyła każdy log z Pino lub Winston z poziomem i polami oraz łączy go ze śladem żądania i z problemem. Zacznij od hojnego darmowego planu, bez karty.

[Zacznij za darmo](https://logbrew.co/pl)

## Źródła

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

## Więcej przewodników po agentach, Pythonie, Node.js i React

- [Dodaj serwer MCP do Claude Code i Codex](https://logbrew.co/pl/guides/mcp-server-claude-code-codex)
- [Jak używać AGENTS.md w Claude Code i Codex](https://logbrew.co/pl/guides/agents-md)
- [Napraw błąd Claude 529 overloaded i błąd 429 rate limit](https://logbrew.co/pl/guides/claude-overloaded-rate-limit-error)
- [Skonfiguruj moduł Python logging z właściwymi poziomami i przechwytywaniem wyjątków](https://logbrew.co/pl/guides/python-logging)
- [Logowanie strukturalne z formatem logów i poziomami, które przeszukasz po polu](https://logbrew.co/pl/guides/structured-logging)
- [Skonfiguruj logowanie w Django i zachowaj ślad stosu każdego błędu 500](https://logbrew.co/pl/guides/django-logging)
- [Skonfiguruj logowanie w FastAPI i obsłuż błędy bez utraty śladu stosu](https://logbrew.co/pl/guides/fastapi-logging)
- [Dodaj error boundary w React i loguj błędy, których nie łapie](https://logbrew.co/pl/guides/react-error-boundary)
- [ID śladu a ID spanu, rozłożone na prawdziwym nagłówku traceparent](https://logbrew.co/pl/guides/trace-id)
- [Przewodniki po błędach, logach, śladach, metrykach i wydaniach](https://logbrew.co/pl/guides)
