---
title: "Eine React Error Boundary bauen und die Fehler loggen, die sie verpasst"
description: "Eine React Error Boundary fängt Fehler beim Rendern ab und zeigt einen Fallback. Hier sind die Klasse, die Fehler, die sie verpasst, und der Weg jedes Fehlers zu LogBrew, getestet mit React 19.3."
canonical: "https://logbrew.co/de/guides/react-error-boundary"
last_updated: "2026-11-21"
---

# Eine React Error Boundary bauen und die Fehler loggen, die sie verpasst

Eine React Error Boundary fängt Fehler beim Rendern ab und zeigt einen Fallback. Hier sind die Klasse, die Fehler, die sie verpasst, und der Weg jedes Fehlers zu LogBrew, getestet mit React 19.3.

Getestet am 21. November 2026 mit React 19.3.1, Vite 8.3.8, Chrome 156, @logbrew/react 0.1.6, @logbrew/sdk 0.1.47 und logbrew CLI 0.1.96

Von [Furkan Erday](https://github.com/furkanerday). Furkan Erday hat LogBrew gegründet. Er entwickelt LogBrew jeden Tag mit Claude Code und Codex.

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

## Welche React-Fehler einen Fallback zeigen und LogBrew erreichen

| Wo der Fehler geworfen wurde | Fallback angezeigt | Issue in LogBrew |
| --- | --- | --- |
| Rendern, in `LogBrewErrorBoundary` | Ja | Ja |
| `useEffect`, in der Boundary | Ja | Ja |
| Rendern, ohne Boundary | Nein, leere Root | Ja, über die Root-Optionen |
| Handler `onClick` | Nein | Nein |
| Async-Handler, nach `await` | Nein | Nein |
| `onClick` mit `captureReactError()` | Nein | Ja |

6 Fehler in 1 Vite-Produktions-Build mit React 19.3.1 und @logbrew/react 0.1.6.

## Eine Error Boundary schreiben

### Die Boundary als Klassenkomponente schreiben

React hat dafür keinen Hook, deshalb ist eine Error Boundary eine Klasse. `getDerivedStateFromError` schaltet sie beim nächsten Rendern auf den Fallback um. `componentDidCatch` bekommt den Fehler und `info.componentStack`, die Liste der Komponenten über der, die geworfen hat.

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

### Den Teil der Seite umschließen, der scheitern kann

`TapList` liest `taps.map`, wenn `taps` fehlt, und wirft deshalb beim Rendern. Die Boundary zeigte `Could not load the taps.`, und die Überschrift `Taproom` blieb stehen. In der Entwicklung gab React den Fehler zusätzlich mit `The above error occurred in the <TapList> component` aus.

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

Ausgabe

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

### Ein Fehler im Ereignis-Handler umgeht die Boundary

React ruft `onClick` außerhalb des Renderns auf, deshalb bekam die Boundary den Fehler nie. Der Button blieb auf der Seite, und der Browser gab einen nicht abgefangenen Fehler aus. Ein Fehler nach `await` verhielt sich genauso.

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

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

Ausgabe

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

### Einen Handler-Fehler über den State an die Boundary geben

Fang den Fehler im Handler ab, speichere ihn mit `setError` und wirf ihn beim nächsten Rendern. Dann zeigt die Boundary ihren Fallback und bekommt den Fehler 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>;
}
```

Ausgabe

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

### Ohne Boundary entfernt React den ganzen Baum

Fängt keine Boundary einen Render-Fehler ab, hängt React 19 die Root aus. Das Element `root` war leer, und auch die Überschrift war weg. React gab den Fehler aus und eine Warnung, die eine Error Boundary empfiehlt.

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

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

Ausgabe

```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-Fehler an LogBrew senden

### Die Pakete installieren

`@logbrew/react` bringt den Provider, die Error Boundary und die Root-Optionen mit. Nimm einen Browser-Schlüssel deines LogBrew-Projekts als `clientKey`.

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

