---
title: "用 Pino 或 Winston 配置 Node.js 日志一个错误都不丢"
description: "Pino 和 Winston 在某些调用写法下都会丢掉错误。这里有两个 Node.js 日志库的配置、日志级别，以及能保留堆栈的错误写法，全部来自 Node.js 22 上的实测。"
canonical: "https://logbrew.co/zh-Hans/guides/node-logging"
last_updated: "2026-11-20"
---

# 用 Pino 或 Winston 配置 Node.js 日志一个错误都不丢

Pino 和 Winston 在某些调用写法下都会丢掉错误。这里有两个 Node.js 日志库的配置、日志级别，以及能保留堆栈的错误写法，全部来自 Node.js 22 上的实测。

2026年11月20日 用 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和@logbrew/express 0.1.14 实测

作者 [Furkan Erday](https://github.com/furkanerday). Furkan Erday 是 LogBrew 的创始人，每天用 Claude Code 和 Codex 开发 LogBrew。

Canonical: https://logbrew.co/zh-Hans/guides/node-logging

## 哪种调用能在终端输出和 LogBrew 中保留错误

| 日志调用 | 输出 | LogBrew |
| --- | --- | --- |
| Pino `error(err, msg)` | 消息和堆栈 | 名称和消息 |
| Pino `error(msg, err)` | 丢失 | 丢失 |
| Winston `error(err)` | `{"level":"error"}` | 名称和消息 |
| Winston `error(err, msg)` | `"message":{}` | 丢失 |
| Winston `error(msg, { err })` | `"err":{}` | 名称和消息 |
| Winston `error(msg, err)` | 消息和堆栈 | 名称和消息 |

在 Pino 10.4 和未配置 format 的 Winston 3.19 中，用 6 种写法传入 `new Error("keg empty")`。

## 配置 Pino 日志记录器

### 创建 1 个记录器，让它输出 JSON

`pino()` 记录 `info` 及以上级别，每次调用输出 1 行 JSON，带数字形式的 `level`、`time`、`pid` 和 `hostname`。`debug` 调用没有任何输出。我们替换了输出中的主机名。

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

输出

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

### 从环境变量读取级别

用 `LOG_LEVEL=debug` 运行，不改代码就能看到 `debug` 那一行。`LOG_LEVEL` 为空时进程会退出。`??` 保留了空字符串，Pino 随即抛出 `default level: must be included in custom levels`。变量可能为空时，改用 `||`。

```bash
import pino from "pino";

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

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

输出

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

### 先传错误，再传消息

Pino 会把第一个参数或 `err` 字段里的 `Error` 转成带 `type`、`message` 和 `stack` 的 `err`。放在消息后面的错误会被悄悄丢掉。第三行没有 `err`。每段堆栈我们只保留了第一行。

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

输出

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

## 配置 Winston 日志记录器

### 用 Console transport 创建记录器

不传选项时，`winston.createLogger()` 记录 `info` 及以上级别并输出 JSON。`debug` 调用没有输出，而且在你加上 `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");
```

输出

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

### 在 format.json() 之前加上 format.errors()

没有 format 时，`logger.error(err)` 只输出 `{"level":"error"}`。JSON format 会跳过 `Error` 的消息和堆栈。把 `winston.format.errors({ stack: true })` 放在最前面，同一个调用就会把两者都输出。

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

输出

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

### 先传消息，再传错误

`logger.error(err, "pour failed")` 会丢掉你的消息。`logger.error("pour failed", { err })` 输出 `"err":{}`。`logger.error("pour failed", err)` 两者都保留，并把错误消息接在你的消息后面，变成 `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);
```

输出

```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 和 Winston 日志发送到 LogBrew

### 安装包并设置密钥

`@logbrew/node` 捕获 Pino 日志，`@logbrew/sdk` 提供 Winston transport，`@logbrew/express` 为每个请求加上链路。`createLogBrewNodeClient()` 从 `LOGBREW_SERVER_API_KEY` 读取密钥。

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

### 调用一次 installLogBrewPinoInstrumentation()

在第一条日志之前调用。Pino 照常输出自己的行，LogBrew 收到每条记录，带有 `pinoLevel`、`pinoLevelNumber` 和你的字段。LogBrew 只保留扁平字段，所以 `card` 对象没有发送。`RecordingTransport` 保存 SDK 发出的内容，方便我们打印出来。在你的应用里去掉 `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 }));
}
```

输出

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

### 给 Winston 加上 createLogBrewWinstonTransport()

把这个 transport 加在 Console 旁边。每条记录都带有 `winstonLevel`、`defaultMeta` 和你的字段，有错误时还带有 `errorName` 和 `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 }));
}
```

输出

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

### 把每条日志关联到它的 Express 请求

