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

# Surveillance des tâches Rake

export const VersionRequirements = ({versions = []}) => {
  if (!Array.isArray(versions) || versions.length === 0) {
    return null;
  }
  const boundaries = {
    upper: " or lower",
    exact: "",
    lower: " or higher"
  };
  const containerStyle = {
    marginTop: "0.5rem",
    marginBottom: "1.5rem"
  };
  const lineStyle = {
    display: "block",
    margin: "0 0 0.35rem 0",
    fontSize: "0.875rem",
    lineHeight: "1.4"
  };
  const pillBaseStyle = {
    display: "inline-block",
    padding: "0.1em 0.4em",
    borderRadius: "0.25rem",
    border: "1px solid",
    fontFamily: "ui-monospace, SFMono-Regular, Menlo, monospace",
    fontSize: "0.85em",
    fontWeight: 500
  };
  const pillColors = {
    "AppSignal for Elixir": {
      background: "#f3e8ff",
      borderColor: "#e9d5ff",
      color: "#9333ea"
    },
    "AppSignal for Front-end": {
      background: "#fef9c3",
      borderColor: "#fde68a",
      color: "#ca8a04"
    },
    "AppSignal for Go": {
      background: "#ccfbf1",
      borderColor: "#99f6e4",
      color: "#0d9488"
    },
    "AppSignal for JavaScript": {
      background: "#fef9c3",
      borderColor: "#fde68a",
      color: "#ca8a04"
    },
    "AppSignal for Node.js": {
      background: "#dcfce7",
      borderColor: "#bbf7d0",
      color: "#16a34a"
    },
    "AppSignal for Python": {
      background: "#dbeafe",
      borderColor: "#bfdbfe",
      color: "#2563eb"
    },
    "AppSignal for Ruby": {
      background: "#fee2e2",
      borderColor: "#fecaca",
      color: "#dc2626"
    },
    "AppSignal for Rust": {
      background: "#ffedd5",
      borderColor: "#fed7aa",
      color: "#ea580c"
    }
  };
  const defaultPillColor = {
    background: "#f4f4f5",
    borderColor: "#e4e4e7",
    color: "#52525b"
  };
  const getPillStyle = name => ({
    ...pillBaseStyle,
    ...pillColors[name] || defaultPillColor
  });
  const getBoundText = bound => {
    return boundaries[bound] || boundaries.lower;
  };
  return <div style={containerStyle}>
      {versions.map((v, i) => <p key={`${v.name}-${v.version}-${v.bound || "lower"}-${i}`} style={lineStyle}>
          This feature requires{" "}
          <code style={getPillStyle(v.name)}>{v.name}</code> version {v.version}
          {getBoundText(v.bound)}.
        </p>)}
    </div>;
};

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

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

Chaque exception enregistrée dans une tâche [Rake][rake] sera envoyée à AppSignal et classée sous le [namespace](/application/namespaces) « Background ». Notez que nous ne suivons que les exceptions dans les tâches Rake. Il n'y a pas de surveillance des performances pour les tâches Rake.

(Pour intégrer manuellement la surveillance des performances dans des tâches Rake sélectionnées, veuillez consulter notre [guide d'intégration][integration] et notre [guide d'instrumentation personnalisée][custom-instrumentation].)

Selon la version de la gem AppSignal que vous utilisez et le contexte, certaines étapes manuelles sont requises.

## Intégrations

### Applications Rails

Pour les applications Rails, assurez-vous de dépendre de la tâche `:environment`. Cela charge l'application Rails en mémoire et démarre AppSignal dans le cadre de l'application.

<CodeGroup>
  ```ruby Ruby theme={null}
  # lib/tasks/my_task.rb
  task :my_task => :environment do
    # do stuff
  end
  ```
</CodeGroup>

#### Rakefile

Le `Rakefile` de votre application Rails devrait ressembler à l'exemple ci-dessous. Cela devrait déjà être le cas, pas besoin de le modifier.

<CodeGroup>
  ```ruby Ruby theme={null}
  # Rakefile
  require File.expand_path("../config/application", __FILE__)

  # Only require this file for gem version < 1.0
  # require "appsignal/integrations/rake"

  Rails.application.load_tasks
  ```
</CodeGroup>

