---
title: "React'te bir error boundary ekle ve onun kaçırdığı hataları logla"
description: "React error boundary, render sırasında fırlatılan hataları yakalar ve bir fallback gösterir. Sınıf, onun kaçırdığı hatalar ve her birini LogBrew'e gönderme, React 19.3 üzerinde test edildi."
canonical: "https://logbrew.co/tr/guides/react-error-boundary"
last_updated: "2026-11-21"
---

# React'te bir error boundary ekle ve onun kaçırdığı hataları logla

React error boundary, render sırasında fırlatılan hataları yakalar ve bir fallback gösterir. Sınıf, onun kaçırdığı hatalar ve her birini LogBrew'e gönderme, React 19.3 üzerinde test edildi.

21 Kasım 2026 tarihinde React 19.3.1, Vite 8.3.8, Chrome 156, @logbrew/react 0.1.6, @logbrew/sdk 0.1.47 ve logbrew CLI 0.1.96 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/react-error-boundary

## Hangi React hataları fallback gösterir ve LogBrew'e ulaşır

| Hatanın fırlatıldığı yer | Fallback gösterildi | LogBrew'de sorun |
| --- | --- | --- |
| Render, `LogBrewErrorBoundary` içinde | Evet | Evet |
| `useEffect`, boundary içinde | Evet | Evet |
| Render, boundary olmadan | Hayır, kök boş | Evet, kök seçenekleriyle |
| `onClick` işleyicisi | Hayır | Hayır |
| Async işleyici, `await` sonrası | Hayır | Hayır |
| `captureReactError()` ile `onClick` | Hayır | Evet |

React 19.3.1 ve @logbrew/react 0.1.6 ile 1 Vite canlı ortam build'inde 6 hata.

## Bir error boundary yaz

### Boundary'yi sınıf bileşeni olarak yaz

React'te bunun için bir hook yok, bu yüzden error boundary bir sınıftır. `getDerivedStateFromError` sonraki render'da fallback'e geçer. `componentDidCatch` hatayı ve `info.componentStack` değerini alır, yani hatayı fırlatan bileşenin üstündeki bileşenlerin listesini.

```bash
import { Component } from "react";

export class ErrorBoundary extends Component {
  state = { error: null };

  static getDerivedStateFromError(error) {
    return { error };
  }

  componentDidCatch(error, info) {
    console.log("caught:", error.message);
    console.log("in:", info.componentStack.split("\n")[1].trim());
  }

  render() {
    if (this.state.error) return <p role="alert">Could not load the taps.</p>;
    return this.props.children;
  }
}
```

### Sayfanın bozulabilecek kısmını sarmala

`taps` eksikken `TapList`, `taps.map` değerini okur ve render sırasında hata fırlatır. Boundary `Could not load the taps.` gösterdi, `Taproom` başlığı da ekranda kaldı. Geliştirmede React ayrıca hatayı `The above error occurred in the <TapList> component` ile yazdırdı.

```bash
// TapList.jsx
export function TapList({ taps }) {
  return <ul>{taps.map((tap) => <li key={tap}>{tap}</li>)}</ul>;
}

// App.jsx
import { ErrorBoundary } from "./ErrorBoundary.jsx";
import { TapList } from "./TapList.jsx";

export function App() {
  return (
    <main>
      <h1>Taproom</h1>
      <ErrorBoundary>
        <TapList />
      </ErrorBoundary>
    </main>
  );
}
```

Çıktı

```text
caught: Cannot read properties of undefined (reading 'map')
in: at TapList (http://127.0.0.1:25174/guide/TapList.jsx:3:27)
```

### Olay işleyicisindeki bir hata boundary'nin yanından geçer

React `onClick` işleyicisini render dışında çağırır, bu yüzden boundary hatayı hiç almadı. Düğme sayfada kaldı, tarayıcı da yakalanmamış bir hata yazdırdı. `await` sonrasındaki bir hata da aynısını yaptı.

```bash
export function PourButton() {
  return (
    <button onClick={() => { throw new Error("pour failed"); }}>Pour</button>
  );
}

// main.jsx
createRoot(document.getElementById("root")).render(
  <ErrorBoundary>
    <PourButton />
  </ErrorBoundary>
);
```

