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

# Exception handling

In de meeste applicaties worden er fouten gegenereerd die niet gerelateerd zijn aan
mogelijke bugs in uw code; ze gebeuren gewoon wanneer uw app in contact komt
met de echte wereld. Bots kunnen langskomen en automatisch formulieren proberen te
posten, verouderde links kunnen bezoekers naar inhoud verwijzen die niet meer
bestaat enzovoort.

Om te voorkomen dat deze fouten als problemen in AppSignal worden weergegeven, is het mogelijk
om exception handling aan uw code toe te voegen of zelfs AppSignal bepaalde fouten
volledig te laten negeren.

## Fouten negeren

De AppSignal-configuratie maakt het mogelijk om [fouten te
negeren](/guides/filter-data/ignore-errors). Door een lijst met
specifieke fouten op te geven, stuurt AppSignal geen meldingen wanneer deze fouten optreden.

## Appsignal.set\_error/3

Als u uitzonderingen in uw applicatie wilt opvangen om crashes te voorkomen, maar
toch het optreden ervan wilt bijhouden, kunt u
[`Appsignal.set_error/2`][hexdocs-set_error-2] gebruiken om de uitzondering toe te voegen aan
de huidige AppSignal-transactie:

<CodeGroup>
  ```elixir Elixir theme={null}
  try do
    raise "Exception!"
  rescue
    exception -> Appsignal.set_error(exception, __STACKTRACE__)
  end
  ```
</CodeGroup>

### Erlang

De AppSignal-integratie doet zijn best om fouten die vanuit Erlang worden opgeworpen om te zetten in Elixir-uitzonderingen. Bijvoorbeeld: een `:badarg`
die vanuit Erlang wordt opgeworpen, wordt automatisch geconverteerd naar een `ArgumentError`. Echter, soms is het beste wat het kan doen het inpakken van de fout afkomstig uit Erlang in een `ErlangError`.

Aangezien deze niet veel inzicht geven in het onderliggende probleem, raden we aan om informatie toe te voegen vanuit uw applicatie door de fout op te vangen, zelf een Elixir-uitzondering te creëren en die toe te voegen aan de huidige span met de functie `set_error/2`.

<Warning>
  **OPMERKING:** `Appsignal.set_error/2` is toegevoegd in AppSignal voor Elixir 2.1.0. Als
  u een lagere versie gebruikt, gebruik dan `Appsignal.set_error/3` in plaats daarvan.
</Warning>

In versies vóór 2.1.0 gebruikt u `catch` en `Appsignal.send_error/3`:

<CodeGroup>
  ```elixir Elixir theme={null}
  try do
    raise "Exception!"
  catch
    kind, reason ->
      Appsignal.set_error(kind, reason, __STACKTRACE__)
  end
  ```
</CodeGroup>

De uitzondering wordt door AppSignal getraceerd zoals elke andere fout, en het stelt
u in staat om aangepaste foutafhandeling en fallbacks te bieden.

Als u geen foutobject heeft wanneer u `send_error` aanroept, maar het scenario toch als een fout wilt rapporteren, is het ook mogelijk om een aangepaste foutstruct te initialiseren.

<CodeGroup>
  ```elixir Elixir theme={null}
  defmodule MyCustomError do
    defexception message: "default message" # Customize if you call it without a custom message
  end

  case Worker.do_something() do
    :ok -> IO.puts "yay!"
    {:error, message} ->
      Appsignal.set_error(:error, %MyCustomError{ message: message }, [])
  end
  ```
</CodeGroup>

**Opmerking:** Deze functie werkt alleen wanneer er een AppSignal-transactie actief is.
Anders wordt de fout genegeerd.

Zie
[`Appsignal.send_error/3`](#appsignalsend_error3) voor het verzenden van fouten
zonder een AppSignal-transactie.

## Appsignal.send\_error/3

AppSignal biedt een mechanisme om fouten te traceren die optreden in code die zich niet in
een web- of background job-context bevindt, zoals Mix-taken. Dit is handig voor
instrumentatie die niet automatisch AppSignal-transacties aanmaakt om te
profileren.

U kunt de functie [`Appsignal.send_error/3`][hexdocs-send_error] gebruiken om
direct een uitzondering naar AppSignal te sturen vanuit elke plek in uw code zonder
eerst een AppSignal-transactie te starten.

<CodeGroup>
  ```elixir Elixir theme={null}
  try do
    raise "Exception!"
  catch
    kind, reason ->
      Appsignal.send_error(kind, reason, __STACKTRACE__)
  end
  ```
</CodeGroup>

Als u geen foutobject heeft wanneer u `send_error` aanroept, maar het scenario toch als een fout wilt rapporteren, is het ook mogelijk om een aangepaste foutstruct te initialiseren.

<CodeGroup>
  ```elixir Elixir theme={null}
  defmodule MyCustomError do
    defexception message: "default message" # Customize if you call it without a custom message
  end

  case Worker.do_something() do
    :ok -> IO.puts "yay!"
    {:error, message} ->
      Appsignal.send_error(:error, %MyCustomError{ message: message }, [])
  end
  ```
</CodeGroup>

### Aanvullende metadata

Om metadata aan de verzonden fout toe te voegen, geeft u een functie als vierde argument door aan
`Appsignal.send_errror/4`:

<CodeGroup>
  ```elixir Elixir theme={null}
  try do
    raise "Exception!"
  catch
    kind, reason ->
      Appsignal.send_error(kind, reason, __STACKTRACE__, fn span ->
        Appsignal.Span.set_attribute(span, "key", "value")
      end)
  end
  ```
</CodeGroup>

<Warning>
  **OPMERKING:** `Appsignal.send_error/4` is toegevoegd in AppSignal voor Elixir 2.1.0.
</Warning>

[hexdocs-set_error-2]: https://hexdocs.pm/appsignal/Appsignal.Instrumentation.html#set_error/2

[hexdocs-send_error]: https://hexdocs.pm/appsignal/Appsignal.Instrumentation.html#send_error/3