---
title: "Thiết lập log cho Node.js với Pino hoặc Winston mà không mất lỗi nào"
description: "Pino và Winston đều làm mất lỗi ở một số lời gọi. Đây là cách thiết lập từng logger Node.js, các cấp độ log và lời gọi giữ được stack, đã thử trên Node.js 22."
canonical: "https://logbrew.co/vi/guides/node-logging"
last_updated: "2026-11-20"
---

# Thiết lập log cho Node.js với Pino hoặc Winston mà không mất lỗi nào

Pino và Winston đều làm mất lỗi ở một số lời gọi. Đây là cách thiết lập từng logger Node.js, các cấp độ log và lời gọi giữ được stack, đã thử trên Node.js 22.

Đã thử nghiệm ngày 20 tháng 11, 2026 với 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 và @logbrew/express 0.1.14

Tác giả [Furkan Erday](https://github.com/furkanerday). Furkan Erday là nhà sáng lập LogBrew. Anh xây dựng LogBrew bằng Claude Code và Codex mỗi ngày.

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

## Lời gọi nào giữ được lỗi, trên màn hình và trong LogBrew

| Lời gọi log | Đã in | Trong LogBrew |
| --- | --- | --- |
| Pino `error(err, msg)` | Thông điệp và stack | Tên và thông điệp |
| Pino `error(msg, err)` | Mất | Mất |
| Winston `error(err)` | `{"level":"error"}` | Tên và thông điệp |
| Winston `error(err, msg)` | `"message":{}` | Mất |
| Winston `error(msg, { err })` | `"err":{}` | Tên và thông điệp |
| Winston `error(msg, err)` | Thông điệp và stack | Tên và thông điệp |

6 lời gọi với `new Error("keg empty")` trong Pino 10.4 và Winston 3.19 không có format.

## Thiết lập logger Pino

### Tạo 1 logger và để nó in JSON

`pino()` ghi từ `info` trở lên và in 1 dòng JSON cho mỗi lời gọi, với `level` dạng số, `time`, `pid` và `hostname`. Lời gọi `debug` không in gì. Chúng tôi đã thay tên máy trong kết quả.

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

Kết quả

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

### Đọc cấp độ từ biến môi trường

Chạy với `LOG_LEVEL=debug` và dòng `debug` xuất hiện mà không cần sửa mã. `LOG_LEVEL` rỗng làm dừng tiến trình. `??` giữ nguyên chuỗi rỗng và Pino ném `default level: must be included in custom levels`. Dùng `||` nếu biến có thể rỗng.

```bash
import pino from "pino";

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

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

Kết quả

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

### Truyền lỗi trước, thông điệp sau

Pino biến một `Error` ở đối số đầu tiên, hoặc trong trường `err`, thành `err` với `type`, `message` và `stack`. Lỗi truyền sau thông điệp bị mất mà không có cảnh báo. Dòng thứ ba không có `err`. Chúng tôi cắt mỗi stack sau dòng đầu tiên.

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

Kết quả

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

## Thiết lập logger Winston

### Tạo logger với transport Console

Không có tùy chọn, `winston.createLogger()` ghi từ `info` trở lên và in JSON. Lời gọi `debug` không in gì, và các dòng không có thời gian cho đến khi bạn thêm `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");
```

Kết quả

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

### Thêm format.errors() trước format.json()

Khi chưa có format, `logger.error(err)` chỉ in `{"level":"error"}`. Format JSON bỏ qua thông điệp và stack của một `Error`. Đặt `winston.format.errors({ stack: true })` lên đầu, và cùng lời gọi đó in ra cả hai.

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

Kết quả

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

### Truyền thông điệp trước, lỗi sau

`logger.error(err, "pour failed")` làm mất thông điệp của bạn. `logger.error("pour failed", { err })` in `"err":{}`. `logger.error("pour failed", err)` giữ cả hai và nối thông điệp lỗi vào thông điệp của bạn, thành `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);
```

Kết quả

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

## Gửi log Pino và Winston đến LogBrew

### Cài các gói và đặt khóa

`@logbrew/node` bắt log của Pino, `@logbrew/sdk` chứa transport cho Winston, và `@logbrew/express` thêm trace cho từng request. `createLogBrewNodeClient()` đọc khóa từ `LOGBREW_SERVER_API_KEY`.

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

### Gọi installLogBrewPinoInstrumentation() một lần

Gọi trước dòng log đầu tiên. Pino vẫn in các dòng của nó, và LogBrew nhận từng bản ghi với `pinoLevel`, `pinoLevelNumber` và các trường của bạn. LogBrew chỉ giữ các trường phẳng, nên đối tượng `card` không được gửi. `RecordingTransport` giữ lại những gì SDK đã gửi để chúng tôi in ra. Trong ứng dụng của bạn, bỏ `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 }));
}
```

Kết quả

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

### Thêm createLogBrewWinstonTransport() vào Winston

Thêm transport bên cạnh Console. Mỗi bản ghi đến với `winstonLevel`, `defaultMeta` và các trường của bạn, kèm `errorName` và `errorMessage` của lỗi.

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

Kết quả

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

### Gắn mỗi log với request Express của nó

`logbrewMiddleware()` mở 1 span cho mỗi request, và `logbrewErrorHandler()` biến lỗi bị ném thành một vấn đề kèm các frame của stack. Log Pino bên trong request nhận cùng trace ID. Cột cuối là phần đầu của 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));
    }
  }
});
```

