---
title: "Node.js loglamayı Pino ya da Winston ile kur ve hiçbir hatayı kaçırma"
description: "Pino da Winston da bazı çağrılarda hatayı düşürür. Her iki Node.js logger'ın kurulumu, log seviyeleri ve stack'i koruyan hata çağrıları, Node.js 22 üzerindeki çalıştırmalardan."
canonical: "https://logbrew.co/tr/guides/node-logging"
last_updated: "2026-11-20"
---

# Node.js loglamayı Pino ya da Winston ile kur ve hiçbir hatayı kaçırma

Pino da Winston da bazı çağrılarda hatayı düşürür. Her iki Node.js logger'ın kurulumu, log seviyeleri ve stack'i koruyan hata çağrıları, Node.js 22 üzerindeki çalıştırmalardan.

20 Kasım 2026 tarihinde 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 ve @logbrew/express 0.1.14 ile test edildi

[Furkan Erday](https://github.com/furkanerday) tarafından. Furkan Erday, LogBrew'un kurucusu. LogBrew'u her gün Claude Code ve Codex ile geliştiriyor.

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

## Hangi hata çağrısı hatayı ekranda ve LogBrew'da korur

| Log çağrısı | Yazdırılan | LogBrew'da |
| --- | --- | --- |
| Pino `error(err, msg)` | Mesaj ve stack | Ad ve mesaj |
| Pino `error(msg, err)` | Kayıp | Kayıp |
| Winston `error(err)` | `{"level":"error"}` | Ad ve mesaj |
| Winston `error(err, msg)` | `"message":{}` | Kayıp |
| Winston `error(msg, { err })` | `"err":{}` | Ad ve mesaj |
| Winston `error(msg, err)` | Mesaj ve stack | Ad ve mesaj |

Pino 10.4 ile ve formatsız Winston 3.19 ile `new Error("keg empty")` kullanan 6 çağrı.

## Pino logger'ı kur

### Tek bir logger oluştur, JSON yazdırsın

`pino()` varsayılan olarak `info` ve üstünü loglar ve her çağrıda tek bir JSON satırı yazdırır. Sayısal `level`, `time`, `pid` ve `hostname` ile. `debug` çağrısı hiçbir şey yazdırmadı. Çıktıdaki makine adını değiştirdik.

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

Çıktı

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

### Seviyeyi ortam değişkeninden oku

Bunu `LOG_LEVEL=debug` ile çalıştır, kodu değiştirmeden `debug` satırı görünür. Boş bir `LOG_LEVEL` süreci durdurur. `??` boş metni olduğu gibi bırakır ve Pino `default level: must be included in custom levels` hatasını fırlatır. Değişken boş olabiliyorsa `||` kullan.

```bash
import pino from "pino";

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

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

Çıktı

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

### Önce hatayı, sonra mesajı ver

Pino ilk argümandaki ya da bir `err` alanındaki `Error` nesnesini `type`, `message` ve `stack` bilgileriyle `err` alanına yazar. Mesajdan sonra gelen hata hiçbir uyarı olmadan kaybolur. Üçüncü satırda `err` yok. Her stack'i ilk satırından sonra kestik.

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

Çıktı

```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 logger'ı kur

### Logger'ı Console transport'u ile oluştur

Seçenek vermezsen `winston.createLogger()` `info` ve üstünü loglar ve JSON yazdırır. `debug` çağrısı hiçbir şey yazdırmadı. `winston.format.timestamp()` eklemeden satırlarda zaman bilgisi olmaz.

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

Çıktı

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

### format.json() öncesine format.errors() ekle

Format vermezsen `logger.error(err)` yalnızca `{"level":"error"}` yazdırır. JSON formatı bir `Error` nesnesinin mesajını ve stack'ini atlar. Başa `winston.format.errors({ stack: true })` koyarsan aynı çağrı ikisini de yazdırır.

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

Çıktı

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

### Önce mesajı, sonra hatayı ver

`logger.error(err, "pour failed")` senin mesajını kaybeder. `logger.error("pour failed", { err })` yalnızca `"err":{}` yazdırır. `logger.error("pour failed", err)` ikisini de korur ve hata mesajını seninkinin sonuna ekler. `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);
```

Çıktı

```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 ve Winston loglarını LogBrew'a gönder

### Paketleri kur ve anahtarı ayarla

`@logbrew/node` Pino loglarını yakalar, Winston transport'u `@logbrew/sdk` içindedir, `@logbrew/express` ise istek trace'lerini ekler. `createLogBrewNodeClient()` anahtarı `LOGBREW_SERVER_API_KEY` değişkeninden okur.

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

### installLogBrewPinoInstrumentation() fonksiyonunu bir kez çağır

İlk logdan önce çağır. Pino kendi satırlarını yine yazdırır, LogBrew ise her kaydı `pinoLevel`, `pinoLevelNumber` ve senin alanlarınla alır. LogBrew yalnızca düz alanları tutar, bu yüzden `card` nesnesi dışarıda kaldı. `RecordingTransport` SDK'nın gönderdiğini saklar, biz de onu yazdırdık. Kendi uygulamanda `transport` seçeneğini kaldır.

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

Çıktı

```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'a createLogBrewWinstonTransport() ekle

Transport'u Console'un yanına ekle. Her kayıt `winstonLevel`, `defaultMeta` ve diğer alanların, bir hata varsa da `errorName` ve `errorMessage` ile gelir.

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

Çıktı

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

### Her logu kendi Express isteğine bağla

`logbrewMiddleware()` her istek için bir span açar, `logbrewErrorHandler()` ise fırlatılan hatayı stack frame'leriyle bir soruna çevirir. İstek içindeki Pino logu aynı trace ID'yi alır. Son sütun bu ID'nin başıdır.

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

Çıktı

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

## Test ederken gördüklerimiz

Bu sayfadaki her betiği Node.js 22.18.0, Pino 10.4.0, Winston 3.19.0 ve Express 5.3.0 ile çalıştırdık. Çıktılar, LogBrew SDK'sının hazırladığı her yükü gösterir. İkinci bir çalıştırmada aynı logları bir LogBrew sunucusuna gönderip geri okuduk.

LogBrew SDK'sı hatayı yazdırılan satırdan değil, log kaydından okur. Bu yüzden bir çağrı hiçbir hata yazdırmadan hatayı yine de gönderebilir. Logger hatayı kaydı oluşturmadan önce atarsa ya da hatayı mesajı yaparsa, hiçbir transport onu geri getiremez.

|  | Pino | Winston |
| --- | --- | --- |
| `level: ""` | Başlarken hata verip durur | Her seviyeyi loglar, `debug` dahil |
| Yeni bir `logger.level` hemen geçerli olur | Evet | Evet |

## Pino mu, Winston mu?

Uygulamanın zaten kullandığı logger'da kal. LogBrew ikisinden de kayıt alır.

Winston'da hazır bir gizleme yoktur, bunun için kendi formatını yazarsın.

|  | Pino | Winston |
| --- | --- | --- |
| Argüman sırası | `error(err, msg)` | `error(msg, err)` |
| Her satırda zaman | Evet | `format.timestamp()` ile |
| `error(err)` ile stack | Evet | `format.errors()` ile |
| Hazır gizleme | `redact` | Hayır |

## Pino ve Winston'da Node.js log seviyeleri

Pino seviyelerini `trace` 10'dan `fatal` 60'a kadar numaralar, sayı büyüdükçe önem artar. Winston seviyelerini `error` 0'dan `silly` 6'ya kadar numaralar, sayı küçüldükçe önem artar.

İkisi de varsayılan olarak `info` ve üstünü loglar. Süreç çalışırken değiştirmek için `logger.level = "debug"` ata.

Asıl seviye `pinoLevel` ya da `winstonLevel` alanında kalır.

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

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

Çıktı

```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` | Hayır |

## LogBrew neleri kaydeder

Her Pino ya da Winston kaydı seviyesi, mesajı, asıl seviyesi ve alanlarınla tek bir log olur. Child logger'dan ya da `defaultMeta` içinden gelen alanlar da gelir, yukarıdaki `context.service` gibi.

Kayıtta hata varsa `errorName` ve `errorMessage` eklenir. Stack'i `errorStack` olarak da göndermek için iki entegrasyondan birinde `includeErrorStack: true` ayarla.

Pino entegrasyonu `token`, `password` ve `cookie` gibi alanları logu göndermeden önce atar. Winston transport'u bu alanları olduğu gibi gönderir, bu yüzden önce bir Winston format'ında çıkar.

Express middleware'i ile her log, isteğinin trace ID'sini taşır. Başarısız bir isteğin sorunu, span'i ve logları bu ID'yi paylaşır.

- `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()`
  - Sorun: `GET /kegs/:keg failed`
  - `exception.type`: `Error`
  - `mechanism`: `express.middleware`
  - `handled`: `false`
  - Stack frame'leri: 10

## Sık sorulan sorular

### Pino'da varsayılan log seviyesi nedir?

`info`. `pino()` `info`, `warn`, `error` ve `fatal` seviyelerini yazdırır, `debug` ve `trace` seviyelerini düşürür. Değiştirmek için `pino()` fonksiyonuna `level` ver ya da `logger.level` ata.

### Winston bir hata için neden boş mesaj logluyor?

JSON formatı bir `Error` nesnesinin `message` ve `stack` alanlarını atlar, çünkü bu alanlar sayılabilir (enumerable) değildir. `winston.format.json()` öncesine `winston.format.errors({ stack: true })` ekle.

### Pino ile hata nasıl loglanır?

Hatayı ilk argüman olarak ver. `logger.error(err, "pour failed")`. Ya da bir alanın içinde ver. `logger.error({ err }, "pour failed")`. Pino mesajdan sonra gelen hatayı düşürür.

### Pino mu kullanmalıyım, Winston mu?

Uygulamanın kullandığında kal. Pino kurulum gerektirmeden JSON yazdırır ve hazır gizleme sunar. Winston satırı seçtiğin formatlarla kurar. LogBrew ikisinden de log alır.

### Pino neden default level must be included in custom levels hatası veriyor?

Verdiğin seviye bir Pino seviyesi değil, çoğu zaman boş bir `LOG_LEVEL`. `process.env.LOG_LEVEL || "info"` yaz, böylece boş değer `info` olur.

## Her Node.js hatasını isteğiyle birlikte gör

LogBrew Node SDK her Pino ya da Winston logunu seviyesi ve alanlarıyla gönderir, onu istek trace'ine ve soruna bağlar. Cömert ücretsiz katmanla başla, kart gerekmez.

[Ücretsiz başla](https://logbrew.co/tr)

## Kaynaklar

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

## Ajanlar, Python, Node.js ve React için diğer rehberler

- [Claude Code ve Codex'e MCP sunucusu ekle](https://logbrew.co/tr/guides/mcp-server-claude-code-codex)
- [Claude Code ve Codex'te AGENTS.md kullan](https://logbrew.co/tr/guides/agents-md)
- [Claude overloaded 529 ve rate limit 429 hatalarını çöz](https://logbrew.co/tr/guides/claude-overloaded-rate-limit-error)
- [Python logging'i doğru log seviyeleri ve istisna yakalamayla kur](https://logbrew.co/tr/guides/python-logging)
- [Structured logging ile alana göre arayabileceğin log formatı ve log seviyeleri](https://logbrew.co/tr/guides/structured-logging)
- [Django loglamayı kur ve her 500 hatasının stack trace'ini sakla](https://logbrew.co/tr/guides/django-logging)
- [FastAPI loglamayı kur ve hataları yönet stack trace'i kaybetmeden](https://logbrew.co/tr/guides/fastapi-logging)
- [React'te bir error boundary ekle ve onun kaçırdığı hataları logla](https://logbrew.co/tr/guides/react-error-boundary)
- [Trace ID ve span ID farkı, gerçek bir traceparent başlığıyla](https://logbrew.co/tr/guides/trace-id)
- [Hata, log, trace, metrik ve sürüm rehberleri](https://logbrew.co/tr/guides)
