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

# AppSignal in Phoenix integrieren

Das AppSignal-für-Elixir-Paket integriert sich mit Phoenix. Um die
Integration einzurichten, folgen Sie bitte unserem [Installationsleitfaden](/elixir/installation).

Diese Seite beschreibt weitere Möglichkeiten zur Konfiguration von AppSignal für das [Phoenix-
Framework][phoenix]. Um Ihrer Phoenix-Anwendung weitere benutzerdefinierte Instrumentierung
hinzuzufügen, lesen Sie die [Elixir-
Instrumentierungs-Dokumentation](/elixir/instrumentation).

Weitere Informationen finden Sie in der [AppSignal-Hex-Paket-
Dokumentation][hex-appsignal].

## Installation

1. Die AppSignal-Instrumentierung für Phoenix ist Teil eines
   separaten Pakets, das vom primären `appsignal`-Paket abhängt. Fügen Sie das Paket `appsignal_phoenix` zu Ihrer `mix.exs`-Datei hinzu.

<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. Führen Sie dann `mix deps.get` aus.
3. Führen Sie dann `mix appsignal.install YOUR_PUSH_API_KEY` aus.

Nach der Installation und Konfiguration startet das AppSignal-für-Phoenix-Paket automatisch mit der Instrumentierung von HTTP-Anfragen, was bedeutet, dass keine weitere Einrichtung erforderlich ist.

Um tiefere Einblicke zu erhalten, kann AppSignal so eingerichtet werden, dass es Channels und Live-Views instrumentiert.

## Channels

### Channel-Instrumentierung mit dem Handle eines Channels

Eingehende Channel-Anfragen können instrumentiert werden, indem der Code in Ihren
`handle_in/3`-Funktionen mit `Appsignal.Phoenix.Channel.instrument/5` umschlossen wird:

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

Alternativ können Sie Funktions-Decoratoren verwenden, um Channels zu instrumentieren. Obwohl
weniger flexibel als die Instrumentierungsfunktion, minimieren Decoratoren die Menge an
Code, die Sie zu den Channels Ihrer Anwendung hinzufügen müssen.

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

Channel-Events werden unter dem Tab „Background jobs“ angezeigt und zeigen das
Channel-Modul und das Action-Argument, das Sie eingegeben haben.

## LiveView

Es gibt zwei verschiedene Möglichkeiten, Live-Views zu instrumentieren. Sie können entweder unsere
automatischen Telemetry-Handler verwenden oder Sie können Ihre Live-View-Handler manuell mit unseren Helferfunktionen instrumentieren.

### Automatische Telemetry-Handler

<Tip>
  **Hinweis**: Die LiveView-Telemetry-Integration ist ab AppSignal-für-
  Phoenix-Version `2.1.0` verfügbar.
</Tip>

Die LiveView-Telemetry-Integration von AppSignal instrumentiert automatisch LiveView-Events.

Um sie einzurichten, rufen Sie `Appsignal.Phoenix.LiveView.attach/0` auf, um die LiveView-Telemetry-Handler anzuhängen.
Wir empfehlen, diese Funktion in der `application.ex` Ihrer App aufzurufen:

<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 instrumentiert nun automatisch alle `mount`-, `handle_event`- und `handle_param`-Events unter dem `live_view`-Namespace, was bedeutet, dass Sie sowohl Performance- als auch Fehlereinblicke in Ihre Live-Views erhalten.

### Manuelle Helferfunktionen

<Tip>
  Wenn Sie die automatische Telemetry-Instrumentierung oben bereits konfiguriert haben,
  müssen Sie Ihre Live-View-Handler nicht manuell instrumentieren.
</Tip>

<Tip>
  **Hinweis**: Die LiveView-Helferfunktionen sind ab AppSignal-für-
  Elixir-Version `1.13.0` verfügbar.
</Tip>

Eine LiveView-Action kann auch manuell instrumentiert werden, indem ihr Inhalt in einen
`Appsignal.Phoenix.LiveView.instrument/4`-Block eingewickelt wird.

Bei einer Live-View, die ihren eigenen Zustand jede Sekunde aktualisiert, können wir
AppSignal-Instrumentierung hinzufügen, indem wir sowohl die Funktionen mount/2 als auch handle\_info/2
mit einem `Appsignal.Phoenix.LiveView.instrument`/4-Aufruf umschließen:

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

Der Aufruf einer dieser Funktionen in Ihrer App erstellt jetzt automatisch ein
Sample, das an AppSignal gesendet wird. Diese werden unter dem `:live_view`-Namespace angezeigt.

## Instrumentierung für eingebundene Plugs

Ausnahmen in eingebundenen Plugs werden automatisch von AppSignal abgefangen, aber
Performance-Samples müssen manuell mit den benutzerdefinierten Instrumentierungs-
Helfern oder Decoratoren eingerichtet werden. Weitere Informationen finden Sie in der
[Plug](/elixir/integrations/plug#instrumentation-for-included-plugs)-
Dokumentation.

## Benutzerdefinierte Instrumentierung

[Fügen Sie benutzerdefinierte Instrumentierung hinzu](/elixir/instrumentation/instrumentation), um
komplexeren Code zu verfolgen und vollständigere Aufschlüsselungen langsamer
Anfragen zu erhalten.

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

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