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

# Minütliche Probes

Minütliche Probes sind ein Mechanismus, um periodisch [benutzerdefinierte Metriken](/metrics/custom) an AppSignal zu senden. Dieses System ist standardmäßig im AppSignal-Elixir-Paket enthalten. Zu Beginn jeder Minute werden die minütlichen Probes ausgelöst, um Metriken zu erfassen, und dann bis zur nächsten Minute pausiert.

Standardmäßig aktiviert das AppSignal-Elixir-Paket eine Probe für die ErlangVM.

<Tip>
  **Hinweis**: Wir empfehlen die Verwendung des AppSignal-Elixir-Pakets `1.10.1` und höher, wenn
  Sie diese Funktion nutzen.
</Tip>

## Verwendung

Die minütlichen Probes ermöglichen es dem AppSignal-Elixir-Paket, standardmäßig [benutzerdefinierte Metriken](/metrics/custom) für die ErlangVM zu sammeln und app-spezifische Metriken durch [Erstellen eigener Probes](#creating-probes).

### Mehrere Instanzen

Nach der Aktivierung läuft das System der minütlichen Probes auf jeder Instanz einer App. Das bedeutet, dass globale Metriken durch instanzbezogene Metriken überschrieben werden können, wenn eine Probe Metriken ohne eine Art differenzierendes Tag meldet.

Um dies zu beheben, empfehlen wir, Ihre Metriken mit dem Hostnamen oder etwas anderem, das für jede Instanz eindeutig ist, zu [taggen](/metrics/custom#metric-tags). Beispielsweise taggt die ErlangVM-Probe Metriken standardmäßig mit dem Hostnamen.

Alternativ können Sie [minütliche Probes deaktivieren](/elixir/configuration/options#option-enable_minutely_probes) für alle außer einer Instanz, auf der der Prozess der minütlichen Probes ausgeführt wird. Wir empfehlen die Verwendung der Umgebungsvariable [`APPSIGNAL_ENABLE_MINUTELY_PROBES`](/elixir/configuration/options#option-enable_minutely_probes), um sie nur auf der Instanz Ihrer Wahl zu aktivieren.

## Konfiguration

Die minütlichen Probes werden mit der Konfigurationsoption [`enable_minutely_probes`](/elixir/configuration/options#option-enable_minutely_probes) konfiguriert. Der Standardwert ist `true`.

## Probes erstellen

Wenn Sie mehr [benutzerdefinierte Metriken](/metrics/custom) aus Ihrer App verfolgen möchten als unsere Standard-Probes, können Sie Ihre eigene(n) Probe(s) hinzufügen.

Eine minütliche AppSignal-Probe kann eine [anonyme Funktion](#anonymous-function) oder eine [modulbasierte Funktion](#module-based-function) sein.

### Anonyme Funktion

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

<CodeGroup>
  ```elixir Elixir theme={null}
  Appsignal.Probes.register(:my_probe, fn ->
    Appsignal.set_gauge("database_size", 10)
  end)
  ```
</CodeGroup>

### Modulbasierte Funktion

Eine modulbasierte Funktion kann nützlich sein, wenn Sie eine komplexere Probe haben oder eine Probe mit Abhängigkeiten.

<CodeGroup>
  ```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
  ```
</CodeGroup>

Jetzt können Sie diese Probe in der Start-Funktion Ihrer OTP-App registrieren.

<CodeGroup>
  ```elixir Elixir theme={null}
  Appsignal.Probes.register(:my_probe, &MyApp.MyProbe.call/0)
  ```
</CodeGroup>

### Zustandsbehaftete Probes

Ab Version `2.2.8` des AppSignal-Elixir-Pakets können Probes Zustand zwischen Läufen weitergeben. Wenn Ihre Probe ein Argument annimmt, wird der Rückgabewert des letzten Laufs als Wert für dieses Argument im nächsten Lauf übergeben.

Ein initialer Zustand, der für den ersten Lauf der Probe verwendet werden soll, kann als drittes Argument an `Appsignal.Probes.register` übergeben werden. Wenn er nicht angegeben wird, ist der initiale Zustand `nil`.

<CodeGroup>
  ```elixir Elixir theme={null}
  Appsignal.Probes.register(:stateful_probe, fn minutes ->
    Appsignal.set_gauge("uptime_minutes", minutes)
    minutes + 1
  end, 0)
  ```
</CodeGroup>

Oder als modulbasierte Funktion:

<CodeGroup>
  ```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
  ```
</CodeGroup>

Die Sie dann wie folgt registrieren können:

<CodeGroup>
  ```elixir Elixir theme={null}
  Appsignal.Probes.register(:stateful_probe, &MyApp.MyProbe.call/1, 0)
  ```
</CodeGroup>

## Probes registrieren

Probes können mit der `register`-Methode im Modul `Appsignal.Probes` registriert werden.
Diese Methode akzeptiert drei Argumente.

* `key` – Dies ist der Schlüssel/Name der Probe. Er wird verwendet, um die Probe zu identifizieren, falls beim Ausführen der Probe ein Fehler auftritt (der in die [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 erfassen.
* `state` – Dies ist der initiale Zustand, der an Ihre Probe übergeben wird. Wenn Ihre Probe keinen Zustand als Argument annimmt, hat dieses Argument keine Wirkung. Es ist ein optionales Argument, und sein Standardwert ist `nil`.

Um eine Probe hinzuzufügen, registrieren Sie sie in der `start/2`-Funktion Ihrer Anwendung, kurz bevor der Supervisor gestartet wird.

In einer Phoenix-App sieht das so aus:

<CodeGroup>
  ```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
  ```
</CodeGroup>

## Standard-Probes überschreiben

AppSignal liefert Standard-Probes für bestimmte [Integrationen](/elixir/integrations/). Wenn diese Probe aus irgendeinem Grund nicht ordnungsgemäß funktioniert oder zusätzliche Konfiguration für Ihren Anwendungsfall erfordert, können Sie die Standard-Probe überschreiben, indem Sie eine neue Probe mit demselben Schlüssel registrieren.

<CodeGroup>
  ```elixir Elixir theme={null}
  # lib/my_app/application.ex

  Appsignal.Probes.register(:erlang, fn() ->
    # Do things
  end)
  ```
</CodeGroup>

Das Überschreiben von Probes wird eine Debug-Meldung in die [appsignal.log-Datei](/support/debugging#logs) protokollieren, was dabei helfen kann festzustellen, ob eine Probe korrekt überschrieben wurde.