---
title: "Voeg een React error boundary toe en log de fouten die hij mist"
description: "Een React error boundary vangt fouten tijdens het renderen af en toont een fallback. Hier lees je de klasse, de fouten die hij mist en hoe je elke fout naar LogBrew stuurt, getest op React 19.3."
canonical: "https://logbrew.co/nl/guides/react-error-boundary"
last_updated: "2026-11-21"
---

# Voeg een React error boundary toe en log de fouten die hij mist

Een React error boundary vangt fouten tijdens het renderen af en toont een fallback. Hier lees je de klasse, de fouten die hij mist en hoe je elke fout naar LogBrew stuurt, getest op React 19.3.

Getest op 21 november 2026 met React 19.3.1, Vite 8.3.8, Chrome 156, @logbrew/react 0.1.6, @logbrew/sdk 0.1.47 en logbrew CLI 0.1.96

Door [Furkan Erday](https://github.com/furkanerday). Furkan Erday is de oprichter van LogBrew. Hij bouwt LogBrew elke dag met Claude Code en Codex.

Canonical: https://logbrew.co/nl/guides/react-error-boundary

## Welke React-fouten een fallback tonen en LogBrew bereiken

| Waar de fout werd gegooid | Fallback getoond | Issue in LogBrew |
| --- | --- | --- |
| Renderen, binnen `LogBrewErrorBoundary` | Ja | Ja |
| `useEffect`, binnen de boundary | Ja | Ja |
| Renderen, zonder boundary | Nee, lege root | Ja, via de root-opties |
| Handler `onClick` | Nee | Nee |
| Async handler, na `await` | Nee | Nee |
| `onClick` met `captureReactError()` | Nee | Ja |

6 fouten in 1 Vite-productiebuild met React 19.3.1 en @logbrew/react 0.1.6.

## Een error boundary schrijven

### Schrijf de boundary als klassecomponent

React heeft hier geen hook voor, dus een error boundary is een klasse. `getDerivedStateFromError` zet hem bij de volgende render op de fallback. `componentDidCatch` krijgt de fout en `info.componentStack`, de lijst van componenten boven het component dat de fout gooide.

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

### Wikkel het deel van de pagina dat kan falen

`TapList` leest `taps.map` als `taps` ontbreekt, dus gooit hij een fout tijdens het renderen. De boundary toonde `Could not load the taps.`, en de kop `Taproom` bleef staan. In ontwikkeling schreef React de fout ook met `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>
  );
}
```

Uitvoer

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

### Een fout in een event-handler slaat de boundary over

React roept `onClick` buiten het renderen aan, dus de boundary kreeg de fout nooit. De knop bleef op de pagina, en de browser schreef een niet-afgevangen fout. Een fout na `await` deed hetzelfde.

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

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

Uitvoer

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

### Geef een handlerfout via state door aan de boundary

Vang de fout af in de handler, bewaar hem met `setError` en gooi hem bij de volgende render. Dan toont de boundary zijn fallback en krijgt hij de fout in `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>;
}
```

Uitvoer

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

### Zonder boundary haalt React de hele boom weg

Als geen boundary een renderfout afvangt, unmount React 19 de root. Het element `root` was leeg, en de kop was ook weg. React schreef de fout en een waarschuwing die om een error boundary vraagt.

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

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

Uitvoer

```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-fouten naar LogBrew sturen

### Installeer de pakketten

`@logbrew/react` voegt de provider, de error boundary en de root-opties toe. Gebruik een browsersleutel van je LogBrew-project als `clientKey`.

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

### Maak de client en een transport

De client houdt events in een wachtrij tot je `client.flush(transport)` aanroept. Het transport moet `{ statusCode }` teruggeven. Toen het onze de `fetch`-response teruggaf, mislukte de flush met `invalid transport response`. Zet `VITE_LOGBREW_ENDPOINT` op `https://api.logbrew.co/v1/events`. Wij stuurden naar een lokale LogBrew-server.

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

### Zet LogBrewErrorBoundary binnen LogBrewProvider

`LogBrewErrorBoundary` haalt de client uit `LogBrewProvider`. Zonder provider toonde hij de fallback maar stuurde niets, en `onCaptureError` kreeg `captureReactError requires a client`. `onError` draait na het vastleggen, dus flush daar.

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

Uitvoer

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

### Vang de fouten die geen boundary afving

`createLogBrewReactRootOptions()` geeft `createRoot` zijn fout-callbacks. Het legde de renderfout zonder boundary vast. Het slaat fouten over die `LogBrewErrorBoundary` al stuurde, dus elke fout komt 1 keer aan.

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

Uitvoer

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

### Meld handlerfouten met captureReactError()

Geen boundary en geen root-callback krijgt een fout uit een handler, dus vang hem af en geef hem door aan `captureReactError()`. De `metadata` die je meegeeft, blijven bij het issue.

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

Uitvoer

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

### Lees de issues terug

We lazen het project met een leessleutel. De renderfout binnen de boundary en dezelfde fout zonder boundary kwamen allebei uit `TapList.jsx`, dus werden ze 1 issue met 2 keer voorkomen. De handlerfout werd een eigen issue.

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

Uitvoer

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

## Wat we zagen in onze test

We bouwden 1 Vite-app met React 19.3.1 en @logbrew/react 0.1.6, en draaiden elk geval in Chrome met een lokale LogBrew-server. De output hierboven komt van de Vite-devserver. We draaiden dezelfde gevallen in een productiebuild, met dezelfde resultaten.

Alleen fouten tijdens het renderen en in `useEffect` bereikten een boundary. Fouten in `onClick` en na `await` bereikten geen boundary en geen root-callback. Alleen `captureReactError()` stuurde ze.

|  | `LogBrewErrorBoundary` | `onUncaughtError` |
| --- | --- | --- |
| Renderfout binnen de boundary | Ja | Nee |
| Renderfout zonder boundary | Nee | Ja |
| Fout in een event-handler | Nee | Nee |

## De boundary resetten en opnieuw proberen

De fallback van `LogBrewErrorBoundary` krijgt `resetError`, dat de children opnieuw rendert. Gooit het child opnieuw een fout, dan toont de boundary weer de fallback en stuurt 1 event extra.

Los dus eerst de oorzaak op voordat je het opnieuw probeert, laad bijvoorbeeld de data opnieuw. In onze test renderde de nieuwe poging de lijst toen de data er was.

|  | Fallback getoond | Event gestuurd |
| --- | --- | --- |
| Eerste renderfout | Ja | Ja |
| `Try Again`, het child faalt weer | Ja | Ja |
| `Try Again`, het child rendert | Nee | Nee |

## Wat LogBrew vastlegt

Elke React-fout wordt een issue met de titel `React error:` en het bericht. De boundary legt het mechanisme `react.error_boundary` vast met `handled: true`. De root-opties leggen `react.uncaught_error` vast met `handled: false`.

LogBrew groepeert React-fouten op fouttype en op het bestand van het eerste stackframe. In onze productiebuild kwamen 5 `Error`-events met verschillende berichten, zoals `keg sensor offline` en `tap list not loaded`, uit 1 bundlebestand en werden ze 1 issue. In ontwikkeling is elk component een eigen bestand, dus bleven de issues apart.

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

## Veelgestelde vragen

### Wat is een error boundary in React?

Een klassecomponent met `getDerivedStateFromError` of `componentDidCatch`. Als een child tijdens het renderen een fout gooit, toont React de fallback van de boundary en houdt het de rest van de pagina.

### Kan ik een error boundary met hooks schrijven?

Nee. React heeft er geen hook voor, dus de boundary is een klasse. Schrijf hem 1 keer, of gebruik `LogBrewErrorBoundary`, en zet hem om functiecomponenten heen.

### Waarom vangt mijn error boundary de fout niet af?

De fout werd buiten het renderen gegooid, vaak in een event-handler of na `await`. Vang hem daar af en meld hem met `captureReactError()`, of bewaar hem in state en gooi hem tijdens het renderen.

### Waar zet ik error boundaries?

Om elk deel van de pagina dat los kan falen, zoals een lijst die data laadt, zodat de rest van de pagina blijft. Zet er ook 1 vlak bij de root, want een fout die geen boundary afvangt, haalt de hele boom weg.

### Hoe log ik fouten uit een error boundary?

Stuur ze vanuit `componentDidCatch`, of gebruik `LogBrewErrorBoundary` binnen `LogBrewProvider`. Voeg `createLogBrewReactRootOptions()` toe aan `createRoot` voor de fouten die geen boundary afving.

## Zie elke React-fout met zijn componentstack

LogBrew legt elke renderfout in React vast met zijn componentstack en groepeert herhalingen tot 1 issue. Begin met het ruime gratis abonnement, zonder creditcard.

[Gratis beginnen](https://logbrew.co/nl)

## Bronnen

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

## Meer handleidingen voor agents, Python, Node.js en React

- [Een MCP-server toevoegen aan Claude Code en Codex](https://logbrew.co/nl/guides/mcp-server-claude-code-codex)
- [AGENTS.md gebruiken in Claude Code en Codex](https://logbrew.co/nl/guides/agents-md)
- [Claude overloaded error 529 en rate limit error 429 oplossen](https://logbrew.co/nl/guides/claude-overloaded-rate-limit-error)
- [Python-logging instellen met de juiste logniveaus en exceptions met traceback](https://logbrew.co/nl/guides/python-logging)
- [Structured logging met een logformaat en logniveaus die je per veld doorzoekt](https://logbrew.co/nl/guides/structured-logging)
- [Node.js-logging instellen met Pino of Winston zonder één fout te missen](https://logbrew.co/nl/guides/node-logging)
- [Stel Django-logging in en bewaar de stacktrace van elke 500-fout](https://logbrew.co/nl/guides/django-logging)
- [Stel FastAPI-logging in en handel fouten af zonder de stacktrace te verliezen](https://logbrew.co/nl/guides/fastapi-logging)
- [Trace-ID vs span-ID, ontleed in een echte traceparent-header](https://logbrew.co/nl/guides/trace-id)
- [Los Minified React error #418 en #185 op met de volledige melding en je eigen regel](https://logbrew.co/nl/errors/minified-react-error)
- [Handleidingen voor fouten, logs, traces, metrics en releases](https://logbrew.co/nl/guides)