`logbrewMiddleware()` 为每个请求开启 1 个 Span，`logbrewErrorHandler()` 把抛出的错误变成带堆栈帧的问题。请求内的 Pino 日志会拿到同一个链路 ID。最后一列是这个 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));
    }
  }
});
```

输出

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

## 我们实测看到的结果

本页每个脚本都在 Node.js 22.18.0、Pino 10.4.0、Winston 3.19.0 和 Express 5.3.0 上运行过。输出里是 LogBrew SDK 生成的每份数据。第二次运行时，我们把同样的日志发到 LogBrew 服务器，再读了回来。

LogBrew SDK 从日志记录里读取错误，而不是从打印出的那一行。所以一次调用可以什么错误都不打印，却照样把错误发出去。如果日志库在生成记录之前就丢掉了错误，或者把错误当成了消息，任何 transport 都拿不回来。

|  | Pino | Winston |
| --- | --- | --- |
| `level: ""` | 启动时报错退出 | 记录所有级别，包括 `debug` |
| 新的 `logger.level` 立即生效 | 是 | 是 |

## Pino 还是 Winston，该用哪个

继续用你的应用已经在用的那个。LogBrew 两者的记录都能接收。

Winston 没有内置脱敏，需要你自己写一个 format。

|  | Pino | Winston |
| --- | --- | --- |
| 参数顺序 | `error(err, msg)` | `error(msg, err)` |
| 每行带时间 | 是 | 加上 `format.timestamp()` 后才有 |
| `error(err)` 的堆栈 | 是 | 加上 `format.errors()` 后才有 |
| 内置脱敏 | `redact` | 否 |

## Pino 和 Winston 中的 Node.js 日志级别

Pino 的级别编号从 `trace` 10 到 `fatal` 60，数字越大越严重。Winston 的级别编号从 `error` 0 到 `silly` 6，数字越小越严重。

两者默认都记录 `info` 及以上级别。设置 `logger.level = "debug"` 可以在进程运行时修改级别。

原始级别保留在 `pinoLevel` 或 `winstonLevel` 中。

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

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

输出

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

## LogBrew 记录了什么

每条 Pino 或 Winston 记录都变成 1 条日志，带有级别、消息、原始级别和你的字段。子记录器或 `defaultMeta` 里的字段也会一起发送，比如上面的 `context.service`。

记录中有错误时，会加上 `errorName` 和 `errorMessage`。在任一集成上设置 `includeErrorStack: true`，堆栈也会作为 `errorStack` 发送。

Pino 集成会在发送日志前去掉 `token`、`password`、`cookie` 等字段。Winston transport 会原样发送这些字段，所以先在 Winston 的 format 里去掉它们。

使用 Express 中间件后，每条日志都带有所属请求的链路 ID。1 个失败请求的问题、Span 和日志共用这个 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()`
  - 问题: `GET /kegs/:keg failed`
  - `exception.type`: `Error`
  - `mechanism`: `express.middleware`
  - `handled`: `false`
  - 堆栈帧: 10

## 常见问题

### Pino 默认的日志级别是什么？

`info`。`pino()` 输出 `info`、`warn`、`error` 和 `fatal`，丢弃 `debug` 和 `trace`。给 `pino()` 传入 `level`，或设置 `logger.level`，即可修改。

### 为什么 Winston 记录错误时消息是空的？

`Error` 的 `message` 和 `stack` 是不可枚举的属性，JSON format 会跳过它们。在 `winston.format.json()` 之前加上 `winston.format.errors({ stack: true })`。

### 怎样用 Pino 记录错误？

先传错误，例如 `logger.error(err, "pour failed")`，或者放进字段，例如 `logger.error({ err }, "pour failed")`。放在消息后面的错误会被 Pino 丢掉。

### 该用 Pino 还是 Winston？

继续用你的应用在用的那个。Pino 无需配置就输出 JSON，并内置脱敏。Winston 用你选的 format 组装每一行。LogBrew 两者的日志都能接收。

### 为什么 Pino 抛出 default level must be included in custom levels？

你传入的级别不是 Pino 的级别，常见原因是 `LOG_LEVEL` 为空。写成 `process.env.LOG_LEVEL || "info"`，空值就会回退到 `info`。

## 查看每个 Node.js 错误及其请求

LogBrew Node SDK 把每条 Pino 或 Winston 日志连同级别和字段一起发送，并关联到请求链路和对应的问题。免费额度充足，无需绑卡。

[免费开始](https://logbrew.co/zh-Hans)

## 参考来源

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

## 更多智能体、Python、Node.js 与 React 指南

- [在 Claude Code 和 Codex 中添加 MCP 服务器](https://logbrew.co/zh-Hans/guides/mcp-server-claude-code-codex)
- [在 Claude Code 和 Codex 中使用 AGENTS.md](https://logbrew.co/zh-Hans/guides/agents-md)
- [解决 Claude overloaded 529 错误和 rate limit 429 错误](https://logbrew.co/zh-Hans/guides/claude-overloaded-rate-limit-error)
- [配置 Python 日志用对日志级别并捕获异常和回溯](https://logbrew.co/zh-Hans/guides/python-logging)
- [结构化日志用能按字段搜索的日志格式和日志级别](https://logbrew.co/zh-Hans/guides/structured-logging)
- [配置 Django 日志保留每个 500 错误的回溯信息](https://logbrew.co/zh-Hans/guides/django-logging)
- [配置 FastAPI 日志处理错误不丢失回溯](https://logbrew.co/zh-Hans/guides/fastapi-logging)
- [给 React 加上错误边界并记录它漏掉的错误](https://logbrew.co/zh-Hans/guides/react-error-boundary)
- [Trace ID 和 Span ID 的区别，用真实的 traceparent 请求头解读](https://logbrew.co/zh-Hans/guides/trace-id)
- [错误、日志、链路、指标和版本指南](https://logbrew.co/zh-Hans/guides)
