This feature requires{" "}
{v.name} version {v.version}
{getBoundText(v.bound)}.
)}
;
};
O AppSignal suporta [muitas gems prontas para uso][integrations] e não requer instrumentação adicional para reportar dados de erro e desempenho. Para scripts personalizados e bibliotecas que não suportamos, você pode adicionar monitoramento seguindo este guia.
## Monitorando scripts
Uma amostra do AppSignal é composta por dois elementos: uma transaction e events. Antes de reportar eventos com [nossos helpers de instrumentação](#instrumentation-events), você precisa primeiro criar uma transaction.
Use o helper `Appsignal.monitor` para criar uma transaction e mantê-la ativa durante a duração do bloco fornecido.
O helper monitor reportará o bloco de código instrumentado como medições de desempenho listadas na seção Performance da interface do AppSignal, agrupadas por nome de action. Ele rastreará a duração do bloco e reportará exceções que ocorrerem dentro.
```ruby Ruby theme={null}
class CronJobScript
def call
Appsignal.monitor(
:namespace => "cron",
:action => "CronJobScript#call"
) do
# Your code
end
end
end
```
O helper `monitor` aceita dois argumentos nomeados:
* `namespace` (Opcional): Personaliza o namespace da transaction. O padrão é "web".
* `action` (Obrigatório): Agrupamos as amostras do script por este nome de action para criação de issues e notificações. Sem um nome de action, nenhuma informação sobre o bloco monitorado é reportada, porque não sabemos como agrupar os dados.
### Defina o nome da action depois
O argumento `action` do helper `Appsignal.monitor` pode ser deixado como nil ou definido explicitamente como `:set_later`, mas apenas se o helper `Appsignal.set_action` ainda for chamado dentro do bloco para definir o nome da action. Sem um nome de action, nenhum dado é reportado sobre o bloco instrumentado. Este método de definir o nome da action pode ser útil se o nome da action só puder ser determinado em uma etapa de processamento dentro do bloco.
```ruby Ruby theme={null}
class CronJobScript
def call
Appsignal.monitor(
:action => :set_later
) do
# Your code
# Set action name later
Appsignal.set_action("My action name")
end
end
end
```
### Eventos de instrumentação
Por padrão, a gem Ruby reportará eventos das [integrações suportadas][integrations]. Esses eventos aparecerão na timeline de eventos. Use [nossos helpers de instrumentação](/ruby/instrumentation/instrumentation) para adicionar seus próprios eventos à timeline de eventos. Isso cria um detalhamento mais detalhado do que está acontecendo dentro do bloco monitorado.
```ruby Ruby theme={null}
class CronJobScript
def call
Appsignal.monitor(
:namespace => "cron",
:action => "CronJobScript#call"
) do
Appsignal.instrument "fetch.plans" do
# Complex part of fetching payment plans
end
Appsignal.instrument "send.invoices" do
# Complex part of sending invoices
end
end
end
end
```
## Requisito de parada
Para scripts rodando em hosts de curta duração, é necessário parar a gem AppSignal para Ruby antes que o script termine.
Isso garantirá que ele reporte os dados do script ao AppSignal antes que o host seja desligado.
Esse comportamento só é necessário em cenários como:
* Quando uma tarefa agendada (um cron job) é executada por um serviço de hospedagem.
* Quando um script é executado em um container que inicia para rodar esse script e é desligado quando o script termina.
* Quando um script é executado em um Heroku runner, ou provedores de hospedagem similares.
Não é necessário parar a gem AppSignal para Ruby se o host no qual o script é iniciado continua rodando após o script ter terminado.
O AppSignal é parado automaticamente quando o script termina e um container ou ambiente de hospedagem como o Heroku é detectado.
Esse comportamento é controlado pela [opção `enable_at_exit_hook`](/ruby/configuration/options#option-enable_at_exit_hook).
Garanta que esta opção esteja definida como true para scripts que requerem que o AppSignal seja parado, se não for detectado automaticamente.
Pode ser necessário adicionar uma chamada adicional de `sleep` de alguns segundos para garantir que haja tempo suficiente para enviar todos os dados. Use o exemplo de uso de `at_exit` do código abaixo se necessário.
```ruby Ruby theme={null}
# This block is called after all tasks are ran
# Ensures the AppSignal agent has enough time to send the data to the AppSignal servers
at_exit { sleep 10 }
# Your script code
```
### Helper monitor and stop
O helper `Appsignal.monitor_and_stop` foi descontinuado em favor da [opção `enable_at_exit_hook`](/ruby/configuration/options#option-enable_at_exit_hook), que garante que `Appsignal.stop` seja chamado quando o processo é encerrado, não sempre que o helper `Appsignal.monitor_and_stop` é chamado.
Seu uso é descrito na seção acima desta.
Use este helper apenas em versões da gem Ruby que não suportam a [opção `enable_at_exit_hook`](/ruby/configuration/options#option-enable_at_exit_hook).
Se o seu processo sempre executa uma tarefa/job e termina imediatamente depois, você pode usar o helper `Appsignal.monitor_and_stop`. Isso garantirá que o AppSignal pare automaticamente após o bloco ser executado.
```ruby Ruby theme={null}
# This block is called right before the script exits
# Ensures the AppSignal agent has enough time to send the data to the AppSignal servers
at_exit do
sleep 10
end
class CronJobScript
def call
Appsignal.monitor_and_stop(
:namespace => "cron",
:action => "CronJobScript#call"
) do
# Your code
end
end
end
```
[integrations]: /ruby/integrations.html