---
title: "Configura el logging en Node.js con Pino o Winston sin perder ningún error"
description: "Pino y Winston pierden el error en algunas llamadas. Aquí tienes la configuración de cada logger de Node.js, los niveles de log y las llamadas que conservan el stack, probadas en Node.js 22."
canonical: "https://logbrew.co/es/guides/node-logging"
last_updated: "2026-11-20"
---

# Configura el logging en Node.js con Pino o Winston sin perder ningún error

Pino y Winston pierden el error en algunas llamadas. Aquí tienes la configuración de cada logger de Node.js, los niveles de log y las llamadas que conservan el stack, probadas en Node.js 22.

Probado el 20 de noviembre de 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 y @logbrew/express 0.1.14

Por [Furkan Erday](https://github.com/furkanerday). Furkan Erday es el fundador de LogBrew. Desarrolla LogBrew con Claude Code y Codex todos los días.

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

## Qué llamada conserva el error, en pantalla y en LogBrew

| Llamada de log | Impreso | En LogBrew |
| --- | --- | --- |
| Pino `error(err, msg)` | Mensaje y stack | Nombre y mensaje |
| Pino `error(msg, err)` | Perdido | Perdido |
| Winston `error(err)` | `{"level":"error"}` | Nombre y mensaje |
| Winston `error(err, msg)` | `"message":{}` | Perdido |
| Winston `error(msg, { err })` | `"err":{}` | Nombre y mensaje |
| Winston `error(msg, err)` | Mensaje y stack | Nombre y mensaje |

6 llamadas con `new Error("keg empty")` en Pino 10.4 y en Winston 3.19 sin formato.

## Configura un logger con Pino

### Crea 1 logger y deja que imprima JSON

`pino()` registra desde `info` hacia arriba e imprime 1 línea JSON por llamada, con un `level` numérico, `time`, `pid` y `hostname`. La llamada `debug` no imprimió nada. Cambiamos el nombre del host en la salida.

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

Salida

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

### Lee el nivel desde el entorno

Ejecútalo con `LOG_LEVEL=debug` y aparece la línea `debug`, sin cambiar el código. Un `LOG_LEVEL` vacío detiene el proceso. `??` conserva el texto vacío y Pino lanza `default level: must be included in custom levels`. Usa `||` si la variable puede estar vacía.

```bash
import pino from "pino";

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

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

Salida

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

### Pasa primero el error y después el mensaje

Pino convierte un `Error` del primer argumento, o de un campo `err`, en `err` con su `type`, `message` y `stack`. Un error después del mensaje se pierde sin aviso. La tercera línea no tiene `err`. Cortamos cada stack después de su primera línea.

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

Salida

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

### Crea el logger con un transport Console

Sin opciones, `winston.createLogger()` registra desde `info` hacia arriba e imprime JSON. La llamada `debug` no imprimió nada, y las líneas no tienen hora hasta que añades `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");
```

Salida

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

### Añade format.errors() antes de format.json()

Sin formato, `logger.error(err)` imprime `{"level":"error"}`. El formato JSON omite el mensaje y el stack de un `Error`. Pon `winston.format.errors({ stack: true })` al principio y la misma llamada imprime ambos.

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

Salida

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

### Pasa primero el mensaje y después el error

`logger.error(err, "pour failed")` pierde tu mensaje. `logger.error("pour failed", { err })` imprime `"err":{}`. `logger.error("pour failed", err)` conserva ambos y añade el mensaje del error al tuyo, 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);
```

Salida

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

## Envía los logs de Pino y Winston a LogBrew

### Instala los paquetes y define la clave

`@logbrew/node` captura los logs de Pino, `@logbrew/sdk` incluye el transport de Winston y `@logbrew/express` añade las trazas de cada solicitud. `createLogBrewNodeClient()` lee la clave de `LOGBREW_SERVER_API_KEY`.

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

### Llama a installLogBrewPinoInstrumentation() una vez

Llámala antes del primer log. Pino sigue imprimiendo sus líneas, y LogBrew recibe cada registro con `pinoLevel`, `pinoLevelNumber` y tus campos. LogBrew solo guarda campos planos, así que el objeto `card` quedó fuera. `RecordingTransport` guarda lo que envió el SDK para poder imprimirlo. En tu app, quita `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 }));
}
```

Salida

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

### Añade createLogBrewWinstonTransport() a Winston

Añade el transport junto a Console. Cada registro llega con `winstonLevel`, tu `defaultMeta` y tus campos, y con el `errorName` y el `errorMessage` de un error.

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

Salida

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

### Vincula cada log a su solicitud de Express

`logbrewMiddleware()` abre 1 span por solicitud, y `logbrewErrorHandler()` convierte un error lanzado en una incidencia con sus frames de stack. Un log de Pino dentro de la solicitud recibe el mismo ID de traza. La última columna es el inicio de ese 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));
    }
  }
});
```

Salida

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

## Lo que vimos al probarlo

Ejecutamos cada script de esta página con Node.js 22.18.0, Pino 10.4.0, Winston 3.19.0 y Express 5.3.0. Las salidas muestran cada carga que armó el SDK de LogBrew. En una segunda prueba enviamos los mismos logs a un servidor de LogBrew y los volvimos a leer.

El SDK de LogBrew lee el error del registro del log, no de la línea impresa. Por eso una llamada puede no imprimir ningún error y aun así enviarlo. Si el logger descarta el error antes de crear el registro, o convierte el error en el mensaje, ningún transport puede recuperarlo.

|  | Pino | Winston |
| --- | --- | --- |
| `level: ""` | Se detiene al arrancar con un error | Registra todos los niveles, también `debug` |
| Un `logger.level` nuevo se aplica al momento | Sí | Sí |

## ¿Pino o Winston? Cuál usar

Quédate con el logger que ya usa tu app. LogBrew recibe logs de los dos.

Winston no trae redacción integrada, así que escribes tu propio formato para eso.

|  | Pino | Winston |
| --- | --- | --- |
| Orden de los argumentos | `error(err, msg)` | `error(msg, err)` |
| Hora en cada línea | Sí | Con `format.timestamp()` |
| Stack de `error(err)` | Sí | Con `format.errors()` |
| Redacción integrada | `redact` | No |

## Niveles de log de Node.js en Pino y Winston

Pino numera sus niveles de `trace` 10 a `fatal` 60, y un número mayor es más grave. Winston numera sus niveles de `error` 0 a `silly` 6, y un número menor es más grave.

Los dos registran desde `info` hacia arriba por defecto. Asigna `logger.level = "debug"` para cambiarlo mientras el proceso corre.

El nivel original se queda en `pinoLevel` o `winstonLevel`.

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

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

Salida

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

## Qué registra LogBrew

Cada registro de Pino o Winston se convierte en 1 log con su nivel, su mensaje, su nivel original y tus campos. Los campos de un logger hijo o de `defaultMeta` también llegan, como `context.service` arriba.

Un error en el registro añade `errorName` y `errorMessage`. Define `includeErrorStack: true` en cualquiera de las dos integraciones para enviar también el stack como `errorStack`.

La integración de Pino descarta campos como `token`, `password` y `cookie` antes de enviar un log. El transport de Winston los envía tal cual, así que quítalos antes con un format de Winston.

Con el middleware de Express, cada log lleva el ID de traza de su solicitud. La incidencia, el span y los logs de 1 solicitud fallida comparten ese 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()`
  - Incidencia: `GET /kegs/:keg failed`
  - `exception.type`: `Error`
  - `mechanism`: `express.middleware`
  - `handled`: `false`
  - Frames de pila: 10