Kết quả

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

## Kết quả khi chúng tôi thử nghiệm

Chúng tôi chạy mọi script trên trang này với Node.js 22.18.0, Pino 10.4.0, Winston 3.19.0 và Express 5.3.0. Phần output cho thấy từng payload mà SDK LogBrew tạo ra. Ở lần chạy thứ hai, chúng tôi gửi chính các log đó tới một máy chủ LogBrew rồi đọc lại.

SDK LogBrew đọc lỗi từ bản ghi log, không phải từ dòng được in ra. Vì vậy một lời gọi có thể không in lỗi nào mà vẫn gửi được lỗi. Khi logger bỏ lỗi trước khi tạo bản ghi, hoặc lấy lỗi làm thông điệp, không transport nào lấy lại được.

|  | Pino | Winston |
| --- | --- | --- |
| `level: ""` | Dừng ngay khi khởi động kèm lỗi | Ghi mọi cấp độ, kể cả `debug` |
| `logger.level` mới có hiệu lực ngay | Có | Có |

## Pino hay Winston, nên dùng cái nào

Giữ logger mà ứng dụng của bạn đang dùng. LogBrew nhận bản ghi từ cả hai.

Winston không có sẵn tính năng che dữ liệu, nên bạn tự viết format cho việc đó.

|  | Pino | Winston |
| --- | --- | --- |
| Thứ tự đối số | `error(err, msg)` | `error(msg, err)` |
| Thời gian trên mỗi dòng | Có | Với `format.timestamp()` |
| Stack từ `error(err)` | Có | Với `format.errors()` |
| Che dữ liệu có sẵn | `redact` | Không |

## Cấp độ log Node.js trong Pino và Winston

Pino đánh số cấp độ từ `trace` 10 đến `fatal` 60, số càng lớn càng nghiêm trọng. Winston đánh số cấp độ từ `error` 0 đến `silly` 6, số càng nhỏ càng nghiêm trọng.

Cả hai mặc định ghi từ `info` trở lên. Đặt `logger.level = "debug"` để đổi cấp độ khi tiến trình đang chạy.

Cấp độ gốc vẫn nằm trong `pinoLevel` hoặc `winstonLevel`.

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

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

Kết quả

```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` | Không |

## LogBrew ghi lại những gì

Mỗi bản ghi Pino hoặc Winston trở thành 1 log với cấp độ, thông điệp, cấp độ gốc và các trường của bạn. Trường từ child logger hoặc từ `defaultMeta` cũng được gửi, như `context.service` ở trên.

