---
title: "Configure o logging em Node.js com Pino ou Winston sem perder nenhum erro"
description: "Pino e Winston perdem o erro em algumas chamadas. Veja a configuração de cada logger do Node.js, os níveis de log e as chamadas que mantêm o stack, testadas no Node.js 22."
canonical: "https://logbrew.co/pt-BR/guides/node-logging"
last_updated: "2026-11-20"
---

# Configure o logging em Node.js com Pino ou Winston sem perder nenhum erro

Pino e Winston perdem o erro em algumas chamadas. Veja a configuração de cada logger do Node.js, os níveis de log e as chamadas que mantêm o stack, testadas no Node.js 22.

Testado em 20 de novembro de 2026 com 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

Por [Furkan Erday](https://github.com/furkanerday). Furkan Erday é o fundador do LogBrew. Ele desenvolve o LogBrew com Claude Code e Codex todos os dias.

Canonical: https://logbrew.co/pt-BR/guides/node-logging

## Qual chamada mantém o erro, na tela e no LogBrew

| Chamada de log | Impresso | No LogBrew |
| --- | --- | --- |
| Pino `error(err, msg)` | Mensagem e stack | Nome e mensagem |
| Pino `error(msg, err)` | Perdido | Perdido |
| Winston `error(err)` | `{"level":"error"}` | Nome e mensagem |
| Winston `error(err, msg)` | `"message":{}` | Perdido |
| Winston `error(msg, { err })` | `"err":{}` | Nome e mensagem |
| Winston `error(msg, err)` | Mensagem e stack | Nome e mensagem |

6 chamadas com `new Error("keg empty")` no Pino 10.4 e no Winston 3.19 sem formato.

## Configure um logger com Pino

### Crie 1 logger e deixe ele imprimir JSON

`pino()` registra a partir de `info` e imprime 1 linha JSON por chamada, com `level` numérico, `time`, `pid` e `hostname`. A chamada `debug` não imprimiu nada. Trocamos o nome do host na saída.

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

Saída

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

### Leia o nível do ambiente

Rode com `LOG_LEVEL=debug` e a linha `debug` aparece, sem mudar o código. Um `LOG_LEVEL` vazio derruba o processo. `??` mantém o texto vazio e o Pino lança `default level: must be included in custom levels`. Use `||` se a variável puder ficar vazia.

```bash
import pino from "pino";

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

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

Saída

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

### Passe o erro primeiro e depois a mensagem

O Pino transforma um `Error` no primeiro argumento, ou em um campo `err`, em `err` com `type`, `message` e `stack`. Um erro depois da mensagem some sem aviso. A terceira linha não tem `err`. Cortamos cada stack depois da primeira linha.

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

Saída

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

## Configure um logger com Winston

### Crie o logger com um transport Console

Sem opções, `winston.createLogger()` registra a partir de `info` e imprime JSON. A chamada `debug` não imprimiu nada, e as linhas não têm horário até você adicionar `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");
```

Saída

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

### Adicione format.errors() antes de format.json()

Sem formato, `logger.error(err)` imprime `{"level":"error"}`. O formato JSON pula a mensagem e o stack de um `Error`. Coloque `winston.format.errors({ stack: true })` primeiro e a mesma chamada imprime os dois.

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

Saída

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

### Passe a mensagem primeiro e depois o erro

`logger.error(err, "pour failed")` perde a sua mensagem. `logger.error("pour failed", { err })` imprime `"err":{}`. `logger.error("pour failed", err)` mantém os dois e junta a mensagem do erro à sua, como `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);
```

Saída

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

## Envie os logs do Pino e do Winston para o LogBrew

### Instale os pacotes e defina a chave

`@logbrew/node` captura os logs do Pino, `@logbrew/sdk` traz o transport do Winston e `@logbrew/express` adiciona os traces das requisições. `createLogBrewNodeClient()` lê a chave de `LOGBREW_SERVER_API_KEY`.

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

### Chame installLogBrewPinoInstrumentation() uma vez

Chame antes do primeiro log. O Pino continua imprimindo as próprias linhas, e o LogBrew recebe cada registro com `pinoLevel`, `pinoLevelNumber` e os seus campos. O LogBrew guarda só campos simples, então o objeto `card` ficou de fora. `RecordingTransport` guarda o que o SDK enviou para podermos imprimir. No seu app, tire `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 }));
}
```

Saída

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

### Adicione createLogBrewWinstonTransport() ao Winston

Adicione o transport ao lado do Console. Cada registro chega com `winstonLevel`, o seu `defaultMeta` e os seus campos, e com o `errorName` e o `errorMessage` de um erro.

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

Saída

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

### Ligue cada log à sua requisição do Express

`logbrewMiddleware()` abre 1 span por requisição, e `logbrewErrorHandler()` transforma um erro lançado em um problema com os frames do stack. Um log do Pino dentro da requisição recebe o mesmo ID de trace. A última coluna é o começo desse 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));
    }
  }
});
```

Saída

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

## O que vimos no teste

Rodamos cada script desta página com Node.js 22.18.0, Pino 10.4.0, Winston 3.19.0 e Express 5.3.0. As saídas mostram cada payload que o SDK do LogBrew montou. Em um segundo teste, enviamos os mesmos logs para um servidor do LogBrew e lemos tudo de volta.

