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

Les minutely probes sont un mécanisme permettant d'envoyer périodiquement des [métriques personnalisées](/metrics/custom) à AppSignal. C'est un système qui est inclus dans la gem Ruby AppSignal par défaut. Au début de chaque minute, les minutely probes sont déclenchées une par une pour collecter des métriques, puis mises en veille jusqu'à la minute suivante.

Par défaut, la gem Ruby AppSignal active les probes pour les [bibliothèques](/ruby/integrations) détectées pour votre application.

<Tip>
  **Remarque** : dans la gem Ruby AppSignal 3.7.0 et antérieures, utilisez le
  module `Appsignal::Minutely.probes` pour enregistrer des probes, plutôt que
  la nouvelle API `Appsignal::Probes`.
</Tip>

## Utilisation

Les minutely probes permettent à la gem Ruby AppSignal de collecter des [métriques personnalisées](/metrics/custom) par défaut pour les [intégrations](/ruby/integrations) et des métriques spécifiques à l'application en [créant votre propre probe](#creating-probes).

### Plusieurs instances

Une fois activé, le système de minutely probes s'exécute sur chaque instance d'une application. Cela signifie que si une probe signale des métriques sans une sorte de tag distinctif, les métriques globales peuvent être écrasées par des métriques au niveau de l'instance. Par exemple, il existe une probe qui suit la taille de la file d'attente locale des tâches en arrière-plan pour une application. La base de données de la file d'attente s'exécute localement sur l'instance et les tailles de file d'attente peuvent varier considérablement. Chaque instance d'une application signale des valeurs de métriques différentes pour la même métrique et les mêmes tags, en écrasant la valeur de la métrique chaque minute avec celles de la dernière instance signalant.

Pour remédier à cela, nous suggérons de [taguer](/metrics/custom#metric-tags) vos métriques avec le nom d'hôte ou autre chose d'unique pour chaque instance. Par exemple, la [probe Sidekiq](/ruby/integrations/sidekiq#minutely-probe) tague les métriques avec le nom d'hôte Redis par défaut.

Alternativement, vous pouvez [désactiver les minutely probes](/ruby/configuration/options#option-enable_minutely_probes) pour toutes les instances sauf une, sur laquelle le processus de minutely probes est exécuté. Nous suggérons d'utiliser la variable d'environnement [`APPSIGNAL_ENABLE_MINUTELY_PROBES`](/ruby/configuration/options#option-enable_minutely_probes) pour ne l'activer que sur l'instance de votre choix.

## Configuration

Les minutely probes sont configurées à l'aide de l'option de configuration [`enable_minutely_probes`](/ruby/configuration/options#option-enable_minutely_probes).

## Création de probes

Si vous voulez suivre plus de [métriques personnalisées](/metrics/custom) depuis votre application que les probes par défaut fournies avec nos [intégrations](/ruby/integrations/), vous pouvez ajouter vos propres probes.

Une minutely probe AppSignal peut être l'une des trois choses suivantes. Le type à utiliser pour votre classe dépend du cas d'utilisation.

* [Lambda probe](#lambda-probe)
* [Class probe](#class-probe)
* [Initialized class probe](#initialized-class-probe)

### Lambda probe

Le type de probe le plus simple à enregistrer. Si vous n'avez pas de dépendances pour votre probe, c'est la méthode préférée.

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

### Class probe

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

Une class probe est une probe initialisée paresseusement. Elle ne sera démarrée que si les minutely probes sont démarrées. Elle sera initialisée au début du thread des minutely probes et restera initialisée tant que votre application est en cours d'exécution.

Cette méthode est utile lorsque vous n'avez pas [`enable_minutely_probes`](/ruby/configuration/options#option-enable_minutely_probes) activé pour chaque environnement et que vous ne voulez pas qu'il soit initialisé par défaut.

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

### Initialized class probe

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

Cette méthode est particulièrement utile pour [remplacer les probes par défaut](#overriding-default-probes). La gem Ruby AppSignal livre certaines probes pour les [intégrations](/ruby/integrations) par défaut. Ces probes par défaut enregistrent les probes en tant que [classe](#class-probe) afin qu'elles ne soient pas initialisées lorsqu'elles sont remplacées. Lorsque la configuration par défaut de la probe ne correspond pas à votre cas d'utilisation, vous pouvez [remplacer une probe par défaut](#overriding-default-probes) avec votre propre configuration.

Notez que nous n'enregistrons pas une [classe en tant que probe](#class-probe), mais une instance de la classe en utilisant `.new` et en passant un objet de configuration, par exemple `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>

## Enregistrement des probes

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

Les probes peuvent être enregistrées avec la méthode `register` du module `Appsignal::Probes`.
Cette méthode accepte deux arguments.

* `key` - C'est la clé/le nom de la probe. Elle sera utilisée pour identifier la probe en cas d'erreur lors de l'exécution de la probe (qui sera enregistrée dans le [fichier appsignal.log](/support/debugging#logs)) et pour [remplacer une probe existante](#overriding-default-probes).
* `probe` - C'est l'un des [types de probes pris en charge](#creating-probes) qui doit être appelé chaque minute pour collecter des métriques.

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

### Applications Rails

Nous recommandons d'enregistrer vos probes dans un initializer Rails, comme : `config/initializers/my_probe.rb`.

## Exigences de dépendance

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

Il ne faut pas toujours ajouter une probe à la liste des probes par défaut. Une dépendance peut être requise pour que la probe fonctionne correctement. Cette vérification de dépendance est utilisée dans les probes livrées avec la gem, mais peut également être utilisée dans vos propres probes.

En ajoutant une méthode de classe appelée `dependencies_present?`, une vérification peut être effectuée avant le démarrage de la probe pour savoir si elle doit être démarrée ou non. Cela fonctionne à la fois pour les [class probes](#class-probe) et les [initialized class probes](#initialized-class-probe). Pour ce dernier scénario, il ne devrait pas y avoir d'appel à ladite dépendance dans la méthode `initialize` de la probe car elle est déjà initialisée.

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

## Remplacement des probes par défaut

AppSignal livre des probes par défaut pour certaines [intégrations](/ruby/integrations/). Si pour une raison quelconque cette probe ne fonctionne pas correctement ou nécessite une configuration supplémentaire pour votre cas d'utilisation, vous pouvez remplacer la probe par défaut en [initialisant la classe de probe](#initialized-class-probe) avec votre propre configuration.

Exemple de remplacement de la [probe Sidekiq](/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>

(Notez que vous devrez définir vous-même la variable d'environnement `REDIS_URL`.)

Le remplacement des probes enregistrera un message de debug dans le [fichier appsignal.log](/support/debugging#logs) qui peut aider à détecter si une probe est correctement remplacée.

## Désenregistrer les probes

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

Pour désenregistrer des probes précédemment enregistrées, y compris les probes par défaut, utilisez la méthode `Appsignal::Probes.unregister`. Appelez la méthode unregister avec le nom de la probe pour la désenregistrer.

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