---
title: "Tambahkan error boundary React dan catat error yang lolos darinya"
description: "Error boundary React menangkap error saat render dan menampilkan fallback. Ini class-nya, error yang lolos darinya, dan cara mengirim tiap error ke LogBrew, diuji di React 19.3."
canonical: "https://logbrew.co/id/guides/react-error-boundary"
last_updated: "2026-11-21"
---

# Tambahkan error boundary React dan catat error yang lolos darinya

Error boundary React menangkap error saat render dan menampilkan fallback. Ini class-nya, error yang lolos darinya, dan cara mengirim tiap error ke LogBrew, diuji di React 19.3.

Diuji pada 21 November 2026 dengan React 19.3.1, Vite 8.3.8, Chrome 156, @logbrew/react 0.1.6, @logbrew/sdk 0.1.47, dan logbrew CLI 0.1.96

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/react-error-boundary

## Error React mana yang menampilkan fallback dan sampai ke LogBrew

| Tempat error dilempar | Fallback ditampilkan | Masalah di LogBrew |
| --- | --- | --- |
| Render, di dalam `LogBrewErrorBoundary` | Ya | Ya |
| `useEffect`, di dalam boundary | Ya | Ya |
| Render, tanpa boundary | Tidak, root kosong | Ya, dari opsi root |
| Handler `onClick` | Tidak | Tidak |
| Handler async, setelah `await` | Tidak | Tidak |
| `onClick` dengan `captureReactError()` | Tidak | Ya |

6 error di 1 build produksi Vite dengan React 19.3.1 dan @logbrew/react 0.1.6.

## Tulis error boundary

### Tulis boundary sebagai class component

React tidak punya hook untuk ini, jadi error boundary adalah class. `getDerivedStateFromError` mengalihkannya ke fallback di render berikutnya. `componentDidCatch` menerima error dan `info.componentStack`, yaitu daftar komponen di atas komponen yang melempar error.

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

### Bungkus bagian halaman yang bisa gagal

`TapList` membaca `taps.map` saat `taps` tidak ada, jadi komponen ini melempar error saat render. Boundary menampilkan `Could not load the taps.`, dan judul `Taproom` tetap ada. Saat development, React juga mencetak error dengan `The above error occurred in the <TapList> component`.

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

Output

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

### Error di event handler melewati boundary

React memanggil `onClick` di luar render, jadi boundary tidak pernah menerima error-nya. Tombol tetap ada di halaman, dan browser mencetak error yang tidak tertangkap. Error setelah `await` juga sama.

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

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

Output

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

### Teruskan error handler ke boundary lewat state

Tangkap error di handler, simpan dengan `setError`, lalu lempar di render berikutnya. Boundary lalu menampilkan fallback-nya dan menerima error di `componentDidCatch`.

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

Output

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

### Tanpa boundary, React menghapus seluruh tree

Saat tidak ada boundary yang menangkap error render, React 19 melepas root. Elemen `root` jadi kosong, dan judulnya juga hilang. React mencetak error dan peringatan yang meminta error boundary.

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

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

Output

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

## Kirim error React ke LogBrew

### Pasang paketnya

`@logbrew/react` berisi provider, error boundary, dan opsi root. Pakai kunci browser dari proyek LogBrew kamu sebagai `clientKey`.

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

### Buat klien dan transport

Klien menyimpan event di antrean sampai kamu memanggil `client.flush(transport)`. Transport harus mengembalikan `{ statusCode }`. Saat transport kami mengembalikan respons `fetch`, flush gagal dengan `invalid transport response`. Atur `VITE_LOGBREW_ENDPOINT` ke `https://api.logbrew.co/v1/events`. Kami mengirim ke server LogBrew lokal.

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

### Taruh LogBrewErrorBoundary di dalam LogBrewProvider

`LogBrewErrorBoundary` mengambil klien dari `LogBrewProvider`. Tanpa provider, boundary menampilkan fallback tapi tidak mengirim apa pun, dan `onCaptureError` menerima `captureReactError requires a client`. `onError` berjalan setelah capture, jadi lakukan flush di sana.

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

Output

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

### Tangkap error yang tidak ditangkap boundary mana pun

`createLogBrewReactRootOptions()` memberi `createRoot` callback error-nya. Opsi ini mencatat error render tanpa boundary. Error yang sudah dikirim `LogBrewErrorBoundary` dilewati, jadi tiap error tiba 1 kali.

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

Output

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

### Laporkan error handler dengan captureReactError()

Tidak ada boundary maupun callback root yang menerima error dari handler, jadi tangkap error itu dan teruskan ke `captureReactError()`. `metadata` yang kamu berikan tetap ada di masalah.

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

Output

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

### Baca kembali masalahnya

Kami membaca proyek dengan kunci baca. Error render di dalam boundary dan error yang sama tanpa boundary sama-sama berasal dari `TapList.jsx`, jadi keduanya menjadi 1 masalah dengan 2 kejadian. Error handler menjadi masalah tersendiri.

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

