---
title: "Ajoutez un périmètre d’erreur React et loggez les erreurs qu’il laisse passer"
description: "Un périmètre d’erreur React capture les erreurs pendant le rendu et affiche un fallback. Voici la classe, les erreurs qu’il laisse passer et l’envoi de chacune à LogBrew, testés sur React 19.3."
canonical: "https://logbrew.co/fr/guides/react-error-boundary"
last_updated: "2026-11-21"
---

# Ajoutez un périmètre d’erreur React et loggez les erreurs qu’il laisse passer

Un périmètre d’erreur React capture les erreurs pendant le rendu et affiche un fallback. Voici la classe, les erreurs qu’il laisse passer et l’envoi de chacune à LogBrew, testés sur React 19.3.

Testé le 21 novembre 2026 avec React 19.3.1, Vite 8.3.8, Chrome 156, @logbrew/react 0.1.6, @logbrew/sdk 0.1.47 et logbrew CLI 0.1.96

Par [Furkan Erday](https://github.com/furkanerday). Furkan Erday est le fondateur de LogBrew. Il développe LogBrew avec Claude Code et Codex tous les jours.

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

## Quelles erreurs React affichent un fallback et arrivent dans LogBrew

| Où l’erreur a été levée | Fallback affiché | Problème dans LogBrew |
| --- | --- | --- |
| Rendu, dans `LogBrewErrorBoundary` | Oui | Oui |
| `useEffect`, dans le périmètre | Oui | Oui |
| Rendu, sans périmètre | Non, racine vide | Oui, par les options de racine |
| Gestionnaire `onClick` | Non | Non |
| Gestionnaire async, après `await` | Non | Non |
| `onClick` avec `captureReactError()` | Non | Oui |

6 erreurs dans 1 build de production Vite avec React 19.3.1 et @logbrew/react 0.1.6.

## Écrire un périmètre d’erreur

### Écrivez le périmètre comme un composant de classe

React n’a pas de hook pour cela, donc un périmètre d’erreur est une classe. `getDerivedStateFromError` le fait passer au fallback au rendu suivant. `componentDidCatch` reçoit l’erreur et `info.componentStack`, la liste des composants au-dessus de celui qui a levé l’erreur.

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

### Entourez la partie de la page qui peut échouer

`TapList` lit `taps.map` quand `taps` manque, donc il lève une erreur pendant le rendu. Le périmètre a affiché `Could not load the taps.`, et le titre `Taproom` est resté. En développement, React a aussi écrit l’erreur avec `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>
  );
}
```

Sortie

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

### Une erreur dans un gestionnaire d’événement échappe au périmètre

React appelle `onClick` hors du rendu, donc le périmètre n’a jamais reçu l’erreur. Le bouton est resté sur la page, et le navigateur a écrit une erreur non capturée. Une erreur après `await` a fait de même.

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

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

Sortie

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

### Passez une erreur de gestionnaire au périmètre par le state

Capturez l’erreur dans le gestionnaire, stockez-la avec `setError`, puis levez-la au rendu suivant. Le périmètre affiche alors son fallback et reçoit l’erreur dans `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>;
}
```

Sortie

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

### Sans périmètre, React retire tout l’arbre

Quand aucun périmètre ne capture une erreur de rendu, React 19 démonte la racine. L’élément `root` était vide, et le titre avait disparu aussi. React a écrit l’erreur et un avertissement qui demande un périmètre d’erreur.

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

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

Sortie

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

## Envoyer les erreurs React à LogBrew

### Installez les paquets

`@logbrew/react` ajoute le provider, le périmètre d’erreur et les options de racine. Utilisez une clé navigateur de votre projet LogBrew comme `clientKey`.

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

### Créez le client et un transport

Le client garde les événements dans une file jusqu’à l’appel de `client.flush(transport)`. Le transport doit renvoyer `{ statusCode }`. Quand le nôtre a renvoyé la réponse de `fetch`, le flush a échoué avec `invalid transport response`. Réglez `VITE_LOGBREW_ENDPOINT` sur `https://api.logbrew.co/v1/events`. Nous avons envoyé vers un serveur LogBrew local.

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

### Placez LogBrewErrorBoundary dans LogBrewProvider

`LogBrewErrorBoundary` prend le client dans `LogBrewProvider`. Sans provider, il a affiché le fallback mais n’a rien envoyé, et `onCaptureError` a reçu `captureReactError requires a client`. `onError` s’exécute après la capture, donc faites le flush à cet endroit.

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

Sortie

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

### Capturez les erreurs qu’aucun périmètre n’a capturées

`createLogBrewReactRootOptions()` donne à `createRoot` ses callbacks d’erreur. Elle a enregistré l’erreur de rendu sans périmètre. Elle ignore les erreurs que `LogBrewErrorBoundary` a déjà envoyées, donc chaque erreur arrive 1 seule fois.

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

Sortie

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

### Signalez les erreurs de gestionnaire avec captureReactError()

Ni un périmètre ni un callback de racine ne reçoit une erreur venue d’un gestionnaire, donc capturez-la et passez-la à `captureReactError()`. Les `metadata` que vous passez restent sur le problème.

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

Sortie

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

### Relisez les problèmes

Nous avons lu le projet avec une clé de lecture. L’erreur de rendu dans le périmètre et la même erreur sans périmètre venaient toutes deux de `TapList.jsx`, donc elles sont devenues 1 problème avec 2 occurrences. L’erreur du gestionnaire est devenue un problème à part.

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

Sortie

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

## Ce que nous avons constaté en testant

Nous avons créé 1 application Vite avec React 19.3.1 et @logbrew/react 0.1.6, et lancé chaque cas dans Chrome avec un serveur LogBrew local. Les sorties ci-dessus viennent du serveur de dev Vite. Nous avons lancé les mêmes cas dans un build de production, avec les mêmes résultats.

Seules les erreurs pendant le rendu et dans `useEffect` ont atteint un périmètre. Les erreurs dans `onClick` et après `await` n’ont atteint ni périmètre ni callback de racine. Seul `captureReactError()` les a envoyées.

|  | `LogBrewErrorBoundary` | `onUncaughtError` |
| --- | --- | --- |
| Erreur de rendu dans le périmètre | Oui | Non |
| Erreur de rendu sans périmètre | Non | Oui |
| Erreur dans un gestionnaire d’événement | Non | Non |

## Réinitialiser le périmètre et réessayer

Le fallback de `LogBrewErrorBoundary` reçoit `resetError`, qui refait le rendu des enfants. Si l’enfant lève de nouveau une erreur, le périmètre affiche de nouveau le fallback et envoie 1 événement de plus.

Corrigez donc la cause avant de réessayer, par exemple rechargez les données. Dans notre test, le nouvel essai a affiché la liste quand les données étaient là.

|  | Fallback affiché | Événement envoyé |
| --- | --- | --- |
| Première erreur de rendu | Oui | Oui |
| `Try Again`, l’enfant échoue encore | Oui | Oui |
| `Try Again`, l’enfant s’affiche | Non | Non |

## Ce que LogBrew enregistre

Chaque erreur React devient un problème intitulé `React error:` suivi de son message. Le périmètre enregistre le mécanisme `react.error_boundary` avec `handled: true`. Les options de racine enregistrent `react.uncaught_error` avec `handled: false`.

LogBrew regroupe les erreurs React par type d’erreur et par fichier de la première frame de pile. Dans notre build de production, 5 événements `Error` aux messages différents, comme `keg sensor offline` et `tap list not loaded`, venaient de 1 fichier de bundle et sont devenus 1 problème. En développement, chaque composant est un fichier à part, donc les problèmes sont restés séparés.

- `LogBrewErrorBoundary`
  - `mechanism`: `react.error_boundary`
  - `handled`: `true`
  - Problème: `React error: Cannot read properties of undefined (reading 'map')`
- `createLogBrewReactRootOptions()`
  - `mechanism`: `react.uncaught_error`
  - `handled`: `false`
  - Frames de stack trace: 10
- `captureReactError()`
  - Problème: `React error: payment declined`
  - `metadata.action`: `pay`
  - Clé de regroupement: `react.error:Error:…/HandlerButton.jsx`

## Questions fréquentes

### Qu’est-ce qu’un périmètre d’erreur dans React ?

Un composant de classe avec `getDerivedStateFromError` ou `componentDidCatch`. Quand un enfant lève une erreur pendant le rendu, React affiche le fallback du périmètre et garde le reste de la page.

### Peut-on écrire un périmètre d’erreur avec des hooks ?

Non. React n’a pas de hook pour cela, donc le périmètre est une classe. Écrivez-le 1 fois, ou utilisez `LogBrewErrorBoundary`, et placez-le autour des composants fonctions.

### Pourquoi mon périmètre d’erreur ne capture-t-il pas l’erreur ?

L’erreur a été levée hors du rendu, souvent dans un gestionnaire d’événement ou après `await`. Capturez-la à cet endroit et signalez-la avec `captureReactError()`, ou stockez-la dans le state et levez-la pendant le rendu.

### Où placer les périmètres d’erreur ?

Autour de chaque partie de la page qui peut échouer seule, comme une liste qui charge des données, pour que le reste de la page reste. Placez-en aussi 1 près de la racine, car une erreur qu’aucun périmètre ne capture retire tout l’arbre.

### Comment logger les erreurs d’un périmètre d’erreur ?

Envoyez-les depuis `componentDidCatch`, ou utilisez `LogBrewErrorBoundary` dans `LogBrewProvider`. Ajoutez `createLogBrewReactRootOptions()` à `createRoot` pour les erreurs qu’aucun périmètre n’a capturées.

## Voyez chaque erreur React avec sa pile de composants

LogBrew enregistre chaque erreur de rendu React avec sa pile de composants et regroupe les répétitions en 1 problème. Commencez avec le forfait Free généreux, sans carte bancaire.

[Commencer gratuitement](https://logbrew.co/fr)

## Sources

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

## Autres guides pour les agents, Python, Node.js et React

- [Ajouter un serveur MCP à Claude Code et Codex](https://logbrew.co/fr/guides/mcp-server-claude-code-codex)
- [Utiliser AGENTS.md dans Claude Code et Codex](https://logbrew.co/fr/guides/agents-md)
- [Corriger l’erreur Claude overloaded 529 et l’erreur rate limit 429](https://logbrew.co/fr/guides/claude-overloaded-rate-limit-error)
- [Configurer le module Python logging avec les bons niveaux de log et la capture des exceptions](https://logbrew.co/fr/guides/python-logging)
- [Structured logging avec un format de log et des niveaux que vous cherchez par champ](https://logbrew.co/fr/guides/structured-logging)
- [Configurer le logging Node.js avec Pino ou Winston sans perdre une seule erreur](https://logbrew.co/fr/guides/node-logging)
- [Configurez le logging Django et gardez la stack trace de chaque erreur 500](https://logbrew.co/fr/guides/django-logging)
- [Configurez le logging FastAPI et gérez les erreurs sans perdre la stack trace](https://logbrew.co/fr/guides/fastapi-logging)
- [Trace ID vs span ID, décodés depuis un vrai en-tête traceparent](https://logbrew.co/fr/guides/trace-id)
- [Corriger l’erreur Minified React #418 et #185 avec le message complet et votre ligne de code](https://logbrew.co/fr/errors/minified-react-error)
- [Guides sur les erreurs, logs, traces, métriques et versions](https://logbrew.co/fr/guides)
