---
title: "Siapkan logging Node.js dengan Pino atau Winston tanpa kehilangan satu error pun"
description: "Pino dan Winston sama-sama kehilangan error di beberapa panggilan. Ini setup tiap logger Node.js, level log, dan panggilan error yang menyimpan stack, dari uji coba di Node.js 22."
canonical: "https://logbrew.co/id/guides/node-logging"
last_updated: "2026-11-20"
---

# Siapkan logging Node.js dengan Pino atau Winston tanpa kehilangan satu error pun

Pino dan Winston sama-sama kehilangan error di beberapa panggilan. Ini setup tiap logger Node.js, level log, dan panggilan error yang menyimpan stack, dari uji coba di Node.js 22.

Diuji pada 20 November 2026 dengan 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, dan @logbrew/express 0.1.14

Oleh [Furkan Erday](https://github.com/furkanerday). Furkan Erday adalah pendiri LogBrew. Setiap hari ia membangun LogBrew dengan Claude Code dan Codex.

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

## Panggilan mana yang menyimpan error, di layar dan di LogBrew

| Panggilan log | Tercetak | Di LogBrew |
| --- | --- | --- |
| Pino `error(err, msg)` | Pesan dan stack | Nama dan pesan |
| Pino `error(msg, err)` | Hilang | Hilang |
| Winston `error(err)` | `{"level":"error"}` | Nama dan pesan |
| Winston `error(err, msg)` | `"message":{}` | Hilang |
| Winston `error(msg, { err })` | `"err":{}` | Nama dan pesan |
| Winston `error(msg, err)` | Pesan dan stack | Nama dan pesan |

6 panggilan dengan `new Error("keg empty")` di Pino 10.4 dan di Winston 3.19 tanpa format.

## Siapkan logger Pino

### Buat 1 logger dan biarkan ia mencetak JSON

`pino()` mencatat mulai dari `info` ke atas dan mencetak 1 baris JSON per panggilan, dengan `level` berupa angka, `time`, `pid`, dan `hostname`. Panggilan `debug` tidak mencetak apa pun. Kami mengganti nama host di output.

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

### Baca level dari variabel lingkungan

Jalankan dengan `LOG_LEVEL=debug`, dan baris `debug` muncul tanpa mengubah kode. `LOG_LEVEL` yang kosong menghentikan proses. `??` mempertahankan teks kosong, lalu Pino melempar `default level: must be included in custom levels`. Pakai `||` jika variabelnya bisa kosong.

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

### Berikan error dulu, baru pesannya

Pino mengubah `Error` di argumen pertama, atau di field `err`, menjadi `err` dengan `type`, `message`, dan `stack`. Error yang diberikan setelah pesan hilang tanpa peringatan. Baris ketiga tidak punya `err`. Kami memotong tiap stack setelah baris pertamanya.

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

## Siapkan logger Winston

### Buat logger dengan transport Console

Tanpa opsi, `winston.createLogger()` mencatat mulai dari `info` ke atas dan mencetak JSON. Panggilan `debug` tidak mencetak apa pun, dan baris tidak punya waktu sampai kamu menambahkan `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"}
```

### Tambahkan format.errors() sebelum format.json()

Tanpa format, `logger.error(err)` hanya mencetak `{"level":"error"}`. Format JSON melewatkan pesan dan stack sebuah `Error`. Taruh `winston.format.errors({ stack: true })` di depan, dan panggilan yang sama mencetak keduanya.

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

### Berikan pesan dulu, baru error-nya

`logger.error(err, "pour failed")` kehilangan pesanmu. `logger.error("pour failed", { err })` mencetak `"err":{}`. `logger.error("pour failed", err)` menyimpan keduanya dan menambahkan pesan error ke pesanmu, menjadi `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 …"}
```

## Kirim log Pino dan Winston ke LogBrew

### Pasang paket dan atur key

`@logbrew/node` menangkap log Pino, `@logbrew/sdk` berisi transport Winston, dan `@logbrew/express` menambahkan trace tiap permintaan. `createLogBrewNodeClient()` membaca key dari `LOGBREW_SERVER_API_KEY`.

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

### Panggil installLogBrewPinoInstrumentation() sekali

Panggil sebelum log pertama. Pino tetap mencetak barisnya sendiri, dan LogBrew menerima tiap record dengan `pinoLevel`, `pinoLevelNumber`, dan field milikmu. LogBrew hanya menyimpan field datar, jadi objek `card` tidak ikut. `RecordingTransport` menyimpan apa yang dikirim SDK agar bisa kami cetak. Di aplikasimu, hapus `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"}
```

### Tambahkan createLogBrewWinstonTransport() ke Winston

Tambahkan transport di samping Console. Tiap record tiba dengan `winstonLevel`, `defaultMeta` dan field milikmu, serta `errorName` dan `errorMessage` dari sebuah 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 }));
}
```

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

### Hubungkan tiap log ke permintaan Express-nya

`logbrewMiddleware()` membuka 1 span per permintaan, dan `logbrewErrorHandler()` mengubah error yang dilempar menjadi masalah dengan frame stack-nya. Log Pino di dalam permintaan mendapat trace ID yang sama. Kolom terakhir adalah awal ID itu.

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

## Hasil pengujian kami

Kami menjalankan setiap skrip di halaman ini dengan Node.js 22.18.0, Pino 10.4.0, Winston 3.19.0, dan Express 5.3.0. Output-nya menunjukkan setiap payload yang dibuat SDK LogBrew. Di uji coba kedua, kami mengirim log yang sama ke server LogBrew lalu membacanya kembali.

SDK LogBrew membaca error dari record log, bukan dari baris yang tercetak. Jadi sebuah panggilan bisa tidak mencetak error apa pun tetapi tetap mengirimnya. Jika logger membuang error sebelum membuat record, atau menjadikan error sebagai pesannya, tidak ada transport yang bisa mengembalikannya.

|  | Pino | Winston |
| --- | --- | --- |
| `level: ""` | Berhenti saat mulai dengan error | Mencatat semua level, termasuk `debug` |
| `logger.level` baru langsung berlaku | Ya | Ya |

## Pino atau Winston, mana yang dipakai

Tetap pakai logger yang sudah dipakai aplikasimu. LogBrew menerima record dari keduanya.

Winston tidak punya penyamaran bawaan, jadi kamu menulis format sendiri untuk itu.

|  | Pino | Winston |
| --- | --- | --- |
| Urutan argumen | `error(err, msg)` | `error(msg, err)` |
| Waktu di tiap baris | Ya | Dengan `format.timestamp()` |
| Stack dari `error(err)` | Ya | Dengan `format.errors()` |
| Penyamaran bawaan | `redact` | Tidak |

## Level log Node.js di Pino dan Winston

Pino memberi nomor level dari `trace` 10 sampai `fatal` 60, dan angka yang lebih besar lebih parah. Winston memberi nomor level dari `error` 0 sampai `silly` 6, dan angka yang lebih kecil lebih parah.

Keduanya mencatat mulai dari `info` ke atas secara bawaan. Atur `logger.level = "debug"` untuk mengubahnya saat proses berjalan.

Level aslinya tetap ada di `pinoLevel` atau `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` | Tidak |

## Apa yang dicatat LogBrew

Tiap record Pino atau Winston menjadi 1 log dengan level, pesan, level asli, dan field milikmu. Field dari child logger atau dari `defaultMeta` ikut terkirim, seperti `context.service` di atas.

Error di dalam record menambahkan `errorName` dan `errorMessage`. Atur `includeErrorStack: true` di salah satu integrasi untuk mengirim stack juga sebagai `errorStack`.

Integrasi Pino membuang field seperti `token`, `password`, dan `cookie` sebelum mengirim log. Transport Winston mengirimnya apa adanya, jadi buang dulu lewat format Winston.

Dengan middleware Express, tiap log membawa trace ID permintaannya. Masalah, span, dan log dari 1 permintaan yang gagal memakai ID yang sama.

- `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()`
  - Masalah: `GET /kegs/:keg failed`
  - `exception.type`: `Error`
  - `mechanism`: `express.middleware`
  - `handled`: `false`
  - Frame stack: 10

## Pertanyaan yang sering diajukan

### Apa level log bawaan di Pino?

`info`. `pino()` mencetak `info`, `warn`, `error`, dan `fatal`, serta membuang `debug` dan `trace`. Berikan `level` ke `pino()` atau atur `logger.level` untuk mengubahnya.

### Kenapa Winston mencatat pesan kosong untuk sebuah error?

Format JSON melewatkan `message` dan `stack` dari sebuah `Error`, karena keduanya tidak enumerable. Tambahkan `winston.format.errors({ stack: true })` sebelum `winston.format.json()`.

### Bagaimana cara mencatat error dengan Pino?

Berikan error lebih dulu, seperti `logger.error(err, "pour failed")`, atau di dalam field, seperti `logger.error({ err }, "pour failed")`. Pino membuang error yang datang setelah pesan.

### Sebaiknya pakai Pino atau Winston?

Tetap pakai yang dipakai aplikasimu. Pino mencetak JSON tanpa setup dan punya penyamaran bawaan. Winston menyusun baris dari format yang kamu pilih. LogBrew menerima log dari keduanya.

### Kenapa Pino melempar default level must be included in custom levels?

Level yang kamu berikan bukan level Pino, sering kali `LOG_LEVEL` yang kosong. Tulis `process.env.LOG_LEVEL || "info"`, agar nilai kosong kembali ke `info`.

## Lihat tiap error Node.js beserta permintaannya

SDK Node LogBrew mengirim tiap log Pino atau Winston dengan level dan field-nya, lalu menghubungkannya ke trace permintaan dan ke masalahnya. Mulai dengan paket gratis yang lega, tanpa perlu kartu.

[Mulai gratis](https://logbrew.co/id)

## Sumber

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

## Panduan lain untuk agen, Python, Node.js, dan React

- [Tambahkan server MCP ke Claude Code dan Codex](https://logbrew.co/id/guides/mcp-server-claude-code-codex)
- [Pakai AGENTS.md di Claude Code dan Codex](https://logbrew.co/id/guides/agents-md)
- [Atasi error Claude overloaded 529 dan rate limit 429](https://logbrew.co/id/guides/claude-overloaded-rate-limit-error)
- [Siapkan Python logging dengan level log yang tepat dan penangkapan exception](https://logbrew.co/id/guides/python-logging)
- [Logging terstruktur dengan format log dan level log yang bisa dicari per field](https://logbrew.co/id/guides/structured-logging)
- [Setup logging Django dan simpan traceback tiap error 500](https://logbrew.co/id/guides/django-logging)
- [Setup logging FastAPI dan tangani error tanpa kehilangan traceback](https://logbrew.co/id/guides/fastapi-logging)
- [Tambahkan error boundary React dan catat error yang lolos darinya](https://logbrew.co/id/guides/react-error-boundary)
- [Trace ID vs span ID, diurai dari header traceparent sungguhan](https://logbrew.co/id/guides/trace-id)
- [Panduan error, log, trace, metrik, dan rilis](https://logbrew.co/id/guides)
