> ## 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 sind ein Mechanismus, um regelmäßig [benutzerdefinierte Metriken](/metrics/custom) an AppSignal zu senden. Dies ist ein System, das standardmäßig im AppSignal Ruby-Gem enthalten ist. Zu Beginn jeder Minute werden die Minutely-Probes nacheinander ausgelöst, um Metriken zu sammeln, und dann bis zur nächsten Minute pausiert.

Standardmäßig aktiviert das AppSignal Ruby-Gem Probes für [Bibliotheken](/ruby/integrations), die für Ihre App erkannt werden.

<Tip>
  **Hinweis**: In AppSignal Ruby-Gem 3.7.0 und niedriger verwenden Sie das Modul
  `Appsignal::Minutely.probes`, um Probes zu registrieren, anstelle der neuen
  `Appsignal::Probes`-API.
</Tip>

## Verwendung

Die Minutely-Probes ermöglichen es dem AppSignal Ruby-Gem, standardmäßig [benutzerdefinierte Metriken](/metrics/custom) für [Integrationen](/ruby/integrations) und app-spezifische Metriken durch [Erstellen Ihrer eigenen Probe](#creating-probes) zu sammeln.

### Mehrere Instanzen

Einmal aktiviert, läuft das Minutely-Probes-System auf jeder Instanz einer App. Das bedeutet, wenn eine Probe Metriken ohne eine Art unterscheidendes Tag meldet, können globale Metriken durch Metriken auf Instanzebene überschrieben werden. Beispielsweise gibt es eine Probe, die verfolgt, wie groß die lokale Hintergrundjob-Queue für eine App ist. Die Queue-Datenbank läuft lokal auf der Instanz, und die Queue-Größen können stark variieren. Jede Instanz einer App meldet unterschiedliche Metrikwerte für dieselbe Metrik und dieselben Tags, was den Metrikwert jede Minute mit denen der zuletzt meldenden Instanz überschreibt.

Um Abhilfe zu schaffen, schlagen wir vor, Ihre Metriken mit dem Hostnamen oder etwas anderem [zu taggen](/metrics/custom#metric-tags), das für jede Instanz einzigartig ist. Beispielsweise taggt die [Sidekiq-Probe](/ruby/integrations/sidekiq#minutely-probe) Metriken standardmäßig mit dem Redis-Hostnamen.

Alternativ können Sie [Minutely-Probes deaktivieren](/ruby/configuration/options#option-enable_minutely_probes) für alle Instanzen außer einer, auf der der Minutely-Probes-Prozess läuft. Wir empfehlen die Verwendung der Umgebungsvariable [`APPSIGNAL_ENABLE_MINUTELY_PROBES`](/ruby/configuration/options#option-enable_minutely_probes), um sie nur auf der Instanz Ihrer Wahl zu aktivieren.

## Konfiguration

Die Minutely-Probes werden mit der Konfigurationsoption [`enable_minutely_probes`](/ruby/configuration/options#option-enable_minutely_probes) konfiguriert.

## Probes erstellen

Wenn Sie mehr [benutzerdefinierte Metriken](/metrics/custom) aus Ihrer App verfolgen möchten als die mit unseren [Integrationen](/ruby/integrations/) ausgelieferten Standard-Probes, können Sie eigene Probe(s) hinzufügen.

Eine AppSignal-Minutely-Probe kann eines von drei Dingen sein. Welcher der drei Typen für Ihre Klasse verwendet werden soll, hängt vom Anwendungsfall ab.

* [Lambda-Probe](#lambda-probe)
* [Klassen-Probe](#class-probe)
* [Initialisierte Klassen-Probe](#initialized-class-probe)

### Lambda-Probe

Der einfachste Probe-Typ zum Registrieren. Wenn Sie keine Abhängigkeiten für Ihre Probe haben, ist dies die bevorzugte Methode.

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

### Klassen-Probe

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

Eine Klassen-Probe ist eine lazy initialisierte Probe. Sie wird nur gestartet, wenn die Minutely-Probes gestartet werden. Sie wird zu Beginn des Minutely-Probes-Threads initialisiert und bleibt initialisiert, solange Ihre App läuft.

Diese Methode ist nützlich, wenn Sie [`enable_minutely_probes`](/ruby/configuration/options#option-enable_minutely_probes) nicht für jede Umgebung aktiviert haben und nicht möchten, dass sie standardmäßig initialisiert wird.

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

### Initialisierte Klassen-Probe

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

Diese Methode ist am nützlichsten zum [Überschreiben von Standard-Probes](#overriding-default-probes). Das AppSignal Ruby-Gem liefert einige Probes für [Integrationen](/ruby/integrations) standardmäßig mit. Diese Standard-Probes registrieren Probes als [Klasse](#class-probe), sodass sie beim Überschreiben nicht initialisiert werden. Wenn die Standardkonfiguration der Probe nicht zu Ihrem Anwendungsfall passt, können Sie eine [Standard-Probe überschreiben](#overriding-default-probes) mit Ihrer eigenen Konfiguration.

Beachten Sie, dass wir keine [Klasse als Probe](#class-probe) registrieren, sondern eine Instanz der Klasse mit `.new` und ein Konfigurationsobjekt übergeben, z. B. `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>

## Probes registrieren

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

Probes können mit der `register`-Methode des Moduls `Appsignal::Probes` registriert werden.
Diese Methode akzeptiert zwei Argumente.

* `key` - Dies ist der Key/Name der Probe. Er wird verwendet, um die Probe zu identifizieren, falls beim Ausführen der Probe ein Fehler auftritt (der in der [appsignal.log-Datei](/support/debugging#logs) protokolliert wird) und um [eine bestehende Probe zu überschreiben](#overriding-default-probes).
* `probe` - Dies ist einer der [unterstützten Probe-Typen](#creating-probes), der jede Minute aufgerufen werden soll, um Metriken zu sammeln.

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

### Rails-Apps

Wir empfehlen, Ihre Probes in einem Rails-Initializer zu registrieren, z. B.: `config/initializers/my_probe.rb`.

## Abhängigkeitsanforderungen

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

Nicht jede Probe sollte standardmäßig zur Liste der Probes hinzugefügt werden. Manche Abhängigkeit kann erforderlich sein, damit die Probe ordnungsgemäß funktioniert. Diese Abhängigkeitsprüfung wird in den im Gem gelieferten Probes verwendet, kann aber auch in Ihren eigenen Probes verwendet werden.

Durch Hinzufügen einer Klassenmethode mit dem Namen `dependencies_present?` kann vor dem Start der Probe geprüft werden, ob sie gestartet werden soll. Dies funktioniert sowohl bei [Klassen-Probes](#class-probe) als auch bei [initialisierten Klassen-Probes](#initialized-class-probe). Im letzteren Szenario sollte es in der `initialize`-Methode der Probe keinen Aufruf an die genannte Abhängigkeit geben, da diese bereits initialisiert ist.

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

## Standard-Probes überschreiben

AppSignal wird mit Standard-Probes für bestimmte [Integrationen](/ruby/integrations/) ausgeliefert. Wenn diese Probe aus irgendeinem Grund nicht ordnungsgemäß funktioniert oder zusätzliche Konfiguration für Ihren Anwendungsfall benötigt, können Sie die Standard-Probe überschreiben, indem Sie [die Probe-Klasse mit Ihrer eigenen Konfiguration initialisieren](#initialized-class-probe).

Beispiel zum Überschreiben der [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>

(Beachten Sie, dass Sie die Umgebungsvariable `REDIS_URL` selbst setzen müssen.)

Das Überschreiben von Probes protokolliert eine Debug-Nachricht in der [appsignal.log-Datei](/support/debugging#logs), die helfen kann zu erkennen, ob eine Probe korrekt überschrieben wurde.

## Probes deregistrieren

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

Um zuvor registrierte Probes, einschließlich der Standard-Probes, zu deregistrieren, verwenden Sie die Methode `Appsignal::Probes.unregister`. Rufen Sie die unregister-Methode mit dem Namen der Probe auf, um sie zu deregistrieren.

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