### Client und Transport erstellen

Der Client hält Ereignisse in einer Warteschlange, bis du `client.flush(transport)` aufrufst. Der Transport muss `{ statusCode }` zurückgeben. Als unserer die `fetch`-Antwort zurückgab, scheiterte der Flush mit `invalid transport response`. Setz `VITE_LOGBREW_ENDPOINT` auf `https://api.logbrew.co/v1/events`. Wir haben an einen lokalen LogBrew-Server gesendet.

```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 in LogBrewProvider setzen

`LogBrewErrorBoundary` holt sich den Client aus `LogBrewProvider`. Ohne Provider zeigte sie den Fallback, sendete aber nichts, und `onCaptureError` bekam `captureReactError requires a client`. `onError` läuft nach der Erfassung, also flushe dort.

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

Ausgabe

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

### Die Fehler abfangen, die keine Boundary abgefangen hat

`createLogBrewReactRootOptions()` gibt `createRoot` seine Fehler-Callbacks. Es speicherte den Render-Fehler ohne Boundary. Fehler, die `LogBrewErrorBoundary` schon gesendet hat, überspringt es, deshalb kommt jeder Fehler 1 Mal an.

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

Ausgabe

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

### Handler-Fehler mit captureReactError() melden

Einen Fehler aus einem Handler bekommt weder eine Boundary noch ein Root-Callback, also fang ihn ab und gib ihn an `captureReactError()`. Die `metadata`, die du mitgibst, bleiben am 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>;
}
```

Ausgabe

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

### Die Issues zurücklesen

Wir haben das Projekt mit einem Leseschlüssel gelesen. Der Render-Fehler in der Boundary und derselbe Fehler ohne Boundary kamen beide aus `TapList.jsx`, deshalb wurden sie 1 Issue mit 2 Vorkommen. Der Handler-Fehler wurde ein eigenes Issue.

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

Ausgabe

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

## Was wir beim Testen gesehen haben

Wir haben 1 Vite-App mit React 19.3.1 und @logbrew/react 0.1.6 gebaut und jeden Fall in Chrome mit einem lokalen LogBrew-Server ausgeführt. Die Ausgaben oben stammen vom Vite-Dev-Server. Dieselben Fälle haben wir in einem Produktions-Build ausgeführt, mit demselben Ergebnis.

Nur Fehler beim Rendern und in `useEffect` erreichten eine Boundary. Fehler in `onClick` und nach `await` erreichten weder eine Boundary noch ein Root-Callback. Nur `captureReactError()` hat sie gesendet.

|  | `LogBrewErrorBoundary` | `onUncaughtError` |
| --- | --- | --- |
| Render-Fehler in der Boundary | Ja | Nein |
| Render-Fehler ohne Boundary | Nein | Ja |
| Fehler im Ereignis-Handler | Nein | Nein |

## Die Boundary zurücksetzen und es erneut versuchen

Der Fallback von `LogBrewErrorBoundary` bekommt `resetError`, das die Kinder neu rendert. Wirft das Kind erneut, zeigt die Boundary wieder den Fallback und sendet 1 weiteres Ereignis.

Behebe also die Ursache vor dem neuen Versuch, lade zum Beispiel die Daten neu. In unserem Lauf hat der neue Versuch die Liste gerendert, als die Daten da waren.

|  | Fallback angezeigt | Ereignis gesendet |
| --- | --- | --- |
| Erster Render-Fehler | Ja | Ja |
| `Try Again`, das Kind wirft erneut | Ja | Ja |
| `Try Again`, das Kind rendert | Nein | Nein |

## Was LogBrew speichert

Jeder React-Fehler wird ein Issue mit dem Titel `React error:` und seiner Nachricht. Die Boundary speichert den Mechanismus `react.error_boundary` mit `handled: true`. Die Root-Optionen speichern `react.uncaught_error` mit `handled: false`.

