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

export const Compatibility = ({versions = [], label = "Available in"}) => {
  if (!Array.isArray(versions) || versions.length === 0) {
    return null;
  }
  const defaultPillStyle = {
    borderColor: "#d4d4d8",
    background: "#f4f4f5",
    color: "#3f3f46"
  };
  const pillStyles = {
    "AppSignal for Elixir": {
      background: "#f3e8ff",
      borderColor: "#d8b4fe",
      color: "#6b21a8"
    },
    "AppSignal for Front-end": {
      background: "#fef9c3",
      borderColor: "#fde047",
      color: "#854d0e"
    },
    "AppSignal for Go": {
      background: "#ccfbf1",
      borderColor: "#5eead4",
      color: "#115e59"
    },
    "AppSignal for JavaScript": {
      background: "#fef9c3",
      borderColor: "#fde047",
      color: "#854d0e"
    },
    "AppSignal for Node.js": {
      background: "#dcfce7",
      borderColor: "#86efac",
      color: "#166534"
    },
    "AppSignal for Python": {
      background: "#dbeafe",
      borderColor: "#93c5fd",
      color: "#1e40af"
    },
    "AppSignal for Ruby": {
      background: "#fee2e2",
      borderColor: "#fca5a5",
      color: "#991b1b"
    },
    "AppSignal for Rust": {
      background: "#ffedd5",
      borderColor: "#fdba74",
      color: "#9a3412"
    }
  };
  const getPillStyle = name => ({
    ...defaultPillStyle,
    ...pillStyles[name] || ({})
  });
  return <div className="not-prose my-4 rounded-lg border border-zinc-200 bg-zinc-50 px-4 py-3 text-sm dark:border-white/10 dark:bg-white/5">
      <div className="flex flex-wrap items-center gap-x-2 gap-y-1">
        <span className="font-semibold text-zinc-700 dark:text-zinc-200">
          {label}:
        </span>
        {versions.map((v, i) => <span key={`${v.name}-${v.version}-${i}`} className="inline-flex items-center gap-1 rounded-full border px-2 py-0.5 text-xs font-medium" style={getPillStyle(v.name)}>
            <span>{v.name}</span>
            <span className="opacity-70">
              {v.version}
              {v.exact ? "" : "+"}
            </span>
          </span>)}
      </div>
    </div>;
};

Minutely probes são um mecanismo para enviar [métricas personalizadas](/metrics/custom) periodicamente para o AppSignal. Esse é um sistema incluído na gem AppSignal para Ruby por padrão. No início de cada minuto, as minutely probes são acionadas uma a uma para coletar métricas e então são suspensas até o próximo minuto.

Por padrão, a gem AppSignal para Ruby habilita probes para [bibliotecas](/ruby/integrations) detectadas no seu app.

<Tip>
  **Nota**: Na gem AppSignal para Ruby 3.7.0 e versões anteriores, use o
  módulo `Appsignal::Minutely.probes` para registrar probes, em vez da nova
  API `Appsignal::Probes`.
</Tip>

## Uso

As minutely probes permitem que a gem AppSignal para Ruby colete [métricas personalizadas](/metrics/custom) por padrão para [integrações](/ruby/integrations) 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 reportar métricas sem algum tipo de tag diferenciadora, métricas globais podem ser sobrescritas por métricas em nível de instância. Por exemplo, há uma probe que rastreia o tamanho da fila local de background jobs de um app. O banco de dados de fila roda localmente na instância e os tamanhos da fila podem variar muito. Cada instância de um app reporta valores de métrica diferentes para a mesma métrica e tags, sobrescrevendo o valor da métrica a cada minuto com os da última instância que reportou.