Çıktı

```text
Uncaught Error: pour failed
    at onClick (http://127.0.0.1:25174/guide/PourButton.jsx:6:10)
```

### İşleyicideki hatayı state ile boundary'ye ilet

Hatayı işleyicide yakala, `setError` ile sakla ve sonraki render'da fırlat. Böylece boundary fallback'i gösterir ve hatayı `componentDidCatch` içinde alır.

```bash
import { useState } from "react";

export function SafePourButton() {
  const [error, setError] = useState(null);
  if (error) throw error;

  function pour() {
    try {
      throw new Error("pour failed");
    } catch (caught) {
      setError(caught);
    }
  }

  return <button onClick={pour}>Pour</button>;
}
```

Çıktı

```text
caught: pour failed
in: at SafePourButton (http://127.0.0.1:25174/guide/SafePourButton.jsx:7:28)
```

### Boundary yoksa React tüm ağacı kaldırır

Hiçbir boundary bir render hatasını yakalamazsa React 19 kökü kaldırır. `root` elemanı boşaldı, başlık da kayboldu. React hatayı ve bir error boundary eklemeni öneren bir uyarı yazdırdı.

```bash
import { createRoot } from "react-dom/client";
import { TapList } from "./TapList.jsx";

createRoot(document.getElementById("root")).render(
  <main>
    <h1>Taproom</h1>
    <TapList />
  </main>
);
```

Çıktı

```text
Uncaught TypeError: Cannot read properties of undefined (reading 'map')
An error occurred in the <TapList> component. Consider adding an error boundary to your tree to customize error handling behavior.
Visit https://react.dev/link/error-boundaries to learn more about error boundaries.
```

## React hatalarını LogBrew'e gönder

### Paketleri kur

`@logbrew/react`, provider'ı, error boundary'yi ve kök seçeneklerini sağlar. `clientKey` olarak LogBrew projenden bir tarayıcı anahtarı kullan.

```bash
npm install @logbrew/sdk @logbrew/react react
```

### İstemciyi ve bir transport oluştur

İstemci olayları `client.flush(transport)` çağırana kadar kuyrukta tutar. Transport `{ statusCode }` döndürmeli. Bizimki `fetch` yanıtını döndürdüğünde flush `invalid transport response` hatasıyla başarısız oldu. `VITE_LOGBREW_ENDPOINT` değerini `https://api.logbrew.co/v1/events` yap. Biz yerel bir LogBrew sunucusuna gönderdik.

```bash
import { createLogBrewReactClient } from "@logbrew/react";

export const client = createLogBrewReactClient({
  clientKey: import.meta.env.VITE_LOGBREW_CLIENT_KEY
});

export const transport = {
  async send(apiKey, body) {
    const response = await fetch(import.meta.env.VITE_LOGBREW_ENDPOINT, {
      method: "POST",
      headers: {
        authorization: `Bearer ${apiKey}`,
        "content-type": "application/json",
      },
      body
    });
    return { statusCode: response.status };
  }
};

export function send() {
  return client
    .flush(transport)
    .then((result) => console.log("sent", JSON.stringify(result)));
}
```

### LogBrewErrorBoundary'yi LogBrewProvider içine koy

`LogBrewErrorBoundary` istemciyi `LogBrewProvider` üzerinden alır. Provider olmadan fallback'i gösterdi ama hiçbir şey göndermedi, `onCaptureError` de `captureReactError requires a client` aldı. `onError` yakalamadan sonra çalışır, bu yüzden flush'ı orada yap.

```bash
import { LogBrewErrorBoundary, LogBrewProvider } from "@logbrew/react";
import { client, send } from "./logbrew.js";
import { TapList } from "./TapList.jsx";

export function App() {
  return (
    <LogBrewProvider client={client}>
      <LogBrewErrorBoundary
        fallback={({ error, resetError }) => (
          <div role="alert">
            <p>Could not load the taps: {error.message}</p>
            <button onClick={resetError}>Try Again</button>
          </div>
        )}
        onError={send}
      >
        <TapList />
      </LogBrewErrorBoundary>
    </LogBrewProvider>
  );
}
```

Çıktı

```text
sent {"statusCode":200,"attempts":1,"batches":1}
```

