> ## Documentation Index
> Fetch the complete documentation index at: https://docs.appsignal.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Frontend-Fehlererfassung

Um einen Fehler an AppSignal zu melden, fangen Sie den Fehler ab und übergeben Sie ihn an die Hilfsfunktion `sendError`.

Wenn Sie TypeScript verwenden, muss das Argument der Hilfsfunktion `sendError` eine Instanz von `Error` oder `ErrorEvent` sein. Das liegt daran, dass in TypeScript ab Version 4.4 abgefangene Variablen im Strict-Modus standardmäßig vom Typ `unknown` sind.

<CodeGroup>
  ```javascript JavaScript theme={null}
  try {
    // do something that might throw an error
  } catch (error) {
    if (error instanceof Error || error instanceof ErrorEvent) {
      appsignal.sendError(error)
      // handle the error
    }
  }

  // You can catch errors asynchronously by listening to Promises...
  asyncActionThatReturnsAPromise().catch(error => appsignal.sendError(error))

  // ...or by using async/await
  async function() {
    try {
      const result = await asyncActionThatReturnsAPromise()
    } catch (error) {
      if (error instanceof Error || error instanceof ErrorEvent) {
        appsignal.sendError(error)
        // handle the error
      }

    }
  }

  // ...or in an event handler or callback function
  events.on("event", (err) => { appsignal.sendError(err) })
  ```
</CodeGroup>

## Metadaten zu Fehlern hinzufügen

Um zusätzliche Metadaten zu Fehlern hinzuzufügen, die mit `sendError` gesendet werden, verwenden Sie das Callback-Funktionsargument. Dieser Callback erhält den aktuellen Span für den Fehler als Argument und ermöglicht es, ihn vor dem Senden an die AppSignal-Server zu ändern.

Weitere Informationen zu allen Daten, die auf einem Span gesetzt werden können, finden Sie auf der [Span-API-Seite][span api].

<CodeGroup>
  ```javascript JavaScript theme={null}
  try {
    // do something that might throw an error
  } catch (error) {
    appsignal.sendError(error, (span) => {
      span.setAction("MyCustomAction");
      span.setNamespace("custom_namespace");
      span.setTags({ tag1: "value 1", tag2: "value 2" });
    });
    // handle the error
  }
  ```
</CodeGroup>

## Nicht abgefangene Ausnahmen

Nicht abgefangene Ausnahmen werden standardmäßig **nicht** erfasst. Wir haben uns entschieden, diese Funktionalität nicht in die Kernbibliothek aufzunehmen, da Browser-Erweiterungen, Werbeblocker usw. ein hohes Maß an Rauschen erzeugen, was Bibliotheken wie diese im Allgemeinen weniger effektiv macht.

Wir empfehlen die Verwendung einer passenden [Integration](/front-end/integrations/) als bessere Möglichkeit zur Behandlung von Ausnahmen. Falls Sie nicht abgefangene Ausnahmen dennoch erfassen *möchten*, können Sie dies tun, indem Sie das Paket [`@appsignal/plugin-window-events`](/front-end/plugins/plugin-window-events) zusammen mit diesem verwenden.

## Einen Codeblock umschließen

Die Bibliothek stellt eine praktische Methode zur Verfügung, um einen Codeblock zu umschließen und alle darin geworfenen Fehler direkt an AppSignal zu senden. Dies ist die Methode `appsignal.wrap()`, eine asynchrone Funktion, die ein `Promise` zurückgibt. Als Argument sollte eine Funktion übergeben werden, die den Code enthält, den Sie umschließen möchten.

<CodeGroup>
  ```javascript JavaScript theme={null}
  try {
    await appsignal.wrap(() => {
      // catch any error from sync or async code here
    });
  } catch (e) {
    // do something else with the error here, the
    // error has already been sent to AppSignal
  }

  // Alternative usage
  appsignal
    .wrap(() => {
      // catch any error from sync or async code here
    })
    .catch((e) => {
      // do something else with the error here, the
      // error has already been sent to AppSignal
    });
  ```
</CodeGroup>

Wenn irgendwo in dieser Funktion ein Fehler ausgelöst wird, geben wir ein abgelehntes Promise zurück, wobei der `Error` als Argument an den `catch`-Handler übergeben wird.

### Metadaten zu umschlossenen Fehlern hinzufügen

Um zusätzliche Metadaten zu Fehlern hinzuzufügen, die mit `wrap` erfasst und gesendet werden, verwenden Sie das Callback-Funktionsargument. Dieser Callback erhält den aktuellen Span für den Fehler als Argument und ermöglicht es, ihn vor dem Senden an die AppSignal-Server zu ändern.

Weitere Informationen zu allen Daten, die auf einem Span gesetzt werden können, finden Sie auf der [Span-API-Seite][span api].

<CodeGroup>
  ```javascript JavaScript theme={null}
  appsignal.wrap(
    () => {
      throw new Error("Test error");
    },
    (span) => {
      span.setAction("MyCustomAction");
      span.setNamespace("custom_namespace");
      span.setTags({ tag1: "value 1", tag2: "value 2" });
    },
  );
  ```
</CodeGroup>

## GraphQL-Fehler

Wenn Sie den `urql`-GraphQL-Client verwenden, lesen Sie bitte die [`@appsignal/urql`-Dokumentation](/front-end/integrations/urql) für Anweisungen zum Einrichten der Fehlerberichterstattung aus GraphQL.

[span api]: /front-end/span.html