---
title: "Configura il logging in Node.js con Pino o Winston senza perdere nessun errore"
description: "Pino e Winston perdono entrambi l’errore in alcune chiamate. Ecco la configurazione di ogni logger Node.js, i livelli di log e le chiamate che tengono lo stack, provate su Node.js 22."
canonical: "https://logbrew.co/it/guides/node-logging"
last_updated: "2026-11-20"
---

# Configura il logging in Node.js con Pino o Winston senza perdere nessun errore

Pino e Winston perdono entrambi l’errore in alcune chiamate. Ecco la configurazione di ogni logger Node.js, i livelli di log e le chiamate che tengono lo stack, provate su Node.js 22.

Testato il 20 novembre 2026 con 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 e @logbrew/express 0.1.14

Di [Furkan Erday](https://github.com/furkanerday). Furkan Erday è il fondatore di LogBrew. Sviluppa LogBrew ogni giorno con Claude Code e Codex.

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

## Quale chiamata tiene l’errore, a schermo e in LogBrew

| Chiamata di log | Scritto | In LogBrew |
| --- | --- | --- |
| Pino `error(err, msg)` | Messaggio e stack | Nome e messaggio |
| Pino `error(msg, err)` | Perso | Perso |
| Winston `error(err)` | `{"level":"error"}` | Nome e messaggio |
| Winston `error(err, msg)` | `"message":{}` | Perso |
| Winston `error(msg, { err })` | `"err":{}` | Nome e messaggio |
| Winston `error(msg, err)` | Messaggio e stack | Nome e messaggio |

6 chiamate con `new Error("keg empty")` in Pino 10.4 e in Winston 3.19 senza formato.

## Configura un logger Pino

### Crea 1 logger e lascia che scriva JSON

`pino()` registra da `info` in su e scrive 1 riga JSON per chiamata, con un `level` numerico, `time`, `pid` e `hostname`. La chiamata `debug` non ha scritto nulla. Nell’output abbiamo sostituito il nome dell’host.

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

Output

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

### Leggi il livello dall’ambiente

Eseguilo con `LOG_LEVEL=debug` e la riga `debug` compare, senza cambiare il codice. Un `LOG_LEVEL` vuoto ferma il processo. `??` tiene il testo vuoto e Pino lancia `default level: must be included in custom levels`. Usa `||` se la variabile può essere vuota.

```bash
import pino from "pino";

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

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

Output

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

### Passa prima l’errore, poi il messaggio

Pino trasforma un `Error` nel primo argomento, o in un campo `err`, in `err` con `type`, `message` e `stack`. Un errore dopo il messaggio si perde senza avvisi. La terza riga non ha `err`. Abbiamo tagliato ogni stack dopo la prima riga.

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

Output

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

## Configura un logger Winston

### Crea il logger con un transport Console

Senza opzioni, `winston.createLogger()` registra da `info` in su e scrive JSON. La chiamata `debug` non ha scritto nulla, e le righe non hanno l’ora finché non aggiungi `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");
```

Output

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

### Aggiungi format.errors() prima di format.json()

Senza formato, `logger.error(err)` scrive `{"level":"error"}`. Il formato JSON salta il messaggio e lo stack di un `Error`. Metti `winston.format.errors({ stack: true })` all’inizio e la stessa chiamata li scrive entrambi.

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

Output

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

### Passa prima il messaggio, poi l’errore

`logger.error(err, "pour failed")` perde il tuo messaggio. `logger.error("pour failed", { err })` scrive `"err":{}`. `logger.error("pour failed", err)` tiene entrambi e aggiunge il messaggio dell’errore al tuo, come `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);
```

Output

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

## Invia i log di Pino e Winston a LogBrew

### Installa i pacchetti e imposta la chiave

`@logbrew/node` cattura i log di Pino, `@logbrew/sdk` contiene il transport per Winston e `@logbrew/express` aggiunge le tracce delle richieste. `createLogBrewNodeClient()` legge la chiave da `LOGBREW_SERVER_API_KEY`.

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

### Chiama installLogBrewPinoInstrumentation() una volta

Chiamala prima del primo log. Pino continua a scrivere le sue righe, e LogBrew riceve ogni record con `pinoLevel`, `pinoLevelNumber` e i tuoi campi. LogBrew tiene solo i campi semplici, quindi l’oggetto `card` è rimasto fuori. `RecordingTransport` conserva quello che l’SDK ha inviato, così possiamo stamparlo. Nella tua app, togli `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 }));
}
```

Output

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

### Aggiungi createLogBrewWinstonTransport() a Winston

Aggiungi il transport accanto a Console. Ogni record arriva con `winstonLevel`, il tuo `defaultMeta` e i tuoi campi, e con `errorName` ed `errorMessage` di un errore.

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

Output

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

### Collega ogni log alla sua richiesta Express

`logbrewMiddleware()` apre 1 span per richiesta, e `logbrewErrorHandler()` trasforma un errore lanciato in un problema con i suoi frame dello stack. Un log di Pino dentro la richiesta riceve lo stesso ID di traccia. L’ultima colonna è l’inizio di quell’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));
    }
  }
});
```

Output

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

## Cosa abbiamo visto nei test

Abbiamo eseguito ogni script di questa pagina con Node.js 22.18.0, Pino 10.4.0, Winston 3.19.0 ed Express 5.3.0. Gli output mostrano ogni payload creato dall’SDK di LogBrew. In una seconda prova abbiamo inviato gli stessi log a un server LogBrew e li abbiamo riletti.