O SDK do LogBrew lê o erro no registro do log, não na linha impressa. Por isso uma chamada pode não imprimir nenhum erro e mesmo assim enviá-lo. Se o logger descarta o erro antes de montar o registro, ou transforma o erro na mensagem, nenhum transport consegue recuperá-lo.

|  | Pino | Winston |
| --- | --- | --- |
| `level: ""` | Para na partida com um erro | Registra todos os níveis, inclusive `debug` |
| Um novo `logger.level` vale na hora | Sim | Sim |

## Pino ou Winston, qual usar

Fique com o logger que o seu app já usa. O LogBrew recebe registros dos dois.

O Winston não tem ocultação embutida, então você escreve o seu próprio formato para isso.

|  | Pino | Winston |
| --- | --- | --- |
| Ordem dos argumentos | `error(err, msg)` | `error(msg, err)` |
| Horário em cada linha | Sim | Com `format.timestamp()` |
| Stack de `error(err)` | Sim | Com `format.errors()` |
| Ocultação embutida | `redact` | Não |

## Níveis de log do Node.js no Pino e no Winston

O Pino numera os níveis de `trace` 10 a `fatal` 60, e um número maior é mais grave. O Winston numera os níveis de `error` 0 a `silly` 6, e um número menor é mais grave.

Os dois registram a partir de `info` por padrão. Defina `logger.level = "debug"` para mudar o nível com o processo rodando.

O nível original fica em `pinoLevel` ou `winstonLevel`.

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

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

Saída

```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` | Não |

## O que o LogBrew registra

Cada registro do Pino ou do Winston vira 1 log com nível, mensagem, nível original e os seus campos. Campos de um logger filho ou de `defaultMeta` também chegam, como `context.service` acima.

Um erro no registro adiciona `errorName` e `errorMessage`. Defina `includeErrorStack: true` em qualquer uma das duas integrações para enviar também o stack como `errorStack`.

A integração do Pino descarta campos como `token`, `password` e `cookie` antes de enviar um log. O transport do Winston envia esses campos do jeito que estão, então remova antes com um format do Winston.

Com o middleware do Express, cada log leva o ID de trace da sua requisição. O problema, o span e os logs de 1 requisição com falha compartilham esse 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`
  - Frames de stack: 10

## Perguntas frequentes

### Qual é o nível de log padrão do Pino?

`info`. `pino()` imprime `info`, `warn`, `error` e `fatal`, e descarta `debug` e `trace`. Passe `level` para `pino()` ou defina `logger.level` para mudar.

### Por que o Winston registra uma mensagem vazia para um erro?

O formato JSON pula `message` e `stack` de um `Error`, porque essas propriedades não são enumeráveis. Adicione `winston.format.errors({ stack: true })` antes de `winston.format.json()`.

### Como registrar um erro com o Pino?

Passe o erro primeiro, como `logger.error(err, "pour failed")`, ou dentro de um campo, como `logger.error({ err }, "pour failed")`. O Pino descarta um erro que vem depois da mensagem.

### Devo usar Pino ou Winston?

Fique com o que o seu app usa. O Pino imprime JSON sem configuração e tem ocultação embutida. O Winston monta a linha com os formatos que você escolhe. O LogBrew recebe logs dos dois.

### Por que o Pino lança default level must be included in custom levels?

O nível que você passou não é um nível do Pino. Muitas vezes é um `LOG_LEVEL` vazio. Escreva `process.env.LOG_LEVEL || "info"` para que um valor vazio volte para `info`.

## Veja cada erro do Node.js com a sua requisição

O SDK Node do LogBrew envia cada log do Pino ou do Winston com nível e campos, e liga o log ao trace da requisição e ao problema. Comece no plano gratuito generoso, sem cartão.

[Comece grátis](https://logbrew.co/pt-BR)

## Fontes

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

## Mais guias para agentes, Python, Node.js e React

- [Adicione um servidor MCP ao Claude Code e ao Codex](https://logbrew.co/pt-BR/guides/mcp-server-claude-code-codex)
- [Use AGENTS.md no Claude Code e no Codex](https://logbrew.co/pt-BR/guides/agents-md)
- [Corrija o erro 529 overloaded e o erro 429 de rate limit do Claude](https://logbrew.co/pt-BR/guides/claude-overloaded-rate-limit-error)
- [Configure o Python logging com os níveis de log certos e captura de exceções](https://logbrew.co/pt-BR/guides/python-logging)
- [Structured logging com formato de log e níveis que você busca por campo](https://logbrew.co/pt-BR/guides/structured-logging)
- [Configure o logging do Django e guarde o stack trace de cada erro 500](https://logbrew.co/pt-BR/guides/django-logging)
- [Configure o logging do FastAPI e trate os erros sem perder o stack trace](https://logbrew.co/pt-BR/guides/fastapi-logging)
- [Adicione um error boundary no React e registre os erros que ele deixa passar](https://logbrew.co/pt-BR/guides/react-error-boundary)
- [Trace ID vs span ID, decodificados de um header traceparent real](https://logbrew.co/pt-BR/guides/trace-id)
- [Guias de erros, logs, traces, métricas e versões](https://logbrew.co/pt-BR/guides)