### Hiçbir boundary'nin yakalamadığı hataları yakala

`createLogBrewReactRootOptions()`, `createRoot` için hata callback'lerini verir. Boundary olmadan fırlatılan render hatasını kaydetti. `LogBrewErrorBoundary` tarafından gönderilmiş hataları atlar, böylece her hata sadece 1 kez gelir.

```bash
import { createRoot } from "react-dom/client";
import { createLogBrewReactRootOptions } from "@logbrew/react";
import { client, send } from "./logbrew.js";
import { TapList } from "./TapList.jsx";

createRoot(
  document.getElementById("root"),
  createLogBrewReactRootOptions(client, { onUncaughtError: send })
).render(<TapList />);
```

Çıktı

```text
sent {"statusCode":200,"attempts":1,"batches":1}
```

### İşleyici hatalarını captureReactError() ile bildir

Ne bir boundary ne de bir kök callback'i işleyicideki hatayı alır, bu yüzden hatayı yakala ve `captureReactError()` fonksiyonuna ver. Verdiğin `metadata` sorunda kalır.

```bash
import { captureReactError } from "@logbrew/react";
import { client, send } from "./logbrew.js";

export function PayButton() {
  async function pay() {
    try {
      await Promise.resolve();
      throw new Error("payment declined");
    } catch (error) {
      captureReactError(client, error, { metadata: { action: "pay" } });
      send();
    }
  }

  return <button onClick={pay}>Pay</button>;
}
```

Çıktı

```text
sent {"statusCode":200,"attempts":1,"batches":1}
```

### Sorunları geri oku

Projeyi bir okuma anahtarıyla okuduk. Boundary içindeki render hatası ve boundary olmadan aynı hata `TapList.jsx` dosyasından geldi, bu yüzden 2 tekrarlı 1 sorun oldu. İşleyici hatası ayrı bir sorun oldu.

```bash
logbrew issues --since 3h
```

Çıktı

```text
Issues (2)
- 1613a62e-31a3-5045-a144-c9c593760bff unresolved error priority=medium React error: payment declined occurrences=1 users=unknown last_seen=2026-11-21T06:35:49.154Z service=unknown_service trace=2ca253b519dfa2866268889760e5f2a0 assignee=unassigned [unversioned / production]
- f9eb7448-fab2-5d52-82f3-592a3b680a08 unresolved error priority=medium React error: Cannot read properties of undefined (reading 'map') occurrences=2 users=unknown last_seen=2026-11-21T06:35:43.870Z service=unknown_service trace=225e883023acc9c768da676fedd8e2c1 assignee=unassigned [unversioned / production]
```

## Test ederken gördüklerimiz

React 19.3.1 ve @logbrew/react 0.1.6 ile 1 Vite uygulaması oluşturduk ve her durumu yerel bir LogBrew sunucusuyla Chrome'da çalıştırdık. Yukarıdaki çıktılar Vite geliştirme sunucusundan geliyor. Aynı durumları bir canlı ortam build'inde de çalıştırdık, sonuçlar aynıydı.

Sadece render sırasında ve `useEffect` içinde fırlatılan hatalar bir boundary'ye ulaştı. `onClick` içindeki ve `await` sonrasındaki hatalar ne bir boundary'ye ne de bir kök callback'ine ulaştı. Bunları sadece `captureReactError()` gönderdi.

|  | `LogBrewErrorBoundary` | `onUncaughtError` |
| --- | --- | --- |
| Boundary içinde render hatası | Evet | Hayır |
| Boundary olmadan render hatası | Hayır | Evet |
| Olay işleyicisinde hata | Hayır | Hayır |

## Boundary'yi sıfırla ve tekrar dene

`LogBrewErrorBoundary` fallback'i `resetError` alır, bu da alt bileşenleri tekrar render eder. Alt bileşen tekrar hata fırlatırsa boundary fallback'i yine gösterir ve 1 olay daha gönderir.

Bu yüzden tekrar denemeden önce nedeni düzelt, örneğin veriyi tekrar yükle. Testimizde veri hazır olduğunda yeni deneme listeyi render etti.