L’SDK di LogBrew legge l’errore dal record del log, non dalla riga stampata. Così una chiamata può non scrivere nessun errore e inviarlo lo stesso. Se il logger scarta l’errore prima di creare il record, o lo usa come messaggio, nessun transport può recuperarlo.

|  | Pino | Winston |
| --- | --- | --- |
| `level: ""` | Si ferma all’avvio con un errore | Registra ogni livello, anche `debug` |
| Un nuovo `logger.level` ha effetto subito | Sì | Sì |

## Pino o Winston, quale usare

Tieni il logger che la tua app usa già. LogBrew riceve i record da entrambi.

Winston non ha un mascheramento integrato, quindi per questo scrivi un tuo formato.

|  | Pino | Winston |
| --- | --- | --- |
| Ordine degli argomenti | `error(err, msg)` | `error(msg, err)` |
| Orario su ogni riga | Sì | Con `format.timestamp()` |
| Stack da `error(err)` | Sì | Con `format.errors()` |
| Mascheramento integrato | `redact` | No |

## Livelli di log Node.js in Pino e Winston

Pino numera i suoi livelli da `trace` 10 a `fatal` 60, e un numero più alto è più grave. Winston numera i suoi livelli da `error` 0 a `silly` 6, e un numero più basso è più grave.

Entrambi registrano da `info` in su per impostazione predefinita. Imposta `logger.level = "debug"` per cambiarlo mentre il processo è attivo.

Il livello originale resta in `pinoLevel` o `winstonLevel`.

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

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

Output

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

## Cosa registra LogBrew

Ogni record di Pino o Winston diventa 1 log con livello, messaggio, livello originale e i tuoi campi. Arrivano anche i campi di un logger figlio o di `defaultMeta`, come `context.service` sopra.

Un errore nel record aggiunge `errorName` ed `errorMessage`. Imposta `includeErrorStack: true` su una delle due integrazioni per inviare anche lo stack come `errorStack`.

L’integrazione di Pino scarta campi come `token`, `password` e `cookie` prima di inviare un log. Il transport di Winston li invia così come sono, quindi toglili prima con un format di Winston.

Con il middleware di Express, ogni log porta l’ID di traccia della sua richiesta. Il problema, lo span e i log di 1 richiesta fallita condividono quell’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()`
  - Problema: `GET /kegs/:keg failed`
  - `exception.type`: `Error`
  - `mechanism`: `express.middleware`
  - `handled`: `false`
  - Frame dello stack: 10

## Domande frequenti

### Qual è il livello di log predefinito in Pino?

`info`. `pino()` scrive `info`, `warn`, `error` e `fatal`, e scarta `debug` e `trace`. Passa `level` a `pino()` o imposta `logger.level` per cambiarlo.

### Perché Winston registra un messaggio vuoto per un errore?

Il formato JSON salta `message` e `stack` di un `Error`, perché non sono enumerabili. Aggiungi `winston.format.errors({ stack: true })` prima di `winston.format.json()`.

### Come registro un errore con Pino?

Passalo per primo, come `logger.error(err, "pour failed")`, oppure in un campo, come `logger.error({ err }, "pour failed")`. Pino scarta un errore che arriva dopo il messaggio.

### Meglio Pino o Winston?

Tieni quello che usa la tua app. Pino scrive JSON senza configurazione e ha il mascheramento integrato. Winston costruisce la riga con i formati che scegli. LogBrew riceve i log da entrambi.

### Perché Pino lancia default level must be included in custom levels?

Il livello passato non è un livello di Pino, spesso è un `LOG_LEVEL` vuoto. Scrivi `process.env.LOG_LEVEL || "info"`, così un valore vuoto torna a `info`.

## Vedi ogni errore Node.js con la sua richiesta

L’SDK Node di LogBrew invia ogni log di Pino o Winston con livello e campi, e lo collega alla traccia della richiesta e al problema. Inizia con il generoso piano gratuito, senza carta.

[Inizia gratis](https://logbrew.co/it)

## Fonti

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

## Altre guide per gli agenti, Python, Node.js e React

- [Aggiungi un server MCP a Claude Code e Codex](https://logbrew.co/it/guides/mcp-server-claude-code-codex)
- [Usa AGENTS.md in Claude Code e Codex](https://logbrew.co/it/guides/agents-md)
- [Risolvi l’errore overloaded 529 e l’errore di rate limit 429 di Claude](https://logbrew.co/it/guides/claude-overloaded-rate-limit-error)
- [Configura il modulo Python logging con i livelli di log giusti e la cattura delle eccezioni](https://logbrew.co/it/guides/python-logging)
- [Structured logging con un formato dei log e livelli che puoi cercare per campo](https://logbrew.co/it/guides/structured-logging)
- [Configura il logging di Django e conserva lo stack trace di ogni errore 500](https://logbrew.co/it/guides/django-logging)
- [Configura il logging di FastAPI e gestisci gli errori senza perdere lo stack trace](https://logbrew.co/it/guides/fastapi-logging)
- [Aggiungi un boundary di errore React e registra gli errori che si lascia sfuggire](https://logbrew.co/it/guides/react-error-boundary)
- [ID traccia vs ID span, decodificati da un vero header traceparent](https://logbrew.co/it/guides/trace-id)
- [Guide su errori, log, tracce, metriche e release](https://logbrew.co/it/guides)
