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

# AppSignal Wrap für die Prozessüberwachung

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

AppSignal stellt `appsignal-wrap` bereit, ein Tool zur Überwachung beliebiger Prozesse, die auf Ihrem Server laufen, wie Ihre Cronjobs, Ihr Datenbankserver oder andere Prozesse, die zu Ihrer Anwendung gehören.

Das `appsignal-wrap`-Tool integriert sich nahtlos mit den Cron- und Heartbeat-Prozessmonitoren, dem Logging und der Fehlerberichterstattung von AppSignal. Es kann verwendet werden, um jeden auf Ihren Servern laufenden Prozess zu überwachen, unabhängig von der Sprache oder dem Framework, in dem er geschrieben ist.

### AppSignal Wrap hilft, Fragen wie diese zu beantworten:

<div style={{ display: 'flex', alignItems: 'center', gap: '12px', marginBottom: '12px' }}>
  <span style={{ display: 'inline-flex', alignItems: 'center', justifyContent: 'center', width: '32px', height: '32px', minWidth: '32px', backgroundColor: '#dcfce7', borderRadius: '8px' }}>
    <Icon icon="check" color="#22c55e" />
  </span>

  <span>Läuft mein Datenbankprozess?</span>
</div>

<div style={{ display: 'flex', alignItems: 'center', gap: '12px', marginBottom: '12px' }}>
  <span style={{ display: 'inline-flex', alignItems: 'center', justifyContent: 'center', width: '32px', height: '32px', minWidth: '32px', backgroundColor: '#dcfce7', borderRadius: '8px' }}>
    <Icon icon="check" color="#22c55e" />
  </span>

  <span>Läuft mein Cronjob pünktlich?</span>
</div>

<div style={{ display: 'flex', alignItems: 'center', gap: '12px', marginBottom: '12px' }}>
  <span style={{ display: 'inline-flex', alignItems: 'center', justifyContent: 'center', width: '32px', height: '32px', minWidth: '32px', backgroundColor: '#dcfce7', borderRadius: '8px' }}>
    <Icon icon="check" color="#22c55e" />
  </span>

  <span>Was ist mit meinem Backup-Skript schiefgelaufen?</span>
</div>

<div style={{ display: 'flex', alignItems: 'center', gap: '12px', marginBottom: '12px' }}>
  <span style={{ display: 'inline-flex', alignItems: 'center', justifyContent: 'center', width: '32px', height: '32px', minWidth: '32px', backgroundColor: '#dcfce7', borderRadius: '8px' }}>
    <Icon icon="check" color="#22c55e" />
  </span>

  <span>Konnte mein Anwendungsserver nicht gestartet werden?</span>
</div>

### Kern-Funktionen von appsignal-wrap

Nach der Installation von `appsignal-wrap` können Sie das Tool verwenden, um Prozesse zu starten, die Sie überwachen möchten. Das `appsignal-wrap`-Tool wird dann:

<div style={{ display: 'flex', alignItems: 'flex-start', gap: '12px', marginBottom: '12px' }}>
  <span style={{ display: 'inline-flex', alignItems: 'center', justifyContent: 'center', width: '32px', height: '32px', minWidth: '32px', backgroundColor: '#fce7f3', borderRadius: '8px' }}>
    <Icon icon="line-columns" color="#ec4899" />
  </span>

  <span>Die Standardausgabe und den Standardfehler des Prozesses als Logs melden, die Sie in [AppSignal Logging](/logging) filtern und abfragen können.</span>
</div>

<div style={{ display: 'flex', alignItems: 'flex-start', gap: '12px', marginBottom: '12px' }}>
  <span style={{ display: 'inline-flex', alignItems: 'center', justifyContent: 'center', width: '32px', height: '32px', minWidth: '32px', backgroundColor: '#dbeafe', borderRadius: '8px' }}>
    <Icon icon="square-check" iconType="solid" color="#3b82f6" />
  </span>

  <span>[Cron-Prozessmonitore](/check-ins) senden, um zu melden, dass der Prozess erfolgreich gestartet und beendet wurde, oder [Heartbeat-Prozessmonitore](/check-ins), um seine Verfügbarkeit zu verfolgen.</span>
</div>