(Pour les versions plus anciennes de la gem AppSignal, versions `< 1`, vous devrez requérir manuellement l'intégration Rake. Elle est chargée automatiquement pour la version `1.x` et supérieure.)

### Applications Ruby

Pour les applications Ruby pures, des étapes supplémentaires sont requises pour charger AppSignal. AppSignal doit être requis, configuré et chargé. Consultez également notre [guide d'intégration][integration].

<CodeGroup>
  ```ruby Ruby theme={null}
  # Rakefile
  require "appsignal"

  Appsignal.start

  task :foo do
    raise "bar"
  end
  ```
</CodeGroup>

## Surveillance des performances des tâches Rake

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

Pour surveiller les performances des tâches Rake et tous les événements qui se produisent dans la tâche, configurez AppSignal avec l'[option de configuration `enable_rake_performance_instrumentation`](/ruby/configuration/options#option-enable_rake_performance_instrumentation) définie sur `true`.

Une fois cette fonctionnalité activée, toutes les tâches Rake seront instrumentées et comptabilisées dans votre forfait.

## Exigence d'arrêt

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

Pour les tâches Rake s'exécutant sur des hôtes de courte durée, il est nécessaire d'arrêter la gem AppSignal Ruby avant la sortie du processus Rake.
Cela garantira qu'elle signale les données des tâches Rake à AppSignal avant l'arrêt de l'hôte.

Ce comportement n'est nécessaire que dans des scénarios tels que :

* Lorsqu'une tâche Rake planifiée (un cron job) est exécutée par un service d'hébergement.
* Lorsqu'une tâche Rake est exécutée sur un conteneur qui démarre pour exécuter cette tâche Rake et s'arrête lorsque la tâche Rake se termine.
* Lorsqu'une tâche Rake est exécutée sur un Heroku runner, ou des fournisseurs d'hébergement similaires.

Il n'est pas nécessaire d'arrêter la gem AppSignal Ruby si l'hôte sur lequel le script est démarré continue à fonctionner après la sortie du script.

AppSignal est arrêté automatiquement à la fin de la tâche Rake si un conteneur ou un environnement d'hébergement comme Heroku est détecté.

Ce comportement est contrôlé par l'[option `enable_at_exit_hook`](/ruby/configuration/options#option-enable_at_exit_hook).
Assurez-vous que cette option est définie sur true pour les scripts qui nécessitent l'arrêt d'AppSignal, s'il n'est pas détecté automatiquement.

Il peut être nécessaire d'ajouter un appel `sleep` supplémentaire de quelques secondes pour s'assurer qu'il y a suffisamment de temps pour envoyer toutes les données. Utilisez l'exemple d'utilisation `at_exit` du code ci-dessous si nécessaire.

<CodeGroup>
  ```ruby Rakefile theme={null}
  # Short-lived host example task

  # This block is called after all tasks are ran
  # Ensures the AppSignal agent has enough time to send the data to the AppSignal servers
  at_exit { sleep 10 }

  task :foo do
    # Your Rake task code
  end
  ```
</CodeGroup>

### Exigence d'arrêt héritée

<Warning>
  La section ci-dessous concerne les applications utilisant la gem Ruby 4.5.7 et inférieure.
  Ces versions n'incluent pas l'[option `enable_at_exit_hook`](/ruby/configuration/options#option-enable_at_exit_hook) qui automatise ce comportement.

  Pour les versions plus récentes de la gem Ruby, consultez la [section d'exigence d'arrêt](#stop-requirement).
</Warning>

Lors de l'exécution d'une seule tâche Rake sur un hôte de courte durée (par exemple avec des conteneurs Docker, des planificateurs Kubernetes ou Heroku), il y a trois exigences.
Cela garantit que l'extension AppSignal de l'application a le temps de vider les données vers l'agent et que l'agent a le temps d'envoyer les données à notre API avant l'arrêt (du conteneur).

**Les exigences sont :**

* `Appsignal.stop` doit être appelé dans la tâche Rake.
  * Lorsque la [surveillance des performances des tâches Rake](#monitoring-rake-task-performance) est activée, cela est fait automatiquement pour toutes les tâches.
* [`running_in_container`](/ruby/configuration/options#option-running_in_container) doit être défini sur true dans la configuration.
  * Pour la plupart des types de conteneurs, `running_in_container` est automatiquement défini sur true lorsqu'il est détecté, pour d'autres une configuration manuelle est requise.
* Un sleep de par exemple 10 secondes pour donner à l'agent AppSignal le temps d'envoyer les données

Un exemple de la façon dont `Appsignal.stop` est appelé dans le Rakefile :

<CodeGroup>
  ```ruby Rakefile theme={null}
  # Short-lived host example task

  # This block is called after all tasks are ran
  # The argument "rake" is the name of the parent process name which is being
  # stopped and logs it as the reason why AppSignal is stopping.
  at_exit do
    Appsignal.stop "rake"
    sleep 10 # For short-lived hosts, give the AppSignal agent time to send the data
  end

  task :foo do
    # Tracking data with AppSignal in your task
    Appsignal.increment_counter "my_custom_counter"
  end
  ```
</CodeGroup>

**Remarque** : un sleep de 10 secondes a été ajouté à la fin de l'exemple de tâche Rake ci-dessus.
Ceci est requis pour les tâches exécutées sur des hôtes de courte durée.
Lorsque la tâche se termine, le processus s'arrête.
L'appel `Appsignal.stop` vide toutes les données de transaction actuellement dans l'extension AppSignal vers notre agent.
Il se met ensuite en sommeil pendant 10 secondes pour permettre à l'agent d'envoyer les données avant l'arrêt.

[rake]: https://github.com/ruby/rake

[integration]: /ruby/instrumentation/integrating-appsignal.html

[custom-instrumentation]: /ruby/instrumentation/instrumentation.html