> ## 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 pour la surveillance de processus

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 fournit `appsignal-wrap`, un outil pour surveiller tout processus s'exécutant sur votre serveur, tel que vos tâches cron, votre serveur de base de données ou tout autre processus lié à votre application.

L'outil `appsignal-wrap` s'intègre parfaitement avec les moniteurs de processus cron et heartbeat d'AppSignal, le logging et le rapport d'erreurs. Il peut être utilisé pour surveiller tout processus s'exécutant sur vos serveurs, quel que soit le langage ou le framework dans lequel il est écrit.

### AppSignal Wrap aide à répondre à des questions telles que :

<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>Mon processus de base de données est-il opérationnel ?</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>Ma tâche cron s'exécute-t-elle à l'heure ?</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>Qu'est-ce qui s'est mal passé avec mon script de sauvegarde ?</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>Mon serveur d'application a-t-il échoué à démarrer ?</span>
</div>

### Fonctionnalités principales d'appsignal-wrap

Après avoir installé `appsignal-wrap`, vous pouvez utiliser l'outil pour démarrer les processus que vous souhaitez surveiller. L'outil `appsignal-wrap` va ensuite :

<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>Rapporter la sortie standard et l'erreur standard du processus, en tant que logs que vous pouvez filtrer et interroger sur [AppSignal Logging](/logging).</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>Envoyer des [moniteurs de processus cron](/check-ins) pour rapporter que le processus a démarré et s'est terminé avec succès, ou des [moniteurs de processus heartbeat](/check-ins) pour suivre son uptime.</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>Rapporter les statuts de sortie d'échec en tant qu'erreurs à AppSignal.</span>
</div>

## Installation

La façon la plus simple d'installer `appsignal-wrap` est d'exécuter la commande suivante :

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

La commande téléchargera automatiquement la dernière version d'`appsignal-wrap` pour votre OS (système d'exploitation) et architecture, et l'installera dans le `$PATH` de votre serveur.

Linux et macOS sont tous deux pris en charge, dans les architectures x86 64-bit (Intel) et ARM 64-bit (Apple Silicon). Alpine Linux est également pris en charge via nos builds activés pour `musl` pour les deux architectures.