<div style={{ display: 'flex', alignItems: 'flex-start', gap: '12px', marginBottom: '12px' }}>
  <span style={{ display: 'inline-flex', alignItems: 'center', justifyContent: 'center', width: '32px', height: '32px', minWidth: '32px', backgroundColor: '#fee2e2', borderRadius: '8px' }}>
    <Icon icon="siren-on" iconType="solid" color="#ef4444" />
  </span>

  <span>Fehlschlag-Exit-Status als Fehler an AppSignal melden.</span>
</div>

## Installation

Der einfachste Weg, `appsignal-wrap` zu installieren, ist die Ausführung des folgenden Befehls:

<CodeGroup>
  ```bash Bash theme={null}
  curl -sSL https://github.com/appsignal/appsignal-wrap/releases/latest/download/install.sh | sudo sh
  ```
</CodeGroup>

Der Befehl lädt automatisch die neueste Version von `appsignal-wrap` für Ihr Betriebssystem und Ihre Architektur herunter und installiert sie in den `$PATH` Ihres Servers.

Sowohl Linux als auch macOS werden unterstützt, in den Architekturen x86 64-Bit (Intel) und ARM 64-Bit (Apple Silicon). Alpine Linux wird ebenfalls durch unsere `musl`-fähigen Builds für beide Architekturen unterstützt.

