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

# Een Span maken en gebruiken

Een `Span` is de naam van het object dat we gebruiken om gegevens vast te leggen over een fout en de bijbehorende context. Het is ontworpen om vergelijkbaar te zijn met, maar niet precies gelijk aan, de Span uit de specificatiestandaard van [OpenTelemetry](https://github.com/open-telemetry/opentelemetry-specification).

## Een nieuwe `Span` aanmaken

Een `Span` kan worden aangemaakt door `appsignal.createSpan()` aan te roepen, wat een nieuw `Span`-object initialiseert met de standaardopties die u heeft meegegeven bij het initialiseren van het `Appsignal`-object.

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

De methode `createSpan()` kan ook een functie als parameter accepteren, waarmee u tegelijkertijd met het aanmaken van de `Span` de bijbehorende gegevens kunt definiëren.

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

`Span`'s kunnen niet worden genest, en er kunnen niet meerdere `Span`'s tegelijk aan `appsignal.send()` worden doorgegeven. We raden aan om `Promise.all` te gebruiken voor gelijktijdige `send`-bewerkingen.

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

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

## Een `Span` bijwerken

Nadat een `Span` is aangemaakt, kunt u er gegevens aan toevoegen met behulp van methoden op het `Span`-object:

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

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

Elke methode die de `Span` wijzigt, retourneert `this`, waardoor u methoden aan elkaar kunt koppelen:

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

Stelt de `action` van de huidige `Span` in. De `action` mag nooit een lege string zijn; deze kan ofwel `undefined` zijn ofwel een niet-lege string. Een actienaam wordt gebruikt om de locatie van een bepaald foutmonster en performance-probleem te identificeren.

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

Stelt de `namespace` van de huidige `Span` in. Namespaces zijn een manier om error-incidenten, performance-incidenten en host metrics in uw app te groeperen.

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

Stelt de `error` van de huidige `Span` in. Het `Error`-object heeft een `name`-, `message`- en `backtrace`-eigenschap. Zorg ervoor dat u als `name` alleen iets gebruikt dat het type van de fout beschrijft. AppSignal groepeert fouten op basis van deze naam. U kunt alles wat u wilt in de `message` opnemen.

Wanneer een `Error`-object aan de methode `setError` wordt doorgegeven, wordt de `stack`-eigenschap genormaliseerd en omgezet in een array van strings, waarbij elke string een regel in de stacktrace vertegenwoordigt. Voor consistentie met onze andere integraties wordt `stack` hernoemd naar `backtrace`.

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

Voegt `tags` toe aan de huidige `Span`. De huidige `tags` worden samengevoegd met het `tags`-object dat als parameter wordt doorgegeven.

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

Voegt `params` toe aan de huidige `Span`. De huidige `params` worden samengevoegd met het `params`-object dat als parameter wordt doorgegeven.

<Warning>
  Als u een versie vóór 1.3.28 gebruikt, mag het `params`-object geen geneste
  objecten bevatten.
</Warning>

### `span.serialize()`

Retourneert de inhoud van een `Span` als een object.

## Een `Span` naar AppSignal sturen

Wanneer u klaar bent met het toevoegen van gegevens aan de `Span`, kan deze aan `appsignal.send()` worden doorgegeven om naar onze API te worden gepusht.

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

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

De methode `send()` verschilt van de methode `sendError()` doordat er een `Span` als parameter kan worden doorgegeven die ofwel direct naar de API wordt gepusht ofwel, in het geval van een netwerkfout, aan de wachtrij wordt toegevoegd om later opnieuw te proberen.

Zodra de `Span` aan `appsignal.send()` is doorgegeven, worden eventuele [Hooks](/front-end/hooks) in de volgende volgorde op de `Span` toegepast:

* Decorators
* Optionele `tags`- of `namespace`-argumenten voor `appsignal.send()`
* Overrides

### Over de Retry Queue

Als om wat voor reden dan ook het pushen van een fout naar de API mislukt (bijvoorbeeld als de netwerkverbinding niet werkt), wordt het `Span`-object waartoe deze behoort in de retry queue geplaatst. Standaard worden verzoeken **5 keer** opnieuw geprobeerd met exponentiële backoff. Als het verzoek slaagt, wordt de bijbehorende `Span` uit de wachtrij verwijderd. Zodra de retry-limiet is bereikt, worden eventuele `Span`'s die nog in de wachtrij staan verwijderd.

<Warning>
  Er is momenteel geen caching geïmplementeerd voor de retry queue, wat
  betekent dat als een `Span` in de wachtrij staat op het moment dat de
  gebruiker uw applicatie verlaat, die `Span` ook wordt verwijderd.
</Warning>