|  | Gösterilen fallback | Gönderilen olay |
| --- | --- | --- |
| İlk render hatası | Evet | Evet |
| `Try Again`, alt bileşen yine hata verir | Evet | Evet |
| `Try Again`, alt bileşen render edilir | Hayır | Hayır |

## LogBrew neleri kaydeder

Her React hatası, `React error:` başlığı ve mesajla bir sorun olur. Boundary, `react.error_boundary` mekanizmasını `handled: true` ile kaydeder. Kök seçenekleri `react.uncaught_error` mekanizmasını `handled: false` ile kaydeder.

LogBrew React hatalarını hata türüne ve ilk stack frame'in dosyasına göre gruplar. Canlı ortam build'imizde `keg sensor offline` ve `tap list not loaded` gibi farklı mesajlı 5 `Error` olayı 1 bundle dosyasından geldi ve 1 sorun oldu. Geliştirmede her bileşen kendi dosyasıdır, bu yüzden sorunlar ayrı kaldı.

- `LogBrewErrorBoundary`
  - `mechanism`: `react.error_boundary`
  - `handled`: `true`
  - Sorun: `React error: Cannot read properties of undefined (reading 'map')`
- `createLogBrewReactRootOptions()`
  - `mechanism`: `react.uncaught_error`
  - `handled`: `false`
  - Stack frame'leri: 10
- `captureReactError()`
  - Sorun: `React error: payment declined`
  - `metadata.action`: `pay`
  - Gruplama anahtarı: `react.error:Error:…/HandlerButton.jsx`

## Sık sorulan sorular

### React'te error boundary nedir?

`getDerivedStateFromError` ya da `componentDidCatch` içeren bir sınıf bileşeni. Bir alt bileşen render sırasında hata fırlatınca React boundary'nin fallback'ini gösterir ve sayfanın geri kalanını korur.

### Error boundary hook'larla yazılabilir mi?

Hayır. React'te bunun için bir hook yok, bu yüzden boundary bir sınıftır. Onu 1 kez yaz ya da `LogBrewErrorBoundary` kullan, sonra fonksiyon bileşenlerinin etrafına koy.

### Error boundary'm hatayı neden yakalamıyor?

Hata render dışında fırlatıldı, çoğu zaman bir olay işleyicisinde ya da `await` sonrasında. Hatayı orada yakala ve `captureReactError()` ile bildir ya da state'e koyup render sırasında fırlat.

### Error boundary'leri nereye koymalıyım?

Sayfanın tek başına bozulabilecek her kısmının etrafına, örneğin veri yükleyen bir listenin, böylece sayfanın geri kalanı çalışmaya devam eder. Köke yakın 1 tane de koy, çünkü hiçbir boundary'nin yakalamadığı bir hata tüm ağacı kaldırır.

### Error boundary hatalarını nasıl loglarım?

Hataları `componentDidCatch` içinden gönder ya da `LogBrewErrorBoundary` bileşenini `LogBrewProvider` içinde kullan. Hiçbir boundary'nin yakalamadığı hatalar için `createRoot` çağrısına `createLogBrewReactRootOptions()` ekle.

## Her React hatasını bileşen yığınıyla birlikte gör

LogBrew her React render hatasını bileşen yığınıyla kaydeder ve tekrarları 1 sorunda toplar. Cömert ücretsiz katmanla başla, kart gerekmez.

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

## Kaynaklar

- [React docs, Catching rendering errors with an Error Boundary](https://react.dev/reference/react/Component#catching-rendering-errors-with-an-error-boundary)
- [React docs, createRoot parameters](https://react.dev/reference/react-dom/client/createRoot#parameters)
- [reactjs/react.dev#8157](https://github.com/reactjs/react.dev/issues/8157)

## 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)
- [Node.js loglamayı Pino ya da Winston ile kur ve hiçbir hatayı kaçırma](https://logbrew.co/tr/guides/node-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)
- [Trace ID ve span ID farkı, gerçek bir traceparent başlığıyla](https://logbrew.co/tr/guides/trace-id)
- [Minified React error #418 ve #185'i tam mesajdan ve kaynak satırından düzelt](https://logbrew.co/tr/errors/minified-react-error)
- [Hata, log, trace, metrik ve sürüm rehberleri](https://logbrew.co/tr/guides)
