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

# Intégrer AppSignal dans Phoenix

Le paquet AppSignal pour Elixir s'intègre à Phoenix. Pour mettre en place
l'intégration, veuillez suivre notre [guide d'installation](/elixir/installation).

Cette page décrira les autres façons de configurer AppSignal pour le [framework
Phoenix][phoenix]. Pour ajouter plus d'instrumentation personnalisée à votre application
Phoenix, lisez la documentation sur l'[instrumentation
Elixir](/elixir/instrumentation).

Vous trouverez plus d'informations dans la [documentation du paquet Hex
AppSignal][hex-appsignal].

## Installation

1. L'instrumentation AppSignal pour Phoenix fait partie d'un
   paquet séparé, qui dépend du paquet principal `appsignal`. Ajoutez le paquet `appsignal_phoenix` à votre fichier `mix.exs`.

<CodeGroup>
  ```elixir Elixir theme={null}
  # mix.exs
  defmodule AppsignalPhoenixExample.MixProject do
    # ...

    defp deps do
      [
        {:phoenix, "~> 1.5.3"},
        {:appsignal_phoenix, "~> 2.0"}
        # ...
      ]
    end
  end
  ```
</CodeGroup>

2. Puis exécutez `mix deps.get`.
3. Puis exécutez `mix appsignal.install YOUR_PUSH_API_KEY`.

Après installation et configuration, le paquet AppSignal pour Phoenix commence automatiquement à instrumenter les requêtes HTTP, ce qui signifie qu'aucune configuration supplémentaire n'est nécessaire.

Pour obtenir des informations plus approfondies, AppSignal peut être configuré pour instrumenter les canaux et les live views.

## Canaux

### Instrumentation de canal avec un handle de canal

Les requêtes de canal entrantes peuvent être instrumentées en enveloppant le code dans vos
fonctions `handle_in/3` avec `Appsignal.Phoenix.Channel.instrument/5` :

<CodeGroup>
  ```elixir Elixir theme={null}
  defmodule AppsignalPhoenixExampleWeb.RoomChannel do
    use Phoenix.Channel

    # ...

    def handle_in("new_msg", %{"body" => body} = params, socket) do
      Appsignal.Phoenix.Channel.instrument(__MODULE__, "new_msg", params, socket, fn ->
        broadcast!(socket, "new_msg", %{body: body})
        {:noreply, socket}
      end)
    end
  end
  ```
</CodeGroup>

Vous pouvez également utiliser les décorateurs de fonction pour instrumenter les canaux. Bien que
moins flexibles que la fonction d'instrumentation, les décorateurs minimisent la quantité
de code que vous devez ajouter aux canaux de votre application.

<CodeGroup>
  ```elixir Elixir theme={null}
  defmodule SomeApp.MyChannel do
    use Appsignal.Instrumentation.Decorators

    @decorate channel_action()
    def handle_in("ping", _payload, socket) do
      # your code here..
    end
  end
  ```
</CodeGroup>

Les événements de canal seront affichés dans l'onglet « Background jobs », montrant le
module du canal et l'argument d'action que vous avez saisi.

## LiveView

Il existe deux façons différentes d'instrumenter les live views. Vous pouvez soit utiliser nos
handlers de télémétrie automatiques, soit instrumenter manuellement vos handlers de live view
à l'aide de nos fonctions d'aide.

### Handlers de télémétrie automatiques

<Tip>
  **Remarque** : L'intégration LiveView Telemetry est disponible à partir d'AppSignal pour
  Phoenix version `2.1.0`.
</Tip>

L'intégration LiveView Telemetry d'AppSignal instrumente automatiquement les événements de live view.

Pour la mettre en place, appelez `Appsignal.Phoenix.LiveView.attach/0` pour attacher les handlers LiveView Telemetry.
Nous recommandons d'appeler cette fonction depuis le fichier `application.ex` de votre application :

