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

# Instalar o AppSignal para Rails

> Acompanhe Chris Oliver instalando e configurando o AppSignal em uma aplicação Rails.

export const YouTube = ({id, title, description, presenter, duration, republished}) => {
  const playlistId = "PLFHQSOKTqHXA";
  const playlistUrl = `https://www.youtube.com/playlist?list=${playlistId}`;
  if (!id || id === "YOUTUBE_ID") {
    return <div style={{
      border: "1px dashed currentColor",
      borderRadius: "0.5rem",
      opacity: 0.7,
      padding: "2rem 1.5rem",
      textAlign: "center",
      fontSize: "0.875rem"
    }}>
        <strong>Video not published yet.</strong>
        <br />
        {title ? `"${title}" has no YouTube id.` : "This tutorial has no YouTube id."}{" "}
        Replace <code>YOUTUBE_ID</code> in this page with the id from the
        video's URL, once it is in the{" "}
        <a href={playlistUrl}>GoRails x AppSignal playlist</a>.
      </div>;
  }
  const prettyDate = republished ? new Date(`${republished}T00:00:00Z`).toLocaleDateString("en-US", {
    year: "numeric",
    month: "long",
    day: "numeric",
    timeZone: "UTC"
  }) : null;
  const schema = {
    "@context": "https://schema.org",
    "@type": "VideoObject",
    name: title,
    embedUrl: `https://www.youtube-nocookie.com/embed/${id}`,
    contentUrl: `https://www.youtube.com/watch?v=${id}`,
    thumbnailUrl: [`https://i.ytimg.com/vi/${id}/maxresdefault.jpg`],
    creator: {
      "@type": "Organization",
      name: "GoRails",
      url: "https://gorails.com"
    },
    publisher: {
      "@type": "Organization",
      name: "AppSignal",
      url: "https://appsignal.com"
    }
  };
  if (description) schema.description = description;
  if (duration) schema.duration = duration;
  if (republished) schema.uploadDate = republished;
  if (presenter) schema.author = {
    "@type": "Person",
    name: presenter
  };
  return <div style={{
    marginBottom: "1.5rem"
  }}>
      <iframe width="100%" height="450" src={`https://www.youtube-nocookie.com/embed/${id}?list=${playlistId}`} title={title} style={{
    borderRadius: "0.5rem",
    border: 0,
    display: "block"
  }} allow="accelerometer; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerPolicy="strict-origin-when-cross-origin" allowFullScreen />
      <p style={{
    fontSize: "0.875rem",
    marginTop: "0.5rem"
  }}>
        <a href={`https://www.youtube.com/watch?v=${id}&list=${playlistId}`}>{`Watch "${title}" on YouTube`}</a>
      </p>
      <script type="application/ld+json" dangerouslySetInnerHTML={{
    __html: JSON.stringify(schema)
  }} />
    </div>;
};

<YouTube id="-QEw0DsvVw0" title="Instalar o AppSignal para Rails" description="Acompanhe Chris Oliver instalando e configurando o AppSignal em uma aplicação Rails." presenter="Chris Oliver" duration="PT13M19S" republished="2026-09-25" />