Para remediar isso, sugerimos [marcar com tags](/metrics/custom#metric-tags) suas métricas com o hostname ou algo único para cada instância. Por exemplo, a [Sidekiq probe](/ruby/integrations/sidekiq#minutely-probe) marca as métricas com o hostname do Redis por padrão.

Alternativamente, você pode [desabilitar minutely probes](/ruby/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`](/ruby/configuration/options#option-enable_minutely_probes) para habilitá-lo 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`](/ruby/configuration/options#option-enable_minutely_probes).

## Criando probes

Se você quiser rastrear mais [métricas personalizadas](/metrics/custom) do seu app além das probes padrão que vêm com nossas [integrações](/ruby/integrations/), você pode adicionar suas próprias probes.

Uma minutely probe do AppSignal pode ser uma de três coisas. Qual dos três tipos usar para sua classe depende do caso de uso.

* [Probe Lambda](#lambda-probe)
* [Probe de classe](#class-probe)
* [Probe de classe inicializada](#initialized-class-probe)

### Probe Lambda

O tipo de probe mais simples para registrar. Se você não tem dependências para sua probe, este é o método preferido.

<CodeGroup>
  ```ruby Ruby theme={null}
  # config/initializers/appsignal.rb or a file that's loaded on boot
  Appsignal::Probes.register(:my_probe, lambda do
    Appsignal.set_gauge("database_size", 10)
  end)
  ```
</CodeGroup>

### Probe de classe

<Compatibility versions={[{ name: "AppSignal for Ruby", version: "2.9.0" }]} />

Uma probe de classe é uma probe inicializada de forma lazy. Ela só será iniciada se as minutely probes forem iniciadas. Será inicializada no início da thread de minutely probes e permanecerá inicializada enquanto seu app estiver rodando.

Este método é útil quando você não tem [`enable_minutely_probes`](/ruby/configuration/options#option-enable_minutely_probes) habilitado para todos os ambientes e não quer que seja inicializado por padrão.

<CodeGroup>
  ```ruby Ruby theme={null}
  # config/initializers/appsignal.rb or a file that's loaded on boot

  # Creating a probe using a Ruby class
  class BackgroundJobLibraryProbe
    def initialize
      # This is only called when the minutely probe gets initialized
      require "background_job_library"
      @connection = BackgroundJobLibrary.connection
    end

    def call
      stats = @connection.fetch_queue_stats
      Appsignal.set_gauge "background_job_library_queue_length", stats.queue_length
      Appsignal.set_gauge "background_job_library_processed_jobs", stats.processed_jobs
    end
  end

  # Registering a Class probe
  Appsignal::Probes.register(
    :background_job_library_probe,
    BackgroundJobLibraryProbe
  )
  ```
</CodeGroup>

### Probe de classe inicializada

<Compatibility versions={[{ name: "AppSignal for Ruby", version: "2.9.0" }]} />

Este método é mais útil para [sobrescrever probes padrão](#overriding-default-probes). A gem AppSignal para Ruby vem com algumas probes para [integrações](/ruby/integrations) por padrão. Essas probes padrão registram probes como uma [classe](#class-probe), então elas não serão inicializadas quando sobrescritas. Quando a configuração padrão da probe não se adequa ao seu caso de uso, você pode [sobrescrever uma probe padrão](#overriding-default-probes) com sua própria configuração.

Note que não registramos uma [classe como uma probe](#class-probe), mas uma instância da classe usando `.new` e passamos um objeto de configuração, ex.: `BackgroundJobLibraryProbe.new(<config>)`.

<CodeGroup>
  ```ruby Ruby theme={null}
  # config/initializers/appsignal.rb or a file that's loaded on boot
  require "background_job_library"

  # Creating a probe using a Ruby class
  class BackgroundJobLibraryProbe
    def initialize(config)
      @connection = BackgroundJobLibrary.connection(config)
    end

    def call
      stats = @connection.fetch_queue_stats
      Appsignal.set_gauge "background_job_library_queue_length", stats.queue_length
      Appsignal.set_gauge "background_job_library_processed_jobs", stats.processed_jobs
    end
  end

  # Registering an initialized Class probe
  Appsignal::Probes.register(
    :background_job_library_probe,
    BackgroundJobLibraryProbe.new(:database => "redis://localhost:6379")
  )
  ```
</CodeGroup>

## Registrando probes

<Compatibility versions={[{ name: "AppSignal for Ruby", version: "2.9.6" }]} />

Probes podem ser registradas com o método `register` no módulo `Appsignal::Probes`.
Este método aceita dois argumentos.

* `key` - Esta é a chave/nome da probe. Ela 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.

<CodeGroup>
  ```ruby Ruby theme={null}
  # config/initializers/appsignal.rb or a file that's loaded on boot

  Appsignal::Probes.register(:my_probe, lambda do
    Appsignal.set_gauge("database_size", 10)
  end)
  ```
</CodeGroup>

### Apps Rails

Recomendamos registrar suas probes em um initializer do Rails, como: `config/initializers/my_probe.rb`.

## Requisitos de dependências

<Compatibility versions={[{ name: "AppSignal for Ruby", version: "2.9.6" }]} />

Nem sempre uma probe deve ser adicionada à lista de probes por padrão. Alguma dependência pode ser necessária para que a probe funcione corretamente. Essa verificação de dependência é usada em probes incluídas na gem, mas também pode ser usada em suas próprias probes.

Ao adicionar um método de classe chamado `dependencies_present?`, uma verificação pode ser realizada antes de iniciar a probe para saber se ela deve ser iniciada ou não. Isso funciona tanto em [probes de classe](#class-probe) quanto em [probes de classe inicializada](#initialized-class-probe). Para este último cenário, não deve haver chamada à dita dependência no método `initialize` da probe, pois ela já está inicializada.

<CodeGroup>
  ```ruby Ruby theme={null}
  # config/initializers/appsignal.rb or a file that's loaded on boot
  require "background_job_library"

  # Creating a probe using a Ruby class
  class BackgroundJobLibraryProbe
    def self.dependencies_present?
      # Only start the probe if the BackgroundJobLibrary version is higher or
      # equal to 1.0.0.
      Gem::Version.new(BackgroundJobLibrary::Version) >= Gem::Version.new("1.0.0")
    end

    def initialize(config = {})
      @config = config
    end

    def call
      stats = connection.fetch_queue_stats
      Appsignal.set_gauge "background_job_library_queue_length", stats.queue_length
      Appsignal.set_gauge "background_job_library_processed_jobs", stats.processed_jobs
    end

    private

    def connection
      @connection ||= BackgroundJobLibrary.connection(@config)
    end
  end

  # Registering a Class probe with a `dependencies_present?` check
  Appsignal::Probes.register(
    :background_job_library_probe,
    BackgroundJobLibraryProbe
  )
  # Also works for initialized probes
  Appsignal::Probes.register(
    :background_job_library_probe,
    BackgroundJobLibraryProbe.new(:url => "schema://my_connection_url:9090")
  )
  ```
</CodeGroup>

## Sobrescrevendo probes padrão

O AppSignal vem com probes padrão para certas [integrações](/ruby/integrations/). Se por algum motivo essa probe não funcionar corretamente ou requerer alguma configuração adicional para o seu caso de uso, você pode sobrescrever a probe padrão [inicializando a classe da probe](#initialized-class-probe) com sua própria configuração.

Exemplo sobrescrevendo a [Sidekiq probe](/ruby/integrations/sidekiq#minutely-probe).

<CodeGroup>
  ```ruby Ruby theme={null}
  # config/initializers/appsignal.rb or a file that's loaded on boot

  Appsignal::Probes.register(
    :sidekiq, # Use the same key as the default Sidekiq probe to override it
    Appsignal::Probes::SidekiqProbe.new(:hostname => ENV["REDIS_URL"])
  )
  ```
</CodeGroup>

(Note que você precisará definir a variável de ambiente `REDIS_URL` você mesmo.)

Sobrescrever probes registrará uma mensagem de debug no [arquivo appsignal.log](/support/debugging#logs), o que pode ajudar a detectar se uma probe foi corretamente sobrescrita.

## Desregistrar probes

<Compatibility versions={[{ name: "AppSignal for Ruby", version: "3.7.1" }]} />

Para desregistrar probes previamente registradas, incluindo as probes padrão, use o método `Appsignal::Probes.unregister`. Chame o método unregister com o nome da probe para desregistrá-la.

<CodeGroup>
  ```ruby Ruby theme={null}
  Appsignal::Probes.unregister(
    :probe_name # Use the same key as used in `Probes.register` to unregister it
  )
  ```
</CodeGroup>