LogBrew gruppiert React-Fehler nach Fehlertyp und der Datei des ersten Stack-Frames. In unserem Produktions-Build kamen 5 `Error`-Ereignisse mit verschiedenen Nachrichten, etwa `keg sensor offline` und `tap list not loaded`, aus 1 Bundle-Datei und wurden 1 Issue. In der Entwicklung ist jede Komponente eine eigene Datei, deshalb blieben die Issues getrennt.

- `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`
  - Gruppierungsschlüssel: `react.error:Error:…/HandlerButton.jsx`

## Häufige Fragen

### Was ist eine Error Boundary in React?

Eine Klassenkomponente mit `getDerivedStateFromError` oder `componentDidCatch`. Wirft ein Kind beim Rendern, zeigt React den Fallback der Boundary und behält den Rest der Seite.

### Kann ich eine Error Boundary mit Hooks schreiben?

Nein. React hat dafür keinen Hook, deshalb ist die Boundary eine Klasse. Schreib sie 1 Mal oder nimm `LogBrewErrorBoundary`, und leg sie um Funktionskomponenten.

### Warum fängt meine Error Boundary den Fehler nicht ab?

Der Fehler wurde außerhalb des Renderns geworfen, oft in einem Ereignis-Handler oder nach `await`. Fang ihn dort ab und melde ihn mit `captureReactError()`, oder speichere ihn im State und wirf ihn beim Rendern.

### Wo sollte ich Error Boundaries platzieren?

Um jeden Teil der Seite, der allein scheitern kann, etwa eine Liste, die Daten lädt, damit der Rest der Seite bleibt. Setz auch 1 nahe der Root, denn ein Fehler, den keine Boundary abfängt, entfernt den ganzen Baum.

### Wie logge ich Fehler aus einer Error Boundary?

Sende sie aus `componentDidCatch`, oder nimm `LogBrewErrorBoundary` in `LogBrewProvider`. Füge `createLogBrewReactRootOptions()` zu `createRoot` hinzu, für die Fehler, die keine Boundary abgefangen hat.

## Jeden React-Fehler mit seinem Komponenten-Stack sehen

LogBrew speichert jeden Render-Fehler in React mit seinem Komponenten-Stack und fasst Wiederholungen zu 1 Issue zusammen. Starte mit dem großzügigen kostenlosen Plan, ohne Kreditkarte.

[Kostenlos starten](https://logbrew.co/de)

## Quellen

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

## Weitere Anleitungen für Agenten, Python, Node.js und React

- [MCP-Server in Claude Code und Codex hinzufügen](https://logbrew.co/de/guides/mcp-server-claude-code-codex)
- [AGENTS.md in Claude Code und Codex nutzen](https://logbrew.co/de/guides/agents-md)
- [Claude-Fehler 529 overloaded und 429 Rate Limit beheben](https://logbrew.co/de/guides/claude-overloaded-rate-limit-error)
- [Python-Logging einrichten mit den richtigen Log-Leveln und Exception-Erfassung](https://logbrew.co/de/guides/python-logging)
- [Structured Logging mit Log-Format und Log-Leveln, die du nach Feld durchsuchst](https://logbrew.co/de/guides/structured-logging)
- [Node.js-Logging mit Pino oder Winston einrichten und keinen Fehler verlieren](https://logbrew.co/de/guides/node-logging)
- [Django-Logging einrichten und den Traceback jedes 500-Fehlers behalten](https://logbrew.co/de/guides/django-logging)
- [FastAPI-Logging einrichten und Fehler behandeln, ohne den Traceback zu verlieren](https://logbrew.co/de/guides/fastapi-logging)
- [Trace-ID vs. Span-ID, an einem echten traceparent-Header erklärt](https://logbrew.co/de/guides/trace-id)
- [Minified React error #418 und #185 beheben, mit der vollen Meldung und deiner Quellzeile](https://logbrew.co/de/errors/minified-react-error)
- [Anleitungen zu Fehlern, Logs, Traces, Metriken und Releases](https://logbrew.co/de/guides)
