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

# Gestion des exceptions

Dans la plupart des applications, certaines erreurs seront levées qui ne sont pas liées à
d'éventuels bugs dans votre code, elles surviennent simplement lorsque votre application entre en contact
avec le monde réel. Des bots peuvent passer et tenter de poster automatiquement des formulaires,
des liens obsolètes peuvent diriger les visiteurs vers du contenu qui n'existe plus,
et ainsi de suite.

Pour éviter que ces erreurs ne soient signalées comme des problèmes dans AppSignal, il est possible
d'ajouter de la gestion d'exceptions à votre code ou même de laisser AppSignal ignorer complètement
certaines erreurs.

## Ignorer les erreurs

La configuration AppSignal permet d'[ignorer
les erreurs](/guides/filter-data/ignore-errors). En fournissant une liste
d'erreurs spécifiques, AppSignal n'enverra pas d'alertes lorsque ces erreurs sont levées.

## Appsignal.set\_error/3

Si vous voulez rescue des exceptions dans votre application pour éviter les crashs, mais
que vous voulez quand même suivre l'occurrence, vous pouvez utiliser
[`Appsignal.set_error/2`][hexdocs-set_error-2] pour ajouter l'exception à la
transaction AppSignal courante :

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

### Erlang

L'intégration AppSignal fait de son mieux pour convertir les erreurs levées par Erlang en exceptions Elixir. Par exemple, un `:badarg`
levé depuis Erlang est automatiquement converti en `ArgumentError`. Cependant, parfois le mieux qu'elle puisse faire est d'envelopper l'erreur provenant d'Erlang dans un `ErlangError`.

Comme celles-ci ne donnent pas beaucoup d'éclairage sur le problème sous-jacent, nous recommandons d'ajouter des informations depuis votre application en attrapant l'erreur, en créant vous-même une exception Elixir et en l'ajoutant au span courant à l'aide de la fonction `set_error/2`.

<Warning>
  **NOTE :** `Appsignal.set_error/2` a été ajoutée dans AppSignal pour Elixir 2.1.0. Si
  vous êtes sur une version inférieure, utilisez `Appsignal.set_error/3` à la place.
</Warning>

Sur les versions antérieures à 2.1.0, utilisez `catch` et `Appsignal.send_error/3` :

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

L'exception sera suivie par AppSignal comme toute autre erreur, et cela vous permet
de fournir une gestion d'erreur personnalisée et des solutions de repli.

Si vous n'avez pas d'objet d'erreur lors de l'appel à `send_error`, mais que vous voulez quand même signaler la situation comme une erreur, il est également possible d'initialiser une struct d'erreur personnalisée.

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

**Remarque :** Cette fonction ne fonctionne que lorsqu'une transaction AppSignal est active.
Sinon, l'erreur sera ignorée.

Veuillez consulter
[`Appsignal.send_error/3`](#appsignalsend_error3) pour envoyer des erreurs
sans transaction AppSignal.

## Appsignal.send\_error/3

AppSignal fournit un mécanisme pour suivre les erreurs qui surviennent dans du code qui n'est pas dans
un contexte web ou de job en arrière-plan, comme les tâches Mix. C'est utile pour
l'instrumentation qui ne crée pas automatiquement de transactions AppSignal à
profiler.

Vous pouvez utiliser la fonction [`Appsignal.send_error/3`][hexdocs-send_error] pour
envoyer directement une exception à AppSignal depuis n'importe quel endroit de votre code sans
démarrer d'abord une transaction AppSignal.

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

Si vous n'avez pas d'objet d'erreur lors de l'appel à `send_error`, mais que vous voulez quand même signaler la situation comme une erreur, il est également possible d'initialiser une struct d'erreur personnalisée.

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

### Métadonnées supplémentaires

Pour ajouter des métadonnées à l'erreur envoyée, passez une fonction comme quatrième argument à
`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>
  **NOTE :** `Appsignal.send_error/4` a été ajoutée dans AppSignal pour 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