> ## 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.
# Minutely probes
Minutely probes são um mecanismo para enviar periodicamente [métricas personalizadas](/metrics/custom) para o AppSignal. Este é um sistema incluído por padrão no pacote AppSignal Elixir. No início de cada minuto, as minutely probes são disparadas para coletar métricas e então aguardam até o próximo minuto.
Por padrão, o pacote AppSignal Elixir habilita uma probe para a ErlangVM.
**Nota**: Recomendamos usar o pacote AppSignal Elixir `1.10.1` ou superior ao
usar este recurso.
## Uso
As minutely probes permitem que o pacote AppSignal Elixir colete [métricas personalizadas](/metrics/custom) por padrão para a ErlangVM e métricas específicas do app [criando sua própria probe](#creating-probes).
### Múltiplas instâncias
Uma vez ativado, o sistema de minutely probes roda em cada instância de um app. Isso significa que se uma probe reporta métricas sem algum tipo de tag diferenciadora, métricas globais podem ser sobrescritas por métricas em nível de instância.
Para remediar isso, sugerimos [tagear](/metrics/custom#metric-tags) suas métricas com o hostname ou algo único para cada instância. Por exemplo, a ErlangVM Probe taga métricas com o hostname por padrão.
Como alternativa, você pode [desabilitar as minutely probes](/elixir/configuration/options#option-enable_minutely_probes) para todas as instâncias, exceto uma, na qual o processo de minutely probes é executado. Sugerimos usar a variável de ambiente [`APPSIGNAL_ENABLE_MINUTELY_PROBES`](/elixir/configuration/options#option-enable_minutely_probes) para habilitá-la apenas na instância de sua escolha.
## Configuração
As minutely probes são configuradas usando a opção de configuração [`enable_minutely_probes`](/elixir/configuration/options#option-enable_minutely_probes). O valor padrão é `true`.
## Criando probes
Se você quiser rastrear mais [métricas personalizadas](/metrics/custom) do seu app do que as probes padrão fazem, você pode adicionar suas próprias probes.
Uma minutely probe do AppSignal pode ser uma [Função anônima](#anonymous-function) ou uma [Função baseada em módulo](#module-based-function).
### Função anônima
O tipo de probe mais simples de registrar. Se você não tem dependências para sua probe, este é o método preferido.
```elixir Elixir theme={null}
Appsignal.Probes.register(:my_probe, fn ->
Appsignal.set_gauge("database_size", 10)
end)
```
### Função baseada em módulo
Uma função baseada em módulo pode ser útil se você tem uma probe mais complexa, ou uma probe que tem dependências.
```elixir Elixir theme={null}
# lib/my_app/probes/my_probe.ex
defmodule MyApp.MyProbe do
def call do
Appsignal.set_gauge("database_size", 10)
end
end
```
Agora você pode registrar esta probe na função start do seu OTP app.
```elixir Elixir theme={null}
Appsignal.Probes.register(:my_probe, &MyApp.MyProbe.call/0)
```
### Probes com estado
A partir da versão `2.2.8` do pacote AppSignal Elixir, as probes podem passar estado entre execuções. Se sua probe recebe um argumento, o valor de retorno da última execução será passado como o valor para esse argumento na execução seguinte.
Um estado inicial a ser usado na primeira execução da probe pode ser fornecido como o terceiro argumento para `Appsignal.Probes.register`. Se ele não for fornecido, o estado inicial será `nil`.
```elixir Elixir theme={null}
Appsignal.Probes.register(:stateful_probe, fn minutes ->
Appsignal.set_gauge("uptime_minutes", minutes)
minutes + 1
end, 0)
```
Ou, como uma função baseada em módulo:
```elixir Elixir theme={null}
# lib/my_app/probes/my_probe.ex
defmodule MyApp.MyProbe do
def call(minutes) do
Appsignal.set_gauge("uptime_minutes", minutes)
minutes + 1
end
end
```
Que você pode então registrar como:
```elixir Elixir theme={null}
Appsignal.Probes.register(:stateful_probe, &MyApp.MyProbe.call/1, 0)
```
## Registrando probes
Probes podem ser registradas com o método `register` no módulo `Appsignal.Probes`.
Este método aceita três argumentos.
* `key` - Esta é a chave/nome da probe. Será usada para identificar a probe caso ocorra um erro durante a execução da probe (que será registrado no [arquivo appsignal.log](/support/debugging#logs)) e para [sobrescrever uma probe existente](#overriding-default-probes).
* `probe` - Este é um dos [tipos de probe suportados](#creating-probes) que deve ser chamado a cada minuto para coletar métricas.
* `state` - Este é o estado inicial que será passado para sua probe. Se sua probe não recebe estado como argumento, este argumento não tem efeito. É um argumento opcional, e seu valor padrão é `nil`.
Para adicionar uma probe, registre-a na função `start/2` da sua aplicação, logo antes do supervisor ser iniciado.
Em um app Phoenix isso ficará assim:
```elixir Elixir theme={null}
# lib/my_app/application.ex
def start(_type, _args) do
children = [
MyApp.Repo,
MyAppWeb.Endpoint,
]
Appsignal.Probes.register(:my_probe, &MyProbe.call/0)
opts = [strategy: :one_for_one, name: Weekmenu.Supervisor]
Supervisor.start_link(children, opts)
end
```
## Sobrescrevendo probes padrão
O AppSignal vem com probes padrão para certas [integrações](/elixir/integrations/). Se por algum motivo essa probe não funcionar corretamente ou exigir alguma configuração adicional para seu caso de uso, você pode sobrescrever a probe padrão registrando uma nova probe com a mesma chave.
```elixir Elixir theme={null}
# lib/my_app/application.ex
Appsignal.Probes.register(:erlang, fn() ->
# Faça coisas
end)
```
Sobrescrever probes registrará uma mensagem de debug no [arquivo appsignal.log](/support/debugging#logs), o que pode ajudar a detectar se uma probe foi sobrescrita corretamente.