Lỗi trong bản ghi thêm `errorName` và `errorMessage`. Đặt `includeErrorStack: true` trên một trong hai tích hợp để gửi cả stack dưới dạng `errorStack`.

Tích hợp Pino bỏ các trường như `token`, `password` và `cookie` trước khi gửi log. Transport Winston gửi chúng nguyên vẹn, nên hãy bỏ chúng trước bằng một format của Winston.

Với middleware Express, mỗi log mang trace ID của request. Vấn đề, span và log của 1 request thất bại dùng chung 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()`
  - Vấn đề: `GET /kegs/:keg failed`
  - `exception.type`: `Error`
  - `mechanism`: `express.middleware`
  - `handled`: `false`
  - Stack frame: 10

## Câu hỏi thường gặp

### Cấp độ log mặc định của Pino là gì?

`info`. `pino()` in `info`, `warn`, `error` và `fatal`, và bỏ `debug` và `trace`. Truyền `level` cho `pino()` hoặc đặt `logger.level` để thay đổi.

### Vì sao Winston ghi thông điệp rỗng cho một lỗi?

Format JSON bỏ qua `message` và `stack` của một `Error`, vì hai thuộc tính này không enumerable. Thêm `winston.format.errors({ stack: true })` trước `winston.format.json()`.

### Ghi lỗi bằng Pino như thế nào?

Truyền lỗi trước, như `logger.error(err, "pour failed")`, hoặc trong một trường, như `logger.error({ err }, "pour failed")`. Pino bỏ lỗi đến sau thông điệp.

### Nên dùng Pino hay Winston?

Giữ logger mà ứng dụng của bạn đang dùng. Pino in JSON không cần thiết lập và có sẵn tính năng che dữ liệu. Winston dựng dòng từ các format bạn chọn. LogBrew nhận log từ cả hai.

### Vì sao Pino ném default level must be included in custom levels?

Cấp độ bạn truyền vào không phải cấp độ của Pino, thường là `LOG_LEVEL` rỗng. Viết `process.env.LOG_LEVEL || "info"` để giá trị rỗng quay về `info`.

## Xem từng lỗi Node.js cùng request của nó

SDK Node của LogBrew gửi từng log Pino hoặc Winston kèm cấp độ và các trường, rồi gắn nó với trace của request và với vấn đề. Bắt đầu với gói miễn phí rộng rãi, không cần thẻ.

[Bắt đầu miễn phí](https://logbrew.co/vi)

## Nguồn

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

## Thêm hướng dẫn cho agent, Python, Node.js và React

- [Thêm máy chủ MCP vào Claude Code và Codex](https://logbrew.co/vi/guides/mcp-server-claude-code-codex)
- [Dùng AGENTS.md trong Claude Code và Codex](https://logbrew.co/vi/guides/agents-md)
- [Khắc phục lỗi Claude overloaded 529 và lỗi rate limit 429](https://logbrew.co/vi/guides/claude-overloaded-rate-limit-error)
- [Thiết lập Python logging với đúng mức log và bắt ngoại lệ kèm traceback](https://logbrew.co/vi/guides/python-logging)
- [Structured logging với định dạng log và mức log bạn tìm được theo trường](https://logbrew.co/vi/guides/structured-logging)
- [Thiết lập logging Django và giữ traceback của mọi lỗi 500](https://logbrew.co/vi/guides/django-logging)
- [Thiết lập logging FastAPI và xử lý lỗi mà không mất traceback](https://logbrew.co/vi/guides/fastapi-logging)
- [Thêm error boundary cho React và ghi log những lỗi mà nó bỏ lọt](https://logbrew.co/vi/guides/react-error-boundary)
- [Trace ID và span ID, giải mã từ một header traceparent thật](https://logbrew.co/vi/guides/trace-id)
- [Hướng dẫn về lỗi, log, trace, chỉ số và bản phát hành](https://logbrew.co/vi/guides)