Output

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

## Hasil pengujian kami

Kami membuat 1 aplikasi Vite dengan React 19.3.1 dan @logbrew/react 0.1.6, lalu menjalankan tiap kasus di Chrome dengan server LogBrew lokal. Output di atas berasal dari server development Vite. Kami menjalankan kasus yang sama di build produksi, dan hasilnya sama.

Hanya error saat render dan di `useEffect` yang sampai ke boundary. Error di `onClick` dan setelah `await` tidak sampai ke boundary maupun callback root. Hanya `captureReactError()` yang mengirimnya.

|  | `LogBrewErrorBoundary` | `onUncaughtError` |
| --- | --- | --- |
| Error render di dalam boundary | Ya | Tidak |
| Error render tanpa boundary | Tidak | Ya |
| Error di event handler | Tidak | Tidak |

## Reset boundary dan coba lagi

Fallback dari `LogBrewErrorBoundary` menerima `resetError`, yang me-render children lagi. Jika child melempar error lagi, boundary menampilkan fallback lagi dan mengirim 1 event lagi.

Jadi perbaiki penyebabnya sebelum mencoba lagi, misalnya muat ulang datanya. Dalam pengujian kami, percobaan ulang me-render daftar saat datanya sudah ada.

|  | Fallback ditampilkan | Event dikirim |
| --- | --- | --- |
| Error render pertama | Ya | Ya |
| `Try Again`, child melempar error lagi | Ya | Ya |
| `Try Again`, child berhasil di-render | Tidak | Tidak |

## Apa yang dicatat LogBrew

Tiap error React menjadi masalah berjudul `React error:` dan pesannya. Boundary mencatat mekanisme `react.error_boundary` dengan `handled: true`. Opsi root mencatat `react.uncaught_error` dengan `handled: false`.

LogBrew mengelompokkan error React berdasarkan tipe error dan file dari frame stack pertama. Di build produksi kami, 5 event `Error` dengan pesan berbeda, seperti `keg sensor offline` dan `tap list not loaded`, berasal dari 1 file bundle dan menjadi 1 masalah. Saat development, tiap komponen adalah file tersendiri, jadi masalahnya tetap terpisah.

- `LogBrewErrorBoundary`
  - `mechanism`: `react.error_boundary`
  - `handled`: `true`
  - Masalah: `React error: Cannot read properties of undefined (reading 'map')`
- `createLogBrewReactRootOptions()`
  - `mechanism`: `react.uncaught_error`
  - `handled`: `false`
  - Frame stack: 10
- `captureReactError()`
  - Masalah: `React error: payment declined`
  - `metadata.action`: `pay`
  - Kunci pengelompokan: `react.error:Error:…/HandlerButton.jsx`

## Pertanyaan yang sering diajukan

### Apa itu error boundary di React?

Class component dengan `getDerivedStateFromError` atau `componentDidCatch`. Saat child melempar error ketika render, React menampilkan fallback dari boundary dan mempertahankan bagian halaman lainnya.

### Bisakah menulis error boundary dengan hooks?

Tidak. React tidak punya hook untuk itu, jadi boundary adalah class. Tulis sekali saja, atau pakai `LogBrewErrorBoundary`, lalu taruh di sekitar function component.

### Kenapa error boundary saya tidak menangkap error-nya?

Error dilempar di luar render, sering kali di event handler atau setelah `await`. Tangkap error di sana dan laporkan dengan `captureReactError()`, atau simpan di state lalu lempar saat render.

### Di mana sebaiknya error boundary ditaruh?

Di sekitar tiap bagian halaman yang bisa gagal sendiri, seperti daftar yang memuat data, agar bagian halaman lainnya tetap ada. Taruh juga 1 di dekat root, karena error yang tidak ditangkap boundary mana pun menghapus seluruh tree.

### Bagaimana cara mencatat error dari error boundary?

Kirim error dari `componentDidCatch`, atau pakai `LogBrewErrorBoundary` di dalam `LogBrewProvider`. Tambahkan `createLogBrewReactRootOptions()` ke `createRoot` untuk error yang tidak ditangkap boundary mana pun.

## Lihat tiap error React beserta component stack-nya

LogBrew mencatat tiap error render React beserta component stack-nya, dan mengelompokkan pengulangannya menjadi 1 masalah. Mulai dengan paket gratis yang lega, tanpa perlu kartu.

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

## Sumber

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

## 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)
- [Siapkan logging Node.js dengan Pino atau Winston tanpa kehilangan satu error pun](https://logbrew.co/id/guides/node-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)
- [Trace ID vs span ID, diurai dari header traceparent sungguhan](https://logbrew.co/id/guides/trace-id)
- [Atasi Minified React error #418 dan #185 dari pesan lengkap dan baris kode kamu](https://logbrew.co/id/errors/minified-react-error)
- [Panduan error, log, trace, metrik, dan rilis](https://logbrew.co/id/guides)