Alternativement, vous pouvez télécharger la dernière version depuis la [page de releases GitHub](https://github.com/appsignal/appsignal-wrap/releases/latest/) pour votre système d'exploitation et architecture, et l'installer manuellement dans le `$PATH` de votre serveur.

## Utilisation

Pour surveiller un processus avec `appsignal-wrap`, vous passez la commande que vous souhaitez surveiller en dernier argument à `appsignal-wrap`. Par exemple :

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

Dans l'exemple ci-dessus, `[NAME]` est le nom que vous souhaitez utiliser pour identifier le processus dans AppSignal, et `[COMMAND]` est la commande que vous souhaitez surveiller. Le nom et la commande sont tous deux requis. Par exemple :

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

Vous aurez besoin d'une clé API au niveau de l'application AppSignal, que vous pouvez trouver dans les paramètres [« Push & Deploy »](https://appsignal.com/redirect-to/app?to=api_keys\&key_tab=app) de votre application AppSignal.

Vous pouvez la fournir à `appsignal-wrap` comme argument de l'option en ligne de commande `--api-key`, ou comme variable d'environnement `APPSIGNAL_APP_PUSH_API_KEY`.

Par défaut, `appsignal-wrap` rapportera la sortie standard et l'erreur standard du processus en tant que logs vers AppSignal, et rapportera tout statut de sortie d'échec à AppSignal en tant qu'erreur.

<span id="check-ins" />

## Surveillance de processus

<Tip>
  [Consultez notre documentation sur la surveillance de processus](/check-ins) pour plus d'informations sur le fonctionnement de
  la surveillance de processus AppSignal.
</Tip>

Par défaut, `appsignal-wrap` n'enverra aucun événement de surveillance de processus. Vous pouvez utiliser les options de ligne de commande `--cron`
ou `--heartbeat` pour activer respectivement les moniteurs de processus cron ou heartbeat.

L'outil `appsignal-wrap` utilisera le nom fourni comme premier argument en tant qu'identifiant du moniteur de processus. Par exemple, pour signaler des événements de moniteur de processus cron avec `backup-script` comme identifiant du moniteur de processus :

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

### Moniteurs de processus cron

Lors de l'utilisation de `--cron` pour envoyer des moniteurs de processus cron, `appsignal-wrap` enverra un événement de moniteur de processus cron de démarrage lorsque le processus démarre, et un événement de moniteur de processus cron de fin si le processus se termine avec succès.

Si le processus se termine avec un statut de sortie d'échec, `appsignal-wrap` n'enverra pas d'événement de moniteur de processus cron de fin.

### Moniteurs de processus heartbeat

Lors de l'utilisation de `--heartbeat` pour envoyer des moniteurs de processus heartbeat, `appsignal-wrap` enverra des événements de moniteur de processus heartbeat en continu pendant la durée de vie du processus.

### Identifiant personnalisé

Pour envoyer des événements de moniteur de processus à AppSignal avec un identifiant différent du nom fourni comme premier argument, vous pouvez passer un identifiant différent en argument des options de ligne de commande `--cron` ou `--heartbeat`. Par exemple :

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

Dans l'exemple ci-dessus, `appsignal-wrap` enverra des événements de moniteur de processus cron avec `daily-backup` comme identifiant du moniteur de processus, mais utilisera toujours `backup` comme nom pour identifier le processus lors du signalement des logs et des erreurs.

## Journalisation

Par défaut, `appsignal-wrap` enverra à la fois la sortie standard et la sortie d'erreur standard du processus qu'il surveille en tant que logs à AppSignal. Les logs apparaîtront sous la source « application », et le nom fourni comme premier argument sera utilisé comme groupe de logs.

### Désactiver la journalisation

Pour désactiver l'envoi de la sortie standard ou de la sortie d'erreur standard en tant que logs, vous pouvez utiliser respectivement les options de ligne de commande `--no-stdout` ou `--no-stderr`.

Pour désactiver complètement l'envoi des logs, vous pouvez utiliser l'option de ligne de commande `--no-log`.

### Groupe de logs personnalisé

Pour envoyer les logs comme un groupe de logs différent, vous pouvez le passer en argument de l'option de ligne de commande `--log`. Par exemple :

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

Dans l'exemple ci-dessus, `appsignal-wrap` utilisera `db` comme groupe de logs lors de l'envoi des logs à AppSignal, mais utilisera toujours `mysql` comme nom pour identifier le processus lors du signalement des moniteurs de processus et des erreurs.

### Source de logs personnalisée

Pour envoyer les logs vers une source de logs différente, vous pouvez passer la clé API de la source de logs, que vous obtenez lors de la [création d'une source de logs](https://docs.appsignal.com/logging/configuration.html#creating-a-log-source), en argument de l'option de ligne de commande `--log-source`, ou comme variable d'environnement `APPSIGNAL_LOG_SOURCE_API_KEY`. Par exemple :

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

## Rapport d'erreurs

Par défaut, `appsignal-wrap` rapportera tout statut de sortie d'échec du processus qu'il surveille en tant qu'erreur à AppSignal. Les erreurs seront groupées par le nom fourni en premier argument.

### Désactiver le rapport d'erreurs

Pour désactiver entièrement le rapport d'erreurs, vous pouvez utiliser l'option en ligne de commande `--no-error`.

### Sortie dans les messages d'erreur

Lors du rapport d'erreurs à AppSignal, `appsignal-wrap` inclura les dernières lignes de la sortie standard et de l'erreur standard du processus comme message d'erreur.

L'utilisation des options en ligne de commande `--no-stdout` ou `--no-stderr` empêchera la sortie standard ou l'erreur standard d'être incluse dans le message d'erreur.

L'utilisation des deux options empêchera tout log d'être inclus dans le message d'erreur.

### Regroupement personnalisé des erreurs

Pour grouper les erreurs différemment, vous pouvez passer un autre nom comme argument à l'option en ligne de commande `--error`. Par exemple :

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

Dans l'exemple ci-dessus, `appsignal-wrap` rapportera les erreurs avec `user-backup` comme groupe d'erreurs, mais utilisera toujours `backup` comme nom pour identifier le processus lors du rapport des logs et des moniteurs de processus.

### Révision d'application

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

Si une révision est fournie en utilisant le drapeau `--revision` ou la variable d'environnement `APPSIGNAL_REVISION`, les erreurs seront groupées avec le déploiement pour cette révision.

## Comportement du processus

L'outil `appsignal-wrap` vise à être *transparent* — c'est-à-dire qu'exécuter une commande à l'aide d'`appsignal-wrap` doit avoir le même comportement que d'exécuter cette même commande seule.

<Note>
  Après la fin du processus surveillé, `appsignal-wrap` attendra une courte période *(généralement une seconde ou moins)* avant de quitter, afin de s'assurer que tous les logs et moniteurs de processus sont envoyés à AppSignal.

  Si vous appelez `appsignal-wrap` dans une boucle, le délai causé par cette attente peut faire en sorte que la boucle s'exécute plus lentement que prévu.
</Note>

### Variables d'environnement

Le processus hérite automatiquement des variables d'environnement du processus parent `appsignal-wrap`.

### Statut de sortie

Si le processus qu'il surveille se termine avec un code de sortie, `appsignal-wrap` se terminera avec le même code de sortie d'échec.

Si le processus qu'il surveille est terminé par un signal, `appsignal-wrap` se terminera avec un code de sortie d'échec de `128 + signal`, où `signal` est le nombre représentant le signal qui a causé la fin du processus. Le signal que ce nombre représente est spécifique au système d'exploitation.

### Entrée et sortie

Le processus hérite automatiquement de son descripteur d'entrée standard du processus parent `appsignal-wrap`.

En plus de les rapporter à AppSignal, la sortie standard et l'erreur standard du processus sont redirigées vers la sortie standard et l'erreur standard du processus parent `appsignal-wrap`.

Lors de l'utilisation de `--no-stdout` ou `--no-stderr`, le processus hérite automatiquement, respectivement, du descripteur de sortie standard ou d'erreur standard du processus parent `appsignal-wrap`.

Cela signifie que vous pouvez utiliser `appsignal-wrap` dans un pipeline, ou rediriger sa sortie vers un fichier, par exemple :

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

### Signaux

Lorsque le processus `appsignal-wrap` reçoit un signal qui peut être géré, il le transmet au processus qu'il surveille.

Par exemple, envoyer un signal `SIGTERM` au processus parent `appsignal-wrap` fera en sorte que le processus qu'il surveille reçoive un signal `SIGTERM`.

Lorsque le processus parent `appsignal-wrap` reçoit un signal qui ne peut pas être géré, tel que `SIGKILL` et `SIGSTOP`, ou s'il plante de manière inattendue, un signal `SIGTERM` sera envoyé au processus qu'il surveille.