## Preguntas frecuentes

### ¿Cuál es el nivel de log por defecto en Pino?

`info`. `pino()` imprime `info`, `warn`, `error` y `fatal`, y descarta `debug` y `trace`. Pasa `level` a `pino()` o asigna `logger.level` para cambiarlo.

### ¿Por qué Winston registra un mensaje vacío para un error?

El formato JSON omite `message` y `stack` de un `Error`, porque no son enumerables. Añade `winston.format.errors({ stack: true })` antes de `winston.format.json()`.

### ¿Cómo registro un error con Pino?

Pásalo primero, como `logger.error(err, "pour failed")`, o dentro de un campo, como `logger.error({ err }, "pour failed")`. Pino descarta un error que va después del mensaje.

### ¿Uso Pino o Winston?

Quédate con el que usa tu app. Pino imprime JSON sin configuración y trae redacción integrada. Winston construye la línea con los formatos que eliges. LogBrew recibe logs de los dos.

### ¿Por qué Pino lanza default level must be included in custom levels?

El nivel que pasaste no es un nivel de Pino. Muchas veces es un `LOG_LEVEL` vacío. Escribe `process.env.LOG_LEVEL || "info"` para que un valor vacío vuelva a `info`.

## Ve cada error de Node.js con su solicitud

El SDK de Node de LogBrew envía cada log de Pino o Winston con su nivel y sus campos, y lo vincula con la traza de la solicitud y con la incidencia. Empieza con el generoso plan gratuito, sin tarjeta.

[Empezar gratis](https://logbrew.co/es)

## Fuentes

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

## Más guías para agentes, Python, Node.js y React

- [Añade un servidor MCP a Claude Code y Codex](https://logbrew.co/es/guides/mcp-server-claude-code-codex)
- [Usa AGENTS.md en Claude Code y Codex](https://logbrew.co/es/guides/agents-md)
- [Soluciona el error 529 overloaded y el error 429 de rate limit en Claude](https://logbrew.co/es/guides/claude-overloaded-rate-limit-error)
- [Configura el módulo Python logging con los niveles de log correctos y captura de excepciones](https://logbrew.co/es/guides/python-logging)
- [Structured logging con un formato de log y niveles que puedes buscar por campo](https://logbrew.co/es/guides/structured-logging)
- [Configura el logging de Django y conserva la traza de pila de cada error 500](https://logbrew.co/es/guides/django-logging)
- [Configura el logging de FastAPI y maneja los errores sin perder la traza de pila](https://logbrew.co/es/guides/fastapi-logging)
- [Añade un error boundary de React y registra los errores que se le escapan](https://logbrew.co/es/guides/react-error-boundary)
- [Trace ID vs span ID, decodificados de una cabecera traceparent real](https://logbrew.co/es/guides/trace-id)
- [Guías de errores, logs, trazas, métricas y versiones](https://logbrew.co/es/guides)
