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

# Integrando o AppSignal ao Phoenix

O pacote AppSignal for Elixir se integra ao Phoenix. Para configurar a
integração, siga nosso [guia de instalação](/elixir/installation).

Esta página descreverá outras maneiras de configurar o AppSignal para o [framework
Phoenix][phoenix]. Para adicionar mais instrumentação personalizada à sua aplicação
Phoenix, leia a documentação de [instrumentação
Elixir](/elixir/instrumentation).

Mais informações podem ser encontradas na [documentação do pacote Hex do
AppSignal][hex-appsignal].

## Instalação

1. A instrumentação do AppSignal para Phoenix faz parte de um
   pacote separado, que depende do pacote `appsignal` principal. Adicione o pacote `appsignal_phoenix` ao seu arquivo `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. Em seguida, execute `mix deps.get`.
3. Em seguida, execute `mix appsignal.install YOUR_PUSH_API_KEY`.

Após a instalação e configuração, o pacote AppSignal for Phoenix começa automaticamente a instrumentar requisições HTTP, ou seja, nenhuma configuração adicional é necessária.

Para obter insights mais profundos, o AppSignal pode ser configurado para instrumentar channels e live views.

## Channels

### Instrumentação de channels com o handle de um channel

Requisições de channel recebidas podem ser instrumentadas envolvendo o código nas suas
funções `handle_in/3` com `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>

Como alternativa, você pode usar function decorators para instrumentar channels. Embora
sejam menos flexíveis do que a função de instrumentação, os decorators minimizam a quantidade
de código que você precisa adicionar aos channels da sua aplicação.

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

    @decorate channel_action()
    def handle_in("ping", _payload, socket) do
      # seu código aqui..
    end
  end
  ```
</CodeGroup>

Eventos de channels serão exibidos na aba "Background jobs", mostrando o
módulo do channel e o argumento de ação que você inseriu.

## LiveView

Existem duas maneiras diferentes de instrumentar live views. Você pode usar nossos
handlers automáticos de telemetria ou instrumentar manualmente seus
handlers de live view com nossas funções helper.

### Handlers automáticos de telemetria

<Tip>
  **Nota**: A integração LiveView Telemetry está disponível a partir do AppSignal for
  Phoenix versão `2.1.0`.
</Tip>

A integração LiveView Telemetry do AppSignal instrumenta automaticamente os eventos de live view.

Para configurá-la, chame `Appsignal.Phoenix.LiveView.attach/0` para anexar os handlers do LiveView Telemetry.
Recomendamos chamar esta função no `application.ex` do seu app:

<CodeGroup>
  ```elixir Elixir theme={null}
  defmodule AppsignalPhoenixExample.Application do
    # ...
    def start(_type, _args) do
      Appsignal.Phoenix.LiveView.attach() # <--- anexa os handlers do LiveView Telemetry
      children = [
        # Inicia o repositório Ecto
        AppsignalPhoenixExample.Repo,
        # Inicia o supervisor de Telemetry
        AppsignalPhoenixExampleWeb.Telemetry,
        # Inicia o sistema PubSub
        {Phoenix.PubSub, name: AppsignalPhoenixExample.PubSub},
        # Inicia o Endpoint (http/https)
        AppsignalPhoenixExampleWeb.Endpoint
        # Inicia um worker chamando: AppsignalPhoenixExample.Worker.start_link(arg)
        # {AppsignalPhoenixExample.Worker, arg}
      ]
      # Veja https://hexdocs.pm/elixir/Supervisor.html
      # para outras estratégias e opções suportadas
      opts = [strategy: :one_for_one, name: AppsignalPhoenixExample.Supervisor]
      Supervisor.start_link(children, opts)
    end
  end
  ```
</CodeGroup>

O AppSignal agora instrumentará automaticamente todos os eventos `mount`, `handle_event` e `handle_param` no namespace `live_view`, o que significa que você receberá insights tanto de desempenho quanto de erros nas suas live views.

### Funções helper manuais

<Tip>
  Se você já configurou a instrumentação automática por telemetria acima,
  não precisa instrumentar manualmente os handlers de live view.
</Tip>

<Tip>
  **Nota**: As funções helper de LiveView estão disponíveis a partir do AppSignal for
  Elixir versão `1.13.0`.
</Tip>

Uma ação de LiveView também pode ser instrumentada manualmente envolvendo seu conteúdo em um
bloco `Appsignal.Phoenix.LiveView.instrument/4`.

Dada uma live view que atualiza seu próprio estado a cada segundo, podemos adicionar
instrumentação AppSignal envolvendo tanto as funções mount/2 quanto handle\_info/2
com uma chamada a `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
      # Envolva o conteúdo da função mount/2 com uma chamada a
      # 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
      # Envolva o conteúdo da função handle_info/2 com uma chamada a
      # Appsignal.Phoenix.LiveView.instrument/4:

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

Chamar uma dessas funções no seu app agora criará automaticamente uma
amostra que é enviada ao AppSignal. Essas amostras são exibidas no namespace
`:live_view`.

## Instrumentação de Plugs incluídos

Exceções em Plugs incluídos são automaticamente capturadas pelo AppSignal, mas
as amostras de desempenho precisam ser configuradas manualmente usando os helpers de
instrumentação personalizada ou decorators. Veja a documentação do
[Plug](/elixir/integrations/plug#instrumentation-for-included-plugs)
para mais informações.

## Instrumentação personalizada

[Adicione instrumentação personalizada](/elixir/instrumentation/instrumentation) para
acompanhar código mais complexo e obter breakdowns mais completos de requisições lentas.

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

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