<CodeGroup>
  ```elixir Elixir theme={null}
  defmodule AppsignalPhoenixExample.Application do
    # ...
    def start(_type, _args) do
      Appsignal.Phoenix.LiveView.attach() # <--- attach the LiveView Telemetry handlers
      children = [
        # Start the Ecto repository
        AppsignalPhoenixExample.Repo,
        # Start the Telemetry supervisor
        AppsignalPhoenixExampleWeb.Telemetry,
        # Start the PubSub system
        {Phoenix.PubSub, name: AppsignalPhoenixExample.PubSub},
        # Start the Endpoint (http/https)
        AppsignalPhoenixExampleWeb.Endpoint
        # Start a worker by calling: AppsignalPhoenixExample.Worker.start_link(arg)
        # {AppsignalPhoenixExample.Worker, arg}
      ]
      # See https://hexdocs.pm/elixir/Supervisor.html
      # for other strategies and supported options
      opts = [strategy: :one_for_one, name: AppsignalPhoenixExample.Supervisor]
      Supervisor.start_link(children, opts)
    end
  end
  ```
</CodeGroup>

AppSignal instrumentera désormais automatiquement tous les événements `mount`, `handle_event` et `handle_param` sous le namespace `live_view`, ce qui signifie que vous obtiendrez à la fois des informations de performance et d'erreur sur vos live views.

### Fonctions d'aide manuelles

<Tip>
  Si vous avez déjà configuré l'instrumentation télémétrique automatique ci-dessus,
  vous n'avez pas besoin d'instrumenter manuellement vos handlers de live view.
</Tip>

<Tip>
  **Remarque** : Les fonctions d'aide LiveView sont disponibles à partir d'AppSignal pour
  Elixir version `1.13.0`.
</Tip>

Une action LiveView peut également être instrumentée manuellement en enveloppant son contenu dans un
bloc `Appsignal.Phoenix.LiveView.instrument/4`.

Étant donné une live view qui met à jour son propre état chaque seconde, nous pouvons ajouter
l'instrumentation AppSignal en enveloppant à la fois les fonctions mount/2 et handle\_info/2
avec un appel `Appsignal.Phoenix.LiveView.instrument`/4 :

<CodeGroup>
  ```elixir Elixir theme={null}
  defmodule AppsignalPhoenixExampleWeb.ClockLive do
    use Phoenix.LiveView
    import Appsignal.Phoenix.LiveView, only: [instrument: 4]

    def render(assigns) do
      AppsignalPhoenixExampleWeb.ClockView.render("index.html", assigns)
    end

    def mount(_session, socket) do
      # Wrap the contents of the mount/2 function with a call to
      # Appsignal.Phoenix.LiveView.instrument/4

      instrument(__MODULE__, "mount", socket, fn ->
        :timer.send_interval(1000, self(), :tick)
        {:ok, assign(socket, state: Time.utc_now())}
      end)
    end

    def handle_info(:tick, socket) do
      # Wrap the contents of the handle_info/2 function with a call to
      # Appsignal.Phoenix.LiveView.instrument/4:

      instrument(__MODULE__, "tick", socket, fn ->
        {:ok, assign(socket, state: Time.utc_now())}
      end)
    end
  end
  ```
</CodeGroup>

Appeler l'une de ces fonctions dans votre application créera maintenant automatiquement un
échantillon envoyé à AppSignal. Ceux-ci sont affichés sous le namespace
`:live_view`.

## Instrumentation pour les Plugs inclus

Les exceptions dans les Plugs inclus sont automatiquement attrapées par AppSignal, mais
les échantillons de performance doivent être configurés manuellement en utilisant les helpers
d'instrumentation personnalisés ou les décorateurs. Voir la documentation
[Plug](/elixir/integrations/plug#instrumentation-for-included-plugs)
pour plus d'informations.

## Instrumentation personnalisée

[Ajoutez de l'instrumentation personnalisée](/elixir/instrumentation/instrumentation) pour
suivre du code plus complexe et obtenir des décompositions plus complètes des requêtes
lentes.

[phoenix]: http://www.phoenixframework.org/

[hex-appsignal]: https://hexdocs.pm/appsignal/