Alternativ können Sie die neueste Version von der [GitHub Releases-Seite](https://github.com/appsignal/appsignal-wrap/releases/latest/) für Ihr Betriebssystem und Ihre Architektur herunterladen und manuell in den `$PATH` Ihres Servers installieren.

## Verwendung

Um einen Prozess mit `appsignal-wrap` zu überwachen, übergeben Sie den Befehl, den Sie überwachen möchten, als letztes Argument an `appsignal-wrap`. Zum Beispiel:

<CodeGroup>
  ```sh Shell theme={null}
  export APPSIGNAL_APP_PUSH_API_KEY=[APP_LEVEL_API_KEY]
  appsignal-wrap [NAME] -- [COMMAND]
  ```
</CodeGroup>

Im obigen Beispiel ist `[NAME]` der Name, den Sie verwenden möchten, um den Prozess in AppSignal zu identifizieren, und `[COMMAND]` ist der Befehl, den Sie überwachen möchten. Sowohl der Name als auch der Befehl sind erforderlich. Zum Beispiel:

<CodeGroup>
  ```sh Shell theme={null}
  appsignal-wrap backup-script -- bash /var/app/backup.sh
  ```
</CodeGroup>

Sie benötigen einen AppSignal App-Level API-Schlüssel, den Sie in den ["Push & Deploy"](https://appsignal.com/redirect-to/app?to=api_keys\&key_tab=app)-Einstellungen Ihrer AppSignal-App finden.

Sie können ihn als Argument für die Befehlszeilenoption `--api-key` oder als Umgebungsvariable `APPSIGNAL_APP_PUSH_API_KEY` an `appsignal-wrap` übergeben.

Standardmäßig meldet `appsignal-wrap` die Standardausgabe und den Standardfehler des Prozesses als Logs an AppSignal und meldet alle Fehlschlag-Exit-Status als Fehler an AppSignal.

<span id="check-ins" />

## Prozessüberwachung

<Tip>
  [Lesen Sie unsere Dokumentation zur Prozessüberwachung](/check-ins) für weitere Informationen
  darüber, wie die AppSignal-Prozessüberwachung funktioniert.
</Tip>

Standardmäßig sendet `appsignal-wrap` keine Prozessüberwachungs-Events. Sie können die Befehlszeilenoptionen `--cron`
oder `--heartbeat` verwenden, um Cron- bzw. Heartbeat-Prozessüberwachungen zu aktivieren.

Das Tool `appsignal-wrap` verwendet den als erstes Argument angegebenen Namen als Bezeichner für die Prozessüberwachung. Um beispielsweise Cron-Prozessüberwachungs-Events mit `backup-script` als Bezeichner für die Prozessüberwachung zu melden:

<CodeGroup>
  ```sh Shell theme={null}
  appsignal-wrap backup-script --cron -- bash /var/app/backup.sh
  ```
</CodeGroup>

### Cron-Prozessüberwachungen

Bei Verwendung von `--cron` zum Senden von Cron-Prozessüberwachungen sendet `appsignal-wrap` ein Start-Cron-Prozessüberwachungs-Event, wenn der Prozess startet, und ein Finish-Cron-Prozessüberwachungs-Event, wenn der Prozess erfolgreich beendet wird.

Wenn der Prozess mit einem Fehler-Exit-Status beendet wird, sendet `appsignal-wrap` kein Finish-Cron-Prozessüberwachungs-Event.

### Heartbeat-Prozessüberwachungen

Bei Verwendung von `--heartbeat` zum Senden von Heartbeat-Prozessüberwachungen sendet `appsignal-wrap` während der Lebensdauer des Prozesses kontinuierlich Heartbeat-Prozessüberwachungs-Events.

### Benutzerdefinierter Bezeichner

Um Prozessüberwachungs-Events mit einem anderen Bezeichner als dem als erstes Argument angegebenen Namen an AppSignal zu senden, können Sie einen anderen Bezeichner als Argument an die Befehlszeilenoptionen `--cron` oder `--heartbeat` übergeben. Zum Beispiel:

<CodeGroup>
  ```sh Shell theme={null}
  appsignal-wrap backup --cron daily-backup -- bash /var/app/backup.sh
  ```
</CodeGroup>

Im obigen Beispiel sendet `appsignal-wrap` Cron-Prozessüberwachungs-Events mit `daily-backup` als Bezeichner für die Prozessüberwachung, verwendet aber weiterhin `backup` als Namen zur Identifizierung des Prozesses bei der Meldung von Logs und Fehlern.

## Logging

Standardmäßig sendet `appsignal-wrap` sowohl die Standardausgabe als auch die Standardfehlerausgabe des überwachten Prozesses als Logs an AppSignal. Die Logs erscheinen unter der Quelle "application", und der als erstes Argument angegebene Name wird als Log-Gruppe verwendet.

### Logging deaktivieren

Um das Senden entweder der Standardausgabe oder der Standardfehlerausgabe als Logs zu deaktivieren, können Sie die Befehlszeilenoptionen `--no-stdout` bzw. `--no-stderr` verwenden.

Um das Senden von Logs vollständig zu deaktivieren, können Sie die Befehlszeilenoption `--no-log` verwenden.

### Benutzerdefinierte Log-Gruppe

Um Logs als andere Log-Gruppe zu senden, können Sie diese als Argument an die Befehlszeilenoption `--log` übergeben. Zum Beispiel:

<CodeGroup>
  ```sh Shell theme={null}
  appsignal-wrap mysql --log db -- mysqld
  ```
</CodeGroup>

Im obigen Beispiel verwendet `appsignal-wrap` `db` als Log-Gruppe beim Senden von Logs an AppSignal, verwendet aber weiterhin `mysql` als Namen zur Identifizierung des Prozesses bei der Meldung von Prozessüberwachungen und Fehlern.

### Benutzerdefinierte Log-Quelle

Um Logs an eine andere Log-Quelle zu senden, können Sie den API-Schlüssel der Log-Quelle, den Sie beim [Erstellen einer Log-Quelle](https://docs.appsignal.com/logging/configuration.html#creating-a-log-source) erhalten, als Argument an die Befehlszeilenoption `--log-source` oder als Umgebungsvariable `APPSIGNAL_LOG_SOURCE_API_KEY` übergeben. Zum Beispiel:

<CodeGroup>
  ```sh Shell theme={null}
  export APPSIGNAL_LOG_SOURCE_API_KEY=[LOG_SOURCE_API_KEY]
  appsignal-wrap mysql -- mysqld
  ```
</CodeGroup>

## Fehlerberichterstattung

Standardmäßig meldet `appsignal-wrap` alle Fehlschlag-Exit-Status des überwachten Prozesses als Fehler an AppSignal. Die Fehler werden nach dem als erstes Argument angegebenen Namen gruppiert.

### Fehlerberichterstattung deaktivieren

Um die Fehlerberichterstattung vollständig zu deaktivieren, können Sie die Befehlszeilenoption `--no-error` verwenden.

### Ausgabe in Fehlermeldungen

Beim Melden von Fehlern an AppSignal nimmt `appsignal-wrap` die letzten Zeilen der Standardausgabe und des Standardfehlers des Prozesses als Fehlermeldung auf.

Die Verwendung der Befehlszeilenoptionen `--no-stdout` oder `--no-stderr` verhindert, dass die Standardausgabe oder der Standardfehler in die Fehlermeldung aufgenommen wird.

Die Verwendung beider Optionen verhindert, dass irgendwelche Logs in die Fehlermeldung aufgenommen werden.

### Benutzerdefinierte Fehlergruppierung

Um Fehler anders zu gruppieren, können Sie einen anderen Namen als Argument an die Befehlszeilenoption `--error` übergeben. Zum Beispiel:

<CodeGroup>
  ```sh Shell theme={null}
  appsignal-wrap backup --error user-backup -- bash /var/app/backup.sh --only-users
  ```
</CodeGroup>

Im obigen Beispiel meldet `appsignal-wrap` Fehler mit `user-backup` als Fehlergruppe, verwendet aber weiterhin `backup` als Namen zur Identifizierung des Prozesses beim Melden von Logs und Prozessmonitoren.

### Anwendungs-Revision

<Compatibility versions={[{ name: "AppSignal Wrap", version: "0.3.1" }]} />

Wenn eine Revision über das Flag `--revision` oder die Umgebungsvariable `APPSIGNAL_REVISION` angegeben wird, werden Fehler mit dem Deployment für diese Revision gruppiert.

## Prozessverhalten

Das `appsignal-wrap`-Tool soll *transparent* sein -- das heißt, das Ausführen eines Befehls über `appsignal-wrap` sollte das gleiche Verhalten haben wie das Ausführen desselben Befehls allein.

<Note>
  Nachdem der überwachte Prozess beendet ist, wartet `appsignal-wrap` eine kurze Zeit *(in der Regel eine Sekunde oder weniger)*, bevor es beendet wird, um sicherzustellen, dass alle Logs und Prozessmonitore an AppSignal gesendet werden.

  Wenn `appsignal-wrap` in einer Schleife aufgerufen wird, kann die durch diese Wartezeit verursachte Verzögerung dazu führen, dass die Schleife langsamer als erwartet läuft.
</Note>

### Umgebungsvariablen

Der Prozess erbt automatisch die Umgebungsvariablen des `appsignal-wrap`-Elternprozesses.

### Exit-Status

Wenn der überwachte Prozess mit einem Exit-Code beendet wird, beendet `appsignal-wrap` sich mit demselben Fehlschlag-Exit-Code.

Wenn der überwachte Prozess durch ein Signal beendet wird, beendet `appsignal-wrap` sich mit einem Fehlschlag-Exit-Code von `128 + signal`, wobei `signal` die Nummer ist, die das Signal repräsentiert, das den Prozess zum Beenden gebracht hat. Das Signal, das diese Nummer repräsentiert, ist betriebssystemspezifisch.

### Eingabe und Ausgabe

Der Prozess erbt seinen Standardeingabe-Deskriptor automatisch vom `appsignal-wrap`-Elternprozess.

Zusätzlich zur Meldung an AppSignal werden die Standardausgabe und der Standardfehler des Prozesses an die Standardausgabe und den Standardfehler des `appsignal-wrap`-Elternprozesses weitergeleitet.

Bei der Verwendung von `--no-stdout` oder `--no-stderr` erbt der Prozess automatisch den Standardausgabe- bzw. Standardfehler-Deskriptor des `appsignal-wrap`-Elternprozesses.

Das bedeutet, dass Sie `appsignal-wrap` in einer Pipeline verwenden oder seine Ausgabe in eine Datei umleiten können, zum Beispiel:

<CodeGroup>
  ```sh Shell theme={null}
  # Without monitoring
  grep "active" customers.csv \
      | python /var/app/import.py \
      > /var/log/import.log

  # With monitoring
  grep "active" customers.csv \
      | appsignal-wrap import-customers -- python /var/app/import.py \
      > /var/log/import.log
  ```
</CodeGroup>

### Signale

Wenn der `appsignal-wrap`-Prozess ein Signal empfängt, das verarbeitet werden kann, leitet er es an den überwachten Prozess weiter.

Beispielsweise führt das Senden eines `SIGTERM`-Signals an den `appsignal-wrap`-Elternprozess dazu, dass der überwachte Prozess ein `SIGTERM`-Signal empfängt.

Wenn der `appsignal-wrap`-Elternprozess ein Signal empfängt, das nicht verarbeitet werden kann, wie z. B. `SIGKILL` und `SIGSTOP`, oder wenn er unerwartet abstürzt, wird ein `SIGTERM`-Signal an den überwachten Prozess gesendet.