Apresentado por Chris Oliver para o [GoRails](https://gorails.com). Republicado no AppSignal em 25 de setembro de 2026.

Você trabalhou por meses na ideia do seu app. Você faz o deploy em produção, e testa o cadastro e os outros recursos para garantir que tudo funciona. Depois você lança seu produto. As pessoas começam a se cadastrar, o que é ótimo. Mas então mensagens de clientes começam a aparecer na sua caixa de entrada com reclamações:

* As páginas estão carregando muito devagar.
* Quando tento redefinir minha senha, o email para concluir o processo nunca chega.
* O app está quebrado?

É nesse momento que você percebe que falta visibilidade sobre a produção, e se dá conta de que precisa se cadastrar no AppSignal.

Chris instala a gem `appsignal` em uma aplicação Ruby on Rails implantada no Hatchbox. Ele a configura manualmente para que você veja o que cada opção faz. Depois ele faz o deploy, e usa o AppSignal para encontrar um erro que seus usuários encontraram.

<Tip>
  Quer que um agente de codificação com IA cuide da instalação? Siga [Configurar um novo aplicativo com IA](/guides/install-with-agents).
</Tip>

<h2 id="what-this-covers">
  O que este tutorial aborda
</h2>

* Adicionar a gem do AppSignal para Ruby e executar o comando de instalação.
* Escolher quais ambientes reportam ao AppSignal.
* Manter sua Push API key fora do seu repositório com as credentials criptografadas do Rails.
* Ignorar ações e namespaces barulhentos, e reportar uma revisão a cada deploy.
* Confirmar que os dados estão chegando e, então, investigar o primeiro erro real que seus usuários encontraram.

<h2 id="requirements">
  Requisitos
</h2>

| O que | Valor |
| - | - |
| Framework | Ruby on Rails |
| Gem | `appsignal` |
| Conta | Uma conta AppSignal, para sua Push API key |

<h2 id="install-appsignal">
  Instalar o AppSignal
</h2>

Depois de se cadastrar, escolha o framework ou a linguagem que o seu app usa. Neste walkthrough, é um app Ruby on Rails implantado no Hatchbox. O fluxo de [configuração com IA do AppSignal](/guides/install-with-agents) também pode identificar isso a partir do ambiente do seu app e executar a instalação. Ou faça do jeito tradicional, como neste walkthrough, e instale tudo manualmente pelo fluxo de UI do AppSignal:

1. Primeiro, selecione **Add app** e depois escolha Ruby & Rails.

2. Adicione a gem de integração do AppSignal para Ruby ao seu Gemfile assim:

   ```rb theme={null}
   # Gemfile
   source "https://rubygems.org"
   gem "appsignal"
   ```

3. Execute `bundle install` para baixar e instalar a gem do AppSignal para Ruby.

4. Por fim, configure-a com a [Push API key](https://appsignal.com/redirect-to/organization?to=admin/api_keys) da sua organização.

   ```bash theme={null}
   bundle exec appsignal install <YOUR_PUSH_API_KEY>
   ```

O comando de instalação verifica sua Push API key. Em seguida, ele pergunta se você quer um nome mais amigável para o seu app, e qual arquivo de configuração usar. Este walkthrough recusa a renomeação e escolhe o arquivo de configuração Ruby, então `config.name` mantém o nome que o instalador detectou. Em seguida, o assistente envia um erro de exemplo para o AppSignal. Ele verifica sua instalação esperando que esse erro chegue.

Para os comandos e requisitos mais recentes e detalhados, leia também a documentação sobre [instalar o AppSignal para Ruby](/ruby/installation).

<h2 id="using-the-ruby-configuration-file">
  Usando o arquivo de configuração Ruby
</h2>

O comando de instalação grava suas respostas em `config/appsignal.rb`. Como a configuração é um arquivo Ruby, toda alteração que você fizer é salva no seu repositório Git. Isso ajuda caso você queira mudar as coisas depois ou desfazê-las.

Por padrão, o AppSignal só é ativado nos ambientes `development` e `production`.

<Tip>
  Normalmente, ambientes de desenvolvimento são usados para testar e quebrar coisas. Você pode substituir o ambiente padrão `"development"` por `"staging"`, por exemplo. Assim você consegue detectar erros e corrigi-los antes que cheguem à produção.
</Tip>

```rb theme={null}
# Visit our documentation for a list of all available configuration options.
# https://docs.appsignal.com/ruby/configuration/options.html
   Appsignal.configure do |config|
      config.activate_if_environment("staging", "production")

      config.name = "AppsignalExample"
```

<h3 id="storing-credentials-safely">
  Armazenando credentials com segurança
</h3>

Execute `rails credentials:edit` para abrir seu editor, cole sua Push API key do AppSignal e salve-a como um secret.
Em seguida, copie o conteúdo de `config/master.key` para a área de transferência. No macOS, execute `cat config/master.key | pbcopy`. Depois vá até seu ambiente de hospedagem, por exemplo o Hatchbox, e defina-o como a variável de ambiente `RAILS_MASTER_KEY`.

```yaml theme={null}
# smtp:
#   user_name: my-smtp-user
#   password: my-smtp-password
#
# aws:
#   access_key_id: 123
#   secret_access_key: 345

# Used as the base secret for all MessageVerifiers in Rails, including
# the one protecting cookies.
secret_key_base: <YOUR_SECRET_KEY_BASE>

appsignal:
  api_key: "<YOUR_PUSH_API_KEY>"
```

```rb theme={null}
  # Your application's Push API key
  # We recommend removing this line and setting this option with the
  # APPSIGNAL_PUSH_API_KEY environment variable instead
  # This will use Rails' encrypted credentials so you can manage them safely in your repository
  # https://docs.appsignal.com/ruby/configuration/options.html#option-push_api_key
      config.push_api_key = Rails.application.credentials.dig(:appsignal, :api_key)
```

<h3 id="ignoring-actions-namespaces-and-configuring-a-revision-file">
  Ignorando ações, namespaces e configurando um arquivo de revisão
</h3>

Aplicações Rails novas têm uma rota padrão chamada `/up`, que você pode ver em `config/routes.rb`. Ela já vem embutida no Rails e retorna um status `200` ou `500` para mostrar se sua aplicação está rodando. Isso é útil para verificações de uptime e health check feitas pelo seu load balancer para confirmar que seu app está no ar. Seu load balancer acessa essa rota a cada poucos segundos. Você nem sempre precisa reportar essa rota, ou outras rotas muito movimentadas, ao AppSignal.

Outra opção é deixar o AppSignal coletar dados e monitorar seu app pelas próximas 24 horas. Veja o que ele reporta, e ajuste depois.

```rb theme={null}
  # Configure actions that should not be monitored by AppSignal.
  # For more information see our docs:
  # https://docs.appsignal.com/ruby/configuration/ignore-actions.html
      config.ignore_actions << "Rails::HealthController#show"
```

Ignore métricas e mensagens do Action Cable relacionadas ao namespace `action_cable`. Isso pode ser útil porque WebSockets no Action Cable do Rails provavelmente geram bastante ruído. Digamos que sua aplicação no Hatchbox esteja enviando eventos em tempo real e mensagens de log constantemente para os navegadores. Isso pode consumir sua cota do AppSignal se esse namespace estiver ativo.

Por fim, seu deploy no Hatchbox grava um arquivo de revisão que contém o SHA do seu commit Git. `config.revision` lê esse arquivo, então o AppSignal vincula todas as métricas, erros, logs e qualquer outra coisa reportada a esse deploy.

Use esse arquivo para rastrear os erros que você corrige e para os quais faz deploy de mudanças. Se eles voltarem depois do seu deploy, o AppSignal avisa que esses erros não foram realmente corrigidos.

```rb theme={null}
  # Configure errors that should not be recorded by AppSignal.
  # For more information see our docs:
  # https://docs.appsignal.com/ruby/configuration/ignore-errors.html
      config.ignore_errors << "MyCustomError"

      config.ignore_namespaces << "action_cable"

      config.revision = File.read("REVISION")
end
```

Aqui está o arquivo completo do nosso walkthrough.

```rb theme={null}
# Visit our documentation for a list of all available configuration options.
# https://docs.appsignal.com/ruby/configuration/options.html
   Appsignal.configure do |config|
      config.activate_if_environment("staging", "production")

      config.name = "AppsignalExample"

  # Your application's Push API key
  # We recommend removing this line and setting this option with the
  # APPSIGNAL_PUSH_API_KEY environment variable instead
  # This will use Rails' encrypted credentials so you can manage them safely in your repository
  # https://docs.appsignal.com/ruby/configuration/options.html#option-push_api_key
      config.push_api_key = Rails.application.credentials.dig(:appsignal, :api_key)

  # Configure actions that should not be monitored by AppSignal.
  # For more information see our docs:
  # https://docs.appsignal.com/ruby/configuration/ignore-actions.html
      config.ignore_actions << "Rails::HealthController#show"

  # Configure errors that should not be recorded by AppSignal.
  # For more information see our docs:
  # https://docs.appsignal.com/ruby/configuration/ignore-errors.html
      config.ignore_errors << "MyCustomError"

      config.ignore_namespaces << "action_cable"
      config.revision = File.read("REVISION")
end
```

Faça commit da configuração e um push para o seu repositório:

```bash theme={null}
git add .
git commit -m "Add appsignal"
git push
```

<h2 id="deploy-your-app">
  Faça o deploy do seu app
</h2>

Depois de salvar no seu repositório Git, vá até sua plataforma de deploy e gerenciamento de servidor, como o Hatchbox. Confirme que o valor da sua master key do Rails corresponde a `config/master.key`, e então faça o deploy do seu app.
Você deve ver um ambiente `production` sendo adicionado ao AppSignal. Ele aparece ao lado do seu ambiente `development` e do erro de demonstração que você enviou durante a instalação. Depois que seu deploy estiver pronto, o AppSignal vai mostrar as métricas e requisições do seu app nos dashboards. Mude para o ambiente `production` para acompanhar as requisições chegando.

<h2 id="find-the-error-your-users-reported">
  Encontre o erro que seus usuários reportaram
</h2>

Você pode então tentar reproduzir o erro que seus usuários tiveram, como o email de redefinição de senha que nunca chegou:

1. Vá até seus dashboards e confira o gráfico "Error rate (%)". O AppSignal separa requisições web de background jobs, como o Solid Queue, em namespaces próprios.

2. Selecione Errors > Issue list e abra o erro que você quer investigar melhor. Ele vai mostrar a mensagem de erro e o backtrace, por exemplo "Make sure your API key is set".

3. No Hatchbox, defina a API key da Resend que está faltando nas suas Environment Variables, e salve. Isso resolve o erro que seus usuários tiveram.

   Neste walkthrough, a key que falta pertence ao Resend, o serviço pelo qual o app envia emails. Crie uma API key no Resend com acesso de envio para todos os domínios, e depois defina-a no Hatchbox. Até você verificar um domínio, uma conta de teste do Resend só entrega para o próprio endereço de teste. Envie a redefinição de senha para `delivered@resend.dev`, e confirme que o email chega no seu dashboard do Resend.

4. Volte para Errors > Issue list no AppSignal e, nas Settings do seu erro, marque o status dele como "Closed".

Os dashboards do AppSignal também mostram um [marker](/guides/deploy-markers) para cada deploy e revisão que você fizer. Você pode ver os erros entre os deploys. O throughput vai indicar se as coisas ficaram mais lentas depois do deploy de um novo recurso. Há muito mais que você pode fazer e investigar no seu app com o AppSignal. Os [Intelligence dashboards](/metrics/intelligence-dashboards) também são gerados automaticamente para os recursos do Rails que o AppSignal detecta. Neste walkthrough, ele detectou que o Active Job estava enviando emails, e gerou dashboards para o Action Mailer e o Active Job. Cada um tem seu próprio dashboard, mostrando o que está acontecendo naquela parte da sua aplicação Rails. Para se aprofundar no seu framework e linguagem de escolha, leia a documentação [AppSignal para Ruby](/ruby). Ela explica como o AppSignal se integra à sua aplicação e oferece visibilidade sobre ela.

<h2 id="transcript">
  Transcrição
</h2>

Transcrito a partir do vídeo e levemente editado. As legendas automáticas entenderam errado vários nomes de produtos e de API, e esses foram corrigidos.

<Accordion title="Ler a transcrição">
  **0:00** Imagine isso: você trabalhou por meses na ideia do seu produto, e ela finalmente está pronta. Você fez o deploy em produção, se cadastrou, testou tudo, e parece que está funcionando muito bem. Então você resolve enviar para seus amigos, sua família, sua newsletter por email, suas redes sociais, tentando conseguir usuários, e as pessoas começam a se cadastrar, o que é bom.

  **0:18** Até que você recebe mensagens de pessoas dizendo: "Ei, essa página carrega muito devagar", ou coisas como: "Ei, tentei redefinir minha senha", e o email simplesmente nunca chegou. "Está quebrado? Tipo, o que está acontecendo?" E você percebe: "Eu não tenho nenhuma visibilidade sobre a produção. O que eu faço?" Bom, você se cadastra no AppSignal.

  **0:39** Então hoje vamos instalar o AppSignal no nosso app Procrastinate aqui, e vamos começar, claro, nos cadastrando no AppSignal e depois instalando no nosso app. Agora, ao fazer isso, você pode escolher seguir o framework ou a linguagem de sua preferência, para nós é Ruby on Rails, mas eu recomendaria simplesmente usar o prompt de IA deles para isso.

  **1:00** Então eles têm documentação e um prompt e tudo pronto, então você pode simplesmente copiar e colar isso, jogar no Claude Code ou no Codex ou no que você estiver usando, e ele vai fazer a instalação para você. Claro que ele também pode configurar coisas, então você pode pedir para ele ajustar detalhes, mas nós vamos fazer do jeito difícil, à moda antiga, manualmente, para que você veja exatamente o que está acontecendo por trás dos panos.

  **1:24** Então tudo que precisamos fazer é adicionar a biblioteca, então `bundle add appsignal` vai baixar e instalar a gem Ruby do AppSignal para que possamos usá-la, e então, claro, precisamos configurá-la para usar nossa API key. E é isso que esse comando de instalação vai fazer: ele vai verificar nossa API key, perguntar se queremos um nome mais amigável para o nosso app, vamos dizer que não, e então como queremos configurá-la.

  **1:47** Vamos usar o arquivo de configuração Ruby, então tudo o que fizermos vai ficar salvo no nosso repositório Git, o que vai ser útil depois, quando formos mudar isso, talvez queiramos desfazer algumas coisas ou o que for, e isso vai enviar um erro de exemplo. Então vamos continuar com esse assistente, e você vai aprender um pouco mais sobre como o AppSignal funciona, mas depois ele vai verificar a instalação, procurando aquele erro de exemplo que veio na nossa instalação.

  **2:13** Enquanto isso acontece, vamos abrir `config/appsignal.rb` e dar uma olhada na configuração padrão. Primeiro, ele só vai ativar se estivermos em um desses ambientes pré-configurados, ou seja, development e production. Claro, estamos em development na nossa máquina local, mas em produção em um servidor, teremos o ambiente production.

  **2:36** Agora, eu não me importo muito em rastrear erros em development, porque costumo quebrar coisas enquanto construo funcionalidades, e isso enviaria métricas e erros e tudo mais para o AppSignal, e eu não preciso disso, eu não vou realmente olhar para eles. Então vou remover isso, e talvez substitua por staging, por exemplo, e isso vai permitir que meu ambiente staging reporte erros e tudo mais, para que eu possa pegá-los e corrigi-los antes que cheguem à produção, por exemplo.

  **3:03** Então você também pode, claro, renomear isso aqui, e sua Push API key é o que permite enviar dados para o AppSignal. Agora, isso na verdade queremos remover, não queremos que fique fixo no código, então vamos escrever `Rails.application.credentials.dig(:appsignal, :api_key)`. O que isso vai fazer é usar as credentials criptografadas do Rails, para que possamos guardar esse secret com segurança nas credentials criptografadas do nosso repositório Git.

  **3:35** Então vamos até nossa outra aba aqui e digitamos `rails credentials:edit`, isso vai abrir nosso editor, descemos até o final e adicionamos as chaves correspondentes, AppSignal API key, e colamos esse secret. Salvamos isso, e então tudo que precisamos fazer é pegar a saída de `config/master.key`, e eu estou no Mac então posso usar `pbcopy` para copiar isso para a área de transferência, e então você vai até seu ambiente de hospedagem.

  **4:07** No nosso caso, estamos usando o Hatchbox, e você vai definir `RAILS_MASTER_KEY` como variável de ambiente com esse valor. Então vá em frente e faça isso, eu já configurei a minha então não preciso fazer isso, mas vamos continuar aqui na configuração do AppSignal.

  **4:23** Há mais algumas coisas que você pode querer considerar ao configurar o seu AppSignal. Uma delas é que provavelmente você vai querer fazer algo como ignorar o health controller, a action show. Então vamos abrir nosso arquivo de routes para você ver exatamente isso.

  **4:44** Em uma aplicação Rails nova, desde que o Kamal surgiu, agora você tem uma rota padrão chamada `/up`, que vai para um controller já embutido no Rails que só diz: "Ei, sua aplicação Rails está rodando." Isso é útil para verificações de uptime ou health checks feitos pelo seu load balancer ou o que for, e essa rota não faz muita coisa, mas é útil. Então ela é importante, e vai ser acessada com frequência, especialmente se estiver atrás de um load balancer fazendo health checks ativos.

  **5:13** Essa rota é acessada a cada poucos segundos só perguntando: "Você ainda está vivo? Você ainda está vivo?" Sim, ainda estou vivo, mas na verdade não precisamos que esses dados sejam reportados para o AppSignal, então eu gosto de ignorar isso. Outras rotas que talvez sejam muito movimentadas e que você queira ignorar, você pode adicionar aqui, mas eu diria para deixar quieto e ver o que acontece em produção, ver quais dados o AppSignal coleta nas próximas quatro horas ou 24 horas, seja lá o que for, e depois você pode ajustar detalhes mais tarde.

  **5:44** E claro, você pode usar IA para analisar isso e então ajustar as coisas de acordo. O mesmo vale para ignorar erros, eu normalmente não adicionaria nada a essa lista, a menos que eu realmente soubesse de algo específico que quiséssemos ignorar, porque obviamente queremos rastrear erros e corrigi-los, então queremos coletar o máximo possível, especialmente para algo como erros.

  **6:06** Uma coisa que talvez não queiramos coletar é se ignorarmos namespaces, podemos dizer que queremos ignorar todas as mensagens e métricas do Action Cable relacionadas a isso, então tudo nesse namespace no AppSignal será ignorado. E isso é importante porque, se você estiver usando WebSockets no Action Cable do Rails, o framework para isso, provavelmente vai gerar bastante ruído.

  **6:33** Então na nossa aplicação no Hatchbox, estamos enviando eventos em tempo real e mensagens de log constantemente para o navegador, e por isso, quando instalamos o AppSignal e não temos isso ativado, a gente simplesmente consome nossa cota muito rápido. Então você provavelmente vai querer deixar isso de fora na instalação inicial e depois voltar e adicionar algo assim mais tarde, depois de uma hora ou duas, ou um dia, o que for. Depois que você teve tempo de ver o que realmente estamos reportando, o que é realmente movimentado, se estamos consumindo nossa cota e nosso plano do AppSignal, aí podemos ajustar.

  **7:09** Certo, por último mas não menos importante, quero mencionar o `config.revision`. Do jeito que o Hatchbox faz deploy, a gente cria um arquivo de revisão que mostra ou contém o SHA do commit Git que você fez deploy. Então há várias formas de acessar isso. Cada provedor de hospedagem é um pouco diferente. Alguns usam variáveis de ambiente, nós também. Mas você também pode personalizar isso, tipo fazer a leitura do arquivo, o arquivo de revisão, e fazer com que isso seja escrito como o deploy ao qual todas essas métricas ou erros ou qualquer outra coisa reportada ao AppSignal estão relacionados.

  **7:45** Isso é muito útil porque, se você corrige um erro e faz deploy de uma mudança que deveria corrigir esse erro, e o erro volta a aparecer depois desse deploy, o AppSignal pode avisar você e dizer: "Ei, você não corrigiu isso de verdade. Você achou que tinha corrigido, mas a gente viu de novo." E talvez seja um caso extremo diferente ou algo assim, mas isso ajuda você a acompanhar tudo isso.

  **8:04** Então, assim que você é notificado sobre um erro, se ele acontecer cem vezes, você não vai receber cem notificações. Mas se você faz o deploy e ele volta, aí você vai ser notificado de novo. Então você sabe que: "Ei, isso não foi realmente corrigido." E isso é muito, muito útil de saber.

  **8:20** Então essas são algumas das personalizações padrão que eu gosto de fazer. Vamos fazer o `git add` de todas essas mudanças, e vamos escrever `git commit -m "Add appsignal"`. E vamos dar push disso para o nosso repositório Git, e podemos ir até nossa aplicação no Hatchbox e fazer o deploy dessas mudanças.

  **8:40** Agora, no seu ambiente, lembre-se, eu mencionei que você precisa ter sua master key do Rails definida, e a gente só quer conferir que esse valor corresponde exatamente ao que estava na nossa área de transferência aqui, com `config/master.key`, e é exatamente a mesma coisa. Então, assim que esse deploy terminar e for bem-sucedido, vamos poder recarregar nossa aplicação, ela vai reiniciar automaticamente, claro, mas aí devemos ver um ambiente production sendo adicionado ao AppSignal.

  **9:12** Então vamos dar uma olhada no que já foi criado até agora. Temos um ambiente development para o AppsignalExample, a aplicação que estamos fazendo, e temos um erro que foi reportado aqui. E se dermos uma olhada na lista de erros, vemos um `Appsignal::Demo::TestError`. Esse, claro, é o erro de teste que o comando de instalação enviou. Era isso que ele estava procurando enquanto verificava a instalação, e ele encontrou, então estava tudo certo.

  **9:40** Excelente. Nosso deploy agora foi bem-sucedido. Então vamos atualizar a página e ver se alguma métrica está sendo enviada para o AppSignal. Eu tenho o ambiente development, mas agora devemos ver um ambiente production aqui em cima, e podemos mudar para ele e devemos ver que as requisições estão chegando agora. Eu fiz três requisições por minuto, por exemplo, aqui, o que é um bom sinal de que está tudo conectado corretamente.

  **10:05** Agora vamos tentar reproduzir esse erro e ver se ele também aparece. Vamos até "esqueci minha senha", colocamos nosso endereço de email, e enviamos isso. Nenhum erro 500, nada do tipo. Então talvez esteja acontecendo algo em segundo plano, e aí podemos dar uma olhada no AppSignal e ver se ele capturou alguma coisa que não vimos visualmente como usuário.

  **10:24** E agora podemos ver que um erro realmente apareceu, e temos um erro no namespace background. Então ele separou automaticamente nosso servidor Rails dos background jobs, no nosso caso, o Solid Queue. E assim ele separou tudo isso, e você pode ver aqui em cores diferentes também. Como isso aconteceu em segundo plano, é uma linha azul, e podemos também ir até a lista de erros e investigar exatamente o que estava errado.

  **10:50** Estamos usando o Resend para emails, e parece que temos um erro do Resend. Então vamos clicar nisso e ver qual foi a mensagem de erro. "Make sure your API key is set." Ah, esqueci completamente de colocar isso aí. Então, no nosso caso, podemos ir até o Resend, criar uma API key, e vamos ter um AppSignal.

  **11:11** Example é o nome. Vamos dar acesso total, ou acesso de envio, para todos os domínios, e então vamos copiar isso e colocar no nosso ambiente. Então eu sei que isso deveria ser uma API key do Resend, colo isso ali, salvo as mudanças, e agora devemos estar prontos, e devemos conseguir enviar esse email e fazer com que funcione com sucesso.

  **11:35** Então agora vamos tentar de novo, e eu lembrei que preciso usar um endereço de email especial do Resend para testar sem ainda ter um domínio válido, porque estou só na conta de teste deles. Então vamos enviar um email para `delivered@resend.dev`. E no dashboard deles, devemos ver agora que "reset your password" acabou de chegar. Eu só criei essa conta para podermos testar com ela, mas podemos confirmar que agora nossos background jobs estão funcionando e não estão mais enviando erros, e que estão de fato usando minha API key real do Resend.

  **12:07** Então esse erro pode ser considerado resolvido, podemos ir lá e fechá-lo nós mesmos, mas também podemos ver que, quando fizermos outro deploy, vai ter outro ponto aqui embaixo, que vai registrar cada deploy que fizermos, com o horário e a revisão Git também. Assim vamos poder ver isso ao longo do tempo e ver os erros entre cada um desses deploys, e também podemos ver o throughput, para você ver que talvez as coisas tenham ficado bem mais lentas depois do deploy de um certo recurso.

  **12:38** Talvez precisássemos corrigir algum problema de performance ou algo assim. Claro, isso é só a ponta do iceberg, o AppSignal tem muito mais coisa que você pode fazer com ele. E por exemplo, atualizando a página, já conseguimos ver os novos dashboards deles para Action Mailer e Active Job que foram gerados automaticamente para nós porque ele detectou que estávamos usando o Active Job para enviar emails.

  **12:56** Então esses dois recursos do Rails têm seus próprios dashboards especiais que permitem ver e obter informações sobre exatamente o que está acontecendo nessas partes das suas aplicações Rails. Então dê uma olhada na documentação para se aprofundar no seu framework e na sua linguagem de escolha, e veja como o AppSignal pode se integrar melhor e te dar visibilidade sobre suas aplicações.
</Accordion>

<h2 id="related-tutorials">
  Tutoriais relacionados
</h2>

* [Executar background jobs com o Solid Queue](/tutorials/ruby/solid-queue)
* [Inspecionar background jobs com o Mission Control](/tutorials/ruby/mission-control-jobs)

<h2 id="about-this-tutorial">
  Sobre este tutorial
</h2>

Este tutorial acompanha, passo a passo, um screencast do GoRails sobre como instalar o AppSignal em uma aplicação Rails implantada no Hatchbox, de Chris Oliver. O screencast é a obra original. O GoRails o publica, junto com o restante da série, em [gorails.com](https://gorails.com).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.