---
title: "Dodaj error boundary w React i loguj błędy, których nie łapie"
description: "Error boundary w React łapie błędy podczas renderu i pokazuje fallback. Oto klasa, błędy, których nie łapie, i wysyłanie każdego z nich do LogBrew, przetestowane na React 19.3."
canonical: "https://logbrew.co/pl/guides/react-error-boundary"
last_updated: "2026-11-21"
---

# Dodaj error boundary w React i loguj błędy, których nie łapie

Error boundary w React łapie błędy podczas renderu i pokazuje fallback. Oto klasa, błędy, których nie łapie, i wysyłanie każdego z nich do LogBrew, przetestowane na React 19.3.

Przetestowane 21 listopada 2026 z użyciem React 19.3.1, Vite 8.3.8, Chrome 156, @logbrew/react 0.1.6, @logbrew/sdk 0.1.47 i logbrew CLI 0.1.96

Autor [Furkan Erday](https://github.com/furkanerday). Furkan Erday jest założycielem LogBrew. Codziennie rozwija LogBrew z pomocą Claude Code i Codex.

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

## Które błędy React pokazują fallback i trafiają do LogBrew

| Gdzie zgłoszono błąd | Pokazany fallback | Problem w LogBrew |
| --- | --- | --- |
| Render wewnątrz `LogBrewErrorBoundary` | Tak | Tak |
| `useEffect` wewnątrz boundary | Tak | Tak |
| Render bez boundary | Nie, pusty root | Tak, z opcji roota |
| Handler `onClick` | Nie | Nie |
| Handler async, po `await` | Nie | Nie |
| `onClick` z `captureReactError()` | Nie | Tak |

6 błędów w 1 buildzie produkcyjnym Vite z React 19.3.1 i @logbrew/react 0.1.6.

## Napisz error boundary

### Napisz boundary jako komponent klasowy

React nie ma do tego hooka, więc error boundary jest klasą. `getDerivedStateFromError` przełącza go na fallback przy następnym renderze. `componentDidCatch` dostaje błąd i `info.componentStack`, czyli listę komponentów nad tym, który zgłosił błąd.

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

### Otocz część strony, która może zawieść

`TapList` czyta `taps.map`, gdy brakuje `taps`, więc zgłasza błąd podczas renderu. Boundary pokazał `Could not load the taps.`, a nagłówek `Taproom` został. W trybie deweloperskim React wypisał też błąd z `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>
  );
}
```

Wynik

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

### Błąd w handlerze zdarzeń omija boundary

React wywołuje `onClick` poza renderem, więc boundary nigdy nie dostał błędu. Przycisk został na stronie, a przeglądarka wypisała nieprzechwycony błąd. Błąd po `await` zachował się tak samo.

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

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

Wynik

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

### Przekaż błąd handlera do boundary przez stan

Przechwyć błąd w handlerze, zapisz go przez `setError` i zgłoś go przy następnym renderze. Wtedy boundary pokazuje swój fallback i dostaje błąd w `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>;
}
```

Wynik

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

### Bez boundary React usuwa całe drzewo

Gdy żaden boundary nie złapie błędu renderu, React 19 odmontowuje root. Element `root` był pusty, a nagłówek też zniknął. React wypisał błąd i ostrzeżenie, które zaleca 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>
);
```

Wynik

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

## Wyślij błędy React do LogBrew

### Zainstaluj pakiety

`@logbrew/react` dodaje provider, error boundary i opcje roota. Użyj klucza przeglądarki ze swojego projektu LogBrew jako `clientKey`.

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

### Utwórz klienta i transport

Klient trzyma zdarzenia w kolejce, dopóki nie wywołasz `client.flush(transport)`. Transport musi zwrócić `{ statusCode }`. Gdy nasz zwrócił odpowiedź z `fetch`, flush nie powiódł się z `invalid transport response`. Ustaw `VITE_LOGBREW_ENDPOINT` na `https://api.logbrew.co/v1/events`. My wysyłaliśmy do lokalnego serwera LogBrew.

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

### Umieść LogBrewErrorBoundary wewnątrz LogBrewProvider

`LogBrewErrorBoundary` bierze klienta z `LogBrewProvider`. Bez providera pokazał fallback, ale nic nie wysłał, a `onCaptureError` dostał `captureReactError requires a client`. `onError` działa po przechwyceniu, więc tam wywołaj flush.

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

Wynik

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

### Łap błędy, których nie złapał żaden boundary

`createLogBrewReactRootOptions()` daje `createRoot` jego callbacki błędów. Zapisał błąd renderu bez boundary. Pomija błędy, które `LogBrewErrorBoundary` już wysłał, więc każdy błąd dociera 1 raz.

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

Wynik

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

### Zgłaszaj błędy handlerów przez captureReactError()

Błędu z handlera nie dostaje ani boundary, ani callback roota, więc przechwyć go i przekaż do `captureReactError()`. Przekazane `metadata` zostają przy problemie.

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

Wynik

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

### Odczytaj problemy

Odczytaliśmy projekt kluczem odczytu. Błąd renderu wewnątrz boundary i ten sam błąd bez boundary pochodziły z `TapList.jsx`, więc stały się 1 problemem z 2 wystąpieniami. Błąd z handlera stał się osobnym problemem.

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

Wynik

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

## Co zobaczyliśmy podczas testu

Zbudowaliśmy 1 aplikację Vite z React 19.3.1 i @logbrew/react 0.1.6 i uruchomiliśmy każdy przypadek w Chrome z lokalnym serwerem LogBrew. Wyniki powyżej pochodzą z serwera deweloperskiego Vite. Te same przypadki uruchomiliśmy w buildzie produkcyjnym i wyniki były takie same.

Tylko błędy podczas renderu i w `useEffect` dotarły do boundary. Błędy w `onClick` i po `await` nie dotarły ani do boundary, ani do callbacku roota. Wysłał je tylko `captureReactError()`.

|  | `LogBrewErrorBoundary` | `onUncaughtError` |
| --- | --- | --- |
| Błąd renderu wewnątrz boundary | Tak | Nie |
| Błąd renderu bez boundary | Nie | Tak |
| Błąd w handlerze zdarzeń | Nie | Nie |

## Zresetuj boundary i spróbuj ponownie

Fallback `LogBrewErrorBoundary` dostaje `resetError`, który ponownie renderuje dzieci. Jeśli dziecko znów zgłosi błąd, boundary znów pokaże fallback i wyśle 1 zdarzenie więcej.

Usuń więc przyczynę przed ponowną próbą, na przykład wczytaj dane jeszcze raz. W naszym teście ponowna próba wyrenderowała listę, gdy dane już były.

|  | Pokazany fallback | Wysłane zdarzenie |
| --- | --- | --- |
| Pierwszy błąd renderu | Tak | Tak |
| `Try Again`, dziecko znów zgłasza błąd | Tak | Tak |
| `Try Again`, dziecko się renderuje | Nie | Nie |

## Co zapisuje LogBrew

Każdy błąd React staje się problemem z tytułem `React error:` i komunikatem. Boundary zapisuje mechanizm `react.error_boundary` z `handled: true`. Opcje roota zapisują `react.uncaught_error` z `handled: false`.

LogBrew grupuje błędy React według typu błędu i pliku pierwszej ramki stosu. W naszym buildzie produkcyjnym 5 zdarzeń `Error` z różnymi komunikatami, na przykład `keg sensor offline` i `tap list not loaded`, pochodziło z 1 pliku bundla i stało się 1 problemem. W trybie deweloperskim każdy komponent jest osobnym plikiem, więc problemy zostały rozdzielone.

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

## Najczęściej zadawane pytania

### Czym jest error boundary w React?

To komponent klasowy z `getDerivedStateFromError` albo `componentDidCatch`. Gdy dziecko zgłosi błąd podczas renderu, React pokazuje fallback boundary i zachowuje resztę strony.

### Czy mogę napisać error boundary na hookach?

Nie. React nie ma do tego hooka, więc boundary jest klasą. Napisz go 1 raz albo użyj `LogBrewErrorBoundary` i otocz nim komponenty funkcyjne.

### Dlaczego mój error boundary nie łapie błędu?

Błąd został zgłoszony poza renderem, często w handlerze zdarzeń albo po `await`. Przechwyć go tam i zgłoś przez `captureReactError()` albo zapisz go w stanie i zgłoś podczas renderu.

### Gdzie umieszczać error boundary?

Wokół każdej części strony, która może zawieść osobno, na przykład listy, która wczytuje dane, żeby reszta strony została. Umieść też 1 blisko roota, bo błąd, którego nie złapie żaden boundary, usuwa całe drzewo.

### Jak logować błędy z error boundary?

Wysyłaj je z `componentDidCatch` albo użyj `LogBrewErrorBoundary` wewnątrz `LogBrewProvider`. Dodaj `createLogBrewReactRootOptions()` do `createRoot` dla błędów, których nie złapał żaden boundary.

## Zobacz każdy błąd React razem ze stosem komponentów

LogBrew zapisuje każdy błąd renderu React ze stosem komponentów i grupuje powtórzenia w 1 problem. Zacznij od hojnego darmowego planu, bez karty.

[Zacznij za darmo](https://logbrew.co/pl)

## Źródła

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

## Więcej przewodników po agentach, Pythonie, Node.js i React

- [Dodaj serwer MCP do Claude Code i Codex](https://logbrew.co/pl/guides/mcp-server-claude-code-codex)
- [Jak używać AGENTS.md w Claude Code i Codex](https://logbrew.co/pl/guides/agents-md)
- [Napraw błąd Claude 529 overloaded i błąd 429 rate limit](https://logbrew.co/pl/guides/claude-overloaded-rate-limit-error)
- [Skonfiguruj moduł Python logging z właściwymi poziomami i przechwytywaniem wyjątków](https://logbrew.co/pl/guides/python-logging)
- [Logowanie strukturalne z formatem logów i poziomami, które przeszukasz po polu](https://logbrew.co/pl/guides/structured-logging)
- [Skonfiguruj logowanie w Node.js z Pino lub Winston i nie zgub żadnego błędu](https://logbrew.co/pl/guides/node-logging)
- [Skonfiguruj logowanie w Django i zachowaj ślad stosu każdego błędu 500](https://logbrew.co/pl/guides/django-logging)
- [Skonfiguruj logowanie w FastAPI i obsłuż błędy bez utraty śladu stosu](https://logbrew.co/pl/guides/fastapi-logging)
- [ID śladu a ID spanu, rozłożone na prawdziwym nagłówku traceparent](https://logbrew.co/pl/guides/trace-id)
- [Napraw Minified React error #418 i #185 z pełnego komunikatu i własnego wiersza kodu](https://logbrew.co/pl/errors/minified-react-error)
- [Przewodniki po błędach, logach, śladach, metrykach i wydaniach](https://logbrew.co/pl/guides)
