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

# Einen Span erstellen und verwenden

Ein `Span` ist der Name des Objekts, das wir verwenden, um Daten über einen Fehler und seinen umgebenden Kontext zu erfassen. Er ist so gestaltet, dass er dem Span aus der [OpenTelemetry](https://github.com/open-telemetry/opentelemetry-specification)-Standardspezifikation ähnelt, aber nicht exakt mit ihm übereinstimmt.

## Einen neuen `Span` erstellen

Ein `Span` kann durch den Aufruf von `appsignal.createSpan()` erstellt werden, wodurch ein neues `Span`-Objekt mit allen Standardoptionen initialisiert wird, die Sie bei der Initialisierung des `Appsignal`-Objekts übergeben haben.

<CodeGroup>
  ```js JavaScript theme={null}
  const span = appsignal.createSpan();
  ```
</CodeGroup>

Die Methode `createSpan()` kann auch eine Funktion als Parameter annehmen, sodass Sie die Daten des `Span` gleichzeitig mit dessen Erstellung definieren können.

<CodeGroup>
  ```js JavaScript theme={null}
  const span = appsignal.createSpan((span) => {
    return span.setTags({
      tag: "value",
    });
  });
  ```
</CodeGroup>

`Span`s können nicht verschachtelt werden, und es können auch nicht mehrere `Span`s gleichzeitig an `appsignal.send()` übergeben werden. Wir empfehlen die Verwendung von `Promise.all` für gleichzeitige `send`-Vorgänge.

<CodeGroup>
  ```js JavaScript theme={null}
  const span1 = appsignal.createSpan();
  const span2 = appsignal.createSpan();

  Promise.all([appsignal.send(span1), appsignal.send(span2)]);
  ```
</CodeGroup>

## Einen `Span` aktualisieren

Nachdem ein `Span` erstellt wurde, können Sie ihm mithilfe von Methoden des `Span`-Objekts Daten hinzufügen:

<CodeGroup>
  ```js JavaScript theme={null}
  const span = appsignal.createSpan();
  span.setTags({ tag: "value" });

  console.log(span.serialize().tags); // { tag: "value" }
  ```
</CodeGroup>

Jede Methode, die den `Span` ändert, gibt `this` zurück, sodass Sie Methoden verketten können:

<CodeGroup>
  ```js JavaScript theme={null}
  const span = appsignal.createSpan();

  span.setTags({ tag: "value" }).setError(new Error("test error"));

  console.log(span.serialize().tags); // { tag: "value" }
  console.log(span.serialize().error); // { name: "Error", message: "test error", backtrace: [...] }
  ```
</CodeGroup>

### `span.setAction(name: string)`

Setzt die `action` des aktuellen `Span`. Die `action` darf niemals ein leerer String sein – sie kann entweder `undefined` oder ein nicht leerer String sein. Ein Action-Name wird verwendet, um den Ort einer bestimmten Stichprobe von Fehlern und Performance-Problemen zu identifizieren.

### `span.setNamespace(name: string)`

Setzt den `namespace` des aktuellen `Span`. Namespaces sind eine Möglichkeit, Fehler-Incidents, Performance-Incidents und Host-Metriken in Ihrer App zu gruppieren.

### `span.setError(error: Error | object)`

Setzt den `error` des aktuellen `Span`. Das `Error`-Objekt hat eine Eigenschaft `name`, `message` und `backtrace`. Achten Sie darauf, als `name` nur etwas zu verwenden, das den Fehlertyp beschreibt. AppSignal gruppiert die Fehler anhand dieses Namens. In die `message` können Sie alles aufnehmen, was Sie möchten.

Wenn ein `Error`-Objekt an die Methode `setError` übergeben wird, wird die `stack`-Eigenschaft normalisiert und in ein Array von Strings transformiert, wobei jeder String eine Zeile im Stacktrace darstellt. Für Konsistenz mit unseren anderen Integrationen wird `stack` in `backtrace` umbenannt.

### `span.setTags(tags: object)`

Fügt dem aktuellen `Span` `tags` hinzu. Die aktuellen `tags` werden mit dem als Parameter übergebenen `tags`-Objekt zusammengeführt.

### `span.setParams(params: object)`

Fügt dem aktuellen `Span` `params` hinzu. Die aktuellen `params` werden mit dem als Parameter übergebenen `params`-Objekt zusammengeführt.

<Warning>
  Wenn Sie eine Version vor 1.3.28 verwenden, darf das `params`-Objekt keine
  verschachtelten Objekte enthalten.
</Warning>

### `span.serialize()`

Gibt den Inhalt eines `Span` als Objekt zurück.

## Einen `Span` an AppSignal senden

Wenn Sie mit dem Hinzufügen von Daten zum `Span` fertig sind, kann er an `appsignal.send()` übergeben werden, um an unsere API gesendet zu werden.

<CodeGroup>
  ```js JavaScript theme={null}
  const span = appsignal.createSpan((span) => {
    return span.setError(new Error("test error"));
  });

  appsignal.send(span);
  ```
</CodeGroup>

Die Methode `send()` unterscheidet sich von der Methode `sendError()`, da sie es ermöglicht, einen `Span` als Parameter zu übergeben, der entweder sofort an die API gesendet oder bei einem Netzwerkfehler der Warteschlange hinzugefügt wird, um später erneut versucht zu werden.

Sobald der `Span` an `appsignal.send()` übergeben wurde, werden alle [Hooks](/front-end/hooks) in der folgenden Reihenfolge auf den `Span` angewendet:

* Decorators
* Optionale `tags`- oder `namespace`-Argumente an `appsignal.send()`
* Overrides

### Über die Wiederholungs-Warteschlange

Wenn aus irgendeinem Grund das Pushen eines Fehlers an die API fehlschlägt (z. B. wenn die Netzwerkverbindung nicht funktioniert), wird das `Span`-Objekt, zu dem er gehört, in die Wiederholungs-Warteschlange gestellt. Standardmäßig werden Anfragen **5 Mal** mit exponentiellem Backoff wiederholt. Wenn die Anfrage erfolgreich ist, wird der entsprechende `Span` aus der Warteschlange entfernt. Sobald das Wiederholungslimit erreicht ist, werden alle in der Warteschlange verbleibenden `Span`s verworfen.

<Warning>
  Für die Wiederholungs-Warteschlange ist derzeit kein Caching implementiert,
  was bedeutet, dass ein `Span`, der sich in der Warteschlange befindet, wenn der Benutzer
  von Ihrer Anwendung wegnavigiert, ebenfalls verworfen wird.
</Warning>