---
title: "Añade un error boundary de React y registra los errores que se le escapan"
description: "Un error boundary de React captura los errores durante el render y muestra un fallback. Aquí tienes la clase, los errores que se le escapan y cómo enviar cada uno a LogBrew, probado en React 19.3."
canonical: "https://logbrew.co/es/guides/react-error-boundary"
last_updated: "2026-11-21"
---

# Añade un error boundary de React y registra los errores que se le escapan

Un error boundary de React captura los errores durante el render y muestra un fallback. Aquí tienes la clase, los errores que se le escapan y cómo enviar cada uno a LogBrew, probado en React 19.3.

Probado el 21 de noviembre de 2026 con React 19.3.1, Vite 8.3.8, Chrome 156, @logbrew/react 0.1.6, @logbrew/sdk 0.1.47 y logbrew CLI 0.1.96

Por [Furkan Erday](https://github.com/furkanerday). Furkan Erday es el fundador de LogBrew. Desarrolla LogBrew con Claude Code y Codex todos los días.

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

## Qué errores de React muestran un fallback y llegan a LogBrew

| Dónde se lanzó el error | Fallback mostrado | Incidencia en LogBrew |
| --- | --- | --- |
| Render, dentro de `LogBrewErrorBoundary` | Sí | Sí |
| `useEffect`, dentro del boundary | Sí | Sí |
| Render, sin boundary | No, raíz vacía | Sí, con las opciones de raíz |
| Manejador `onClick` | No | No |
| Manejador async, después de `await` | No | No |
| `onClick` con `captureReactError()` | No | Sí |

6 errores en 1 build de producción de Vite con React 19.3.1 y @logbrew/react 0.1.6.

## Escribe un error boundary

### Escribe el boundary como componente de clase

React no tiene un hook para esto, así que un error boundary es una clase. `getDerivedStateFromError` lo cambia al fallback en el siguiente render. `componentDidCatch` recibe el error e `info.componentStack`, la lista de componentes por encima del que lanzó el 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;
  }
}
```

### Envuelve la parte de la página que puede fallar

`TapList` lee `taps.map` cuando falta `taps`, así que lanza un error durante el render. El boundary mostró `Could not load the taps.`, y el título `Taproom` se mantuvo. En desarrollo, React también imprimió el error con `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>
  );
}
```

Salida

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

### Un error en un manejador de eventos se salta el boundary

React llama a `onClick` fuera del render, así que el boundary nunca recibió el error. El botón siguió en la página, y el navegador imprimió un error no capturado. Un error después de `await` hizo lo mismo.

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

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

Salida

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

### Pasa el error de un manejador al boundary mediante el estado

Captura el error en el manejador, guárdalo con `setError` y lánzalo en el siguiente render. Entonces el boundary muestra su fallback y recibe el error en `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>;
}
```

Salida

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

### Sin boundary, React quita todo el árbol

Cuando ningún boundary captura un error de render, React 19 desmonta la raíz. El elemento `root` quedó vacío, y el título también desapareció. React imprimió el error y un aviso que pide un 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>
);
```

Salida

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

## Envía los errores de React a LogBrew

### Instala los paquetes

`@logbrew/react` añade el provider, el error boundary y las opciones de raíz. Usa una clave de navegador de tu proyecto de LogBrew como `clientKey`.

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

### Crea el cliente y un transport

El cliente guarda los eventos en una cola hasta que llamas a `client.flush(transport)`. El transport debe devolver `{ statusCode }`. Cuando el nuestro devolvió la respuesta de `fetch`, el flush falló con `invalid transport response`. Define `VITE_LOGBREW_ENDPOINT` como `https://api.logbrew.co/v1/events`. Nosotros enviamos a un servidor local de 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)));
}
```

### Pon LogBrewErrorBoundary dentro de LogBrewProvider

`LogBrewErrorBoundary` toma el cliente de `LogBrewProvider`. Sin provider, mostró el fallback pero no envió nada, y `onCaptureError` recibió `captureReactError requires a client`. `onError` se ejecuta después de la captura, así que haz el flush ahí.

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

Salida

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

### Captura los errores que ningún boundary capturó

`createLogBrewReactRootOptions()` le da a `createRoot` sus callbacks de error. Registró el error de render sin boundary. Omite los errores que `LogBrewErrorBoundary` ya envió, así que cada error llega 1 sola vez.

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

Salida

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

### Reporta los errores de manejadores con captureReactError()

Ni un boundary ni un callback de la raíz reciben el error de un manejador, así que captúralo y pásalo a `captureReactError()`. Los `metadata` que pasas se quedan en la incidencia.

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

Salida

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

### Lee las incidencias

Leímos el proyecto con una clave de lectura. El error de render dentro del boundary y el mismo error sin boundary venían de `TapList.jsx`, así que se convirtieron en 1 incidencia con 2 ocurrencias. El error del manejador se convirtió en una incidencia aparte.

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

Salida

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

## Lo que vimos al probarlo

Creamos 1 app de Vite con React 19.3.1 y @logbrew/react 0.1.6, y ejecutamos cada caso en Chrome con un servidor local de LogBrew. Las salidas de arriba vienen del servidor de desarrollo de Vite. Ejecutamos los mismos casos en un build de producción y los resultados fueron los mismos.

Solo los errores durante el render y en `useEffect` llegaron a un boundary. Los errores en `onClick` y después de `await` no llegaron a ningún boundary ni a ningún callback de la raíz. Solo `captureReactError()` los envió.

|  | `LogBrewErrorBoundary` | `onUncaughtError` |
| --- | --- | --- |
| Error de render dentro del boundary | Sí | No |
| Error de render sin boundary | No | Sí |
| Error en un manejador de eventos | No | No |

## Reinicia el boundary y vuelve a intentarlo

El fallback de `LogBrewErrorBoundary` recibe `resetError`, que vuelve a renderizar los hijos. Si el hijo vuelve a lanzar el error, el boundary muestra otra vez el fallback y envía 1 evento más.

Así que corrige la causa antes de reintentar, por ejemplo vuelve a cargar los datos. En nuestra prueba, el reintento renderizó la lista cuando los datos estaban ahí.

|  | Fallback mostrado | Evento enviado |
| --- | --- | --- |
| Primer error de render | Sí | Sí |
| `Try Again`, el hijo vuelve a fallar | Sí | Sí |
| `Try Again`, el hijo se renderiza | No | No |

## Qué registra LogBrew

Cada error de React se convierte en una incidencia titulada `React error:` y su mensaje. El boundary registra el mecanismo `react.error_boundary` con `handled: true`. Las opciones de raíz registran `react.uncaught_error` con `handled: false`.

LogBrew agrupa los errores de React por tipo de error y por el archivo del primer frame de la pila. En nuestro build de producción, 5 eventos `Error` con mensajes distintos, como `keg sensor offline` y `tap list not loaded`, vinieron de 1 archivo del bundle y se convirtieron en 1 incidencia. En desarrollo, cada componente es un archivo propio, así que las incidencias quedaron separadas.

- `LogBrewErrorBoundary`
  - `mechanism`: `react.error_boundary`
  - `handled`: `true`
  - Incidencia: `React error: Cannot read properties of undefined (reading 'map')`
- `createLogBrewReactRootOptions()`
  - `mechanism`: `react.uncaught_error`
  - `handled`: `false`
  - Frames de pila: 10
- `captureReactError()`
  - Incidencia: `React error: payment declined`
  - `metadata.action`: `pay`
  - Clave de agrupación: `react.error:Error:…/HandlerButton.jsx`

## Preguntas frecuentes

### ¿Qué es un error boundary en React?

Un componente de clase con `getDerivedStateFromError` o `componentDidCatch`. Cuando un hijo lanza un error durante el render, React muestra el fallback del boundary y mantiene el resto de la página.

### ¿Puedo escribir un error boundary con hooks?

No. React no tiene un hook para esto, así que el boundary es una clase. Escríbelo 1 vez, o usa `LogBrewErrorBoundary`, y ponlo alrededor de los componentes de función.

### ¿Por qué mi error boundary no captura el error?

El error se lanzó fuera del render, a menudo en un manejador de eventos o después de `await`. Captúralo ahí y repórtalo con `captureReactError()`, o guárdalo en el estado y lánzalo durante el render.

### ¿Dónde pongo los error boundaries?

Alrededor de cada parte de la página que puede fallar por sí sola, como una lista que carga datos, para que el resto de la página se mantenga. Pon también 1 cerca de la raíz, porque un error que ningún boundary captura quita todo el árbol.

### ¿Cómo registro los errores de un error boundary?

Envíalos desde `componentDidCatch`, o usa `LogBrewErrorBoundary` dentro de `LogBrewProvider`. Añade `createLogBrewReactRootOptions()` a `createRoot` para los errores que ningún boundary capturó.

## Ve cada error de React con su pila de componentes

LogBrew registra cada error de render de React con su pila de componentes y agrupa las repeticiones en 1 incidencia. Empieza con el generoso plan gratuito, sin tarjeta.

[Empezar gratis](https://logbrew.co/es)

## Fuentes

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

## Más guías para agentes, Python, Node.js y React

- [Añade un servidor MCP a Claude Code y Codex](https://logbrew.co/es/guides/mcp-server-claude-code-codex)
- [Usa AGENTS.md en Claude Code y Codex](https://logbrew.co/es/guides/agents-md)
- [Soluciona el error 529 overloaded y el error 429 de rate limit en Claude](https://logbrew.co/es/guides/claude-overloaded-rate-limit-error)
- [Configura el módulo Python logging con los niveles de log correctos y captura de excepciones](https://logbrew.co/es/guides/python-logging)
- [Structured logging con un formato de log y niveles que puedes buscar por campo](https://logbrew.co/es/guides/structured-logging)
- [Configura el logging en Node.js con Pino o Winston sin perder ningún error](https://logbrew.co/es/guides/node-logging)
- [Configura el logging de Django y conserva la traza de pila de cada error 500](https://logbrew.co/es/guides/django-logging)
- [Configura el logging de FastAPI y maneja los errores sin perder la traza de pila](https://logbrew.co/es/guides/fastapi-logging)
- [Trace ID vs span ID, decodificados de una cabecera traceparent real](https://logbrew.co/es/guides/trace-id)
- [Corrige Minified React error #418 y #185 con el mensaje completo y tu línea de código](https://logbrew.co/es/errors/minified-react-error)
- [Guías de errores, logs, trazas, métricas y versiones](https://logbrew.co/es/guides)
