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

# Active Job

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: "2.11.0" }
]}
/>

Active Job est un framework pour déclarer des tâches et les faire s'exécuter sur une variété de backends de file d'attente fournis avec Rails.

L'intégration Active Job suit l'exécution et les événements de la tâche en cours d'exécution.

Lorsque AppSignal détecte des métriques Active Job, il créera un [Magic Dashboard](#magic-dashboard), vous permettant de surveiller visuellement les métriques principales.

## Adaptateurs pris en charge

L'intégration Active Job prend en charge tous les [adaptateurs Active Job](https://api.rubyonrails.org/classes/ActiveJob/QueueAdapters.html).

Elle peut également offrir une prise en charge pour les adaptateurs non répertoriés sur cette page, accessibles via une gem séparée. Cependant, veuillez noter que ces adaptateurs n'ont pas été testés.

## Intégration avec les bibliothèques prises en charge par AppSignal

Les bibliothèques de tâches en arrière-plan suivantes prises en charge par AppSignal sont automatiquement intégrées à Active Job, permettant à AppSignal de vous fournir des informations de performance plus approfondies :

* [Delayed::Job](/ruby/integrations/delayed-job)
* [Que](/ruby/integrations/que)
* [Resque](/ruby/integrations/resque)
* [Sidekiq](/ruby/integrations/sidekiq)
* [Solid Queue](/ruby/integrations/solidqueue)

## Signaler les erreurs lors de l'abandon d'une tâche

<Compatibility
  versions={[
{ name: "AppSignal for Ruby", version: "3.7.3" },
{ name: "Active Job", version: "7.1.0" },
]}
/>

Définissez l'[option de configuration `activejob_report_errors`](/ruby/configuration/options#option-activejob_report_errors) sur `discard` pour ne signaler les erreurs que lorsqu'une tâche est abandonnée. Lorsqu'une tâche est abandonnée, toutes les tentatives de réessai ont été épuisées, et la tâche n'est plus réessayée. Lisez la [documentation Active Job](https://guides.rubyonrails.org/active_job_basics.html#exceptions) pour en savoir plus sur la gestion des exceptions Active Job et les réessais des tâches échouées.

<CodeGroup>
  ```ruby Ruby theme={null}
  class ExampleJob < ActiveJob::Base
    # Configure the retry attempts using the `retry_on` method
    retry_on StandardError, :attempts => 2

    # ...
  end
  ```
</CodeGroup>

<Warning>
  Certains adaptateurs Active Job (tels que Sidekiq, Delayed::Job, etc.) ont leur propre
  système de réessai. Une fois qu'Active Job a épuisé ses réessais, ces bibliothèques
  peuvent déclencher leur propre système de réessai des tâches.

  Cela réessaiera les tâches même après qu'Active Job ait épuisé ses réessais et
  abandonné la tâche. Pour éviter de réessayer les tâches après qu'Active Job ait cessé
  de les réessayer, et qu'il signale des erreurs pour ces réessais, assurez-vous que le
  système de réessai de l'adaptateur est désactivé.

  Lorsque vous vous appuyez sur le système de réessai de Sidekiq, configurez-le également [pour ne
  signaler les erreurs qu'en cas d'abandon](/ruby/integrations/sidekiq#report-errors-on-job-discard),
  afin qu'il ne signale pas les erreurs plusieurs fois.
</Warning>

## Métadonnées

AppSignal collecte les métadonnées suivantes pour les tâches Active Job :

| Métadonnée                 | Description                                                                                                                 |
| -------------------------- | --------------------------------------------------------------------------------------------------------------------------- |
| ID Active Job              | L'ID Active Job est signalé par l'adaptateur Active Job.                                                                    |
| Arguments                  | Arguments passés à la tâche lors de l'appel à `perform_later`.                                                              |
| Événements                 | Tous les événements `*.active_job`.                                                                                         |
| Nom de la tâche            | par exemple `MyBackgroundJob#perform` tel qu'utilisé pour regrouper la tâche pour les incidents AppSignal.                  |
| Priorité                   | La priorité de l'échantillon, si vous utilisez un adaptateur qui prend en charge la priorité des tâches.                    |
| ID de tâche du fournisseur | L'ID de tâche signalé par l'adaptateur Active Job.                                                                          |
| Queue                      | Le nom de la file d'attente de l'échantillon, si vous utilisez un adaptateur qui prend en charge plusieurs files d'attente. |
| Temps de file d'attente\*  | Temps écoulé entre la mise en file d'attente et l'exécution d'une tâche.                                                    |

*\*À partir de la version 6 de Rails, les temps de file d'attente sont signalés pour le namespace à partir duquel ils sont signalés et peuvent être consultés dans les [graphiques de performance](https://appsignal.com/redirect-to/app?to=performance/graphs) d'AppSignal.*

AppSignal utilise les métadonnées Active Job pour vous donner des informations contextuelles plus approfondies sur la performance des tâches. Lors de l'inspection des échantillons Active Job dans AppSignal :

* Le nom de la tâche sera utilisé pour regrouper la tâche pour les incidents AppSignal :

<img src="https://mintcdn.com/appsignal-715f5a51/4TRZP0Sq9Zq7PAPW/assets/images/screenshots/ruby/integrations/active-job/job-performance-samples.png?fit=max&auto=format&n=4TRZP0Sq9Zq7PAPW&q=85&s=866403a09bc23c27704ecd4ac96dc1c7" alt="Exemple d'aperçu des problèmes de performance" width="983" height="362" data-path="assets/images/screenshots/ruby/integrations/active-job/job-performance-samples.png" />

* Les métadonnées (à l'exclusion du nom de la tâche et des événements) seront disponibles sous forme de tags filtrables sur les échantillons d'incidents :

<img src="https://mintcdn.com/appsignal-715f5a51/4TRZP0Sq9Zq7PAPW/assets/images/screenshots/ruby/integrations/active-job/job-tags.png?fit=max&auto=format&n=4TRZP0Sq9Zq7PAPW&q=85&s=35ac92fc750684d84cf17fa9ed4244c5" alt="Exemple de tags Active Job" width="1432" height="672" data-path="assets/images/screenshots/ruby/integrations/active-job/job-tags.png" />

* Les événements `*.active_job` seront affichés dans la chronologie des événements pour les échantillons de performance :

<img src="https://mintcdn.com/appsignal-715f5a51/4TRZP0Sq9Zq7PAPW/assets/images/screenshots/ruby/integrations/active-job/job-event-timeline.png?fit=max&auto=format&n=4TRZP0Sq9Zq7PAPW&q=85&s=920c59814955e89708efb652d5d13cfd" alt="Exemple de chronologie d'événements" width="1314" height="488" data-path="assets/images/screenshots/ruby/integrations/active-job/job-event-timeline.png" />

## Magic dashboard

Lorsque AppSignal reçoit des métriques Active Job, il créera un magic dashboard Active Job, disponible depuis la section dashboard de l'application AppSignal.

Le magic dashboard Active Job aura les graphiques suivants :

| Graphique                                                                                       | Métriques                    | [Tags](#tags)                                        |
| ----------------------------------------------------------------------------------------------- | ---------------------------- | ---------------------------------------------------- |
| [Durée par classe de tâche](#duration-per-job-class-graph)                                      | `transaction_duration`       | <li>`namespace`</li><li>`action`</li>                |
| [Statut des tâches par file d'attente](#job-status-per-queue-graph)                             | `active_job_queue_job_count` | <li>`status`</li><li>`queue`</li>                    |
| [Statut des tâches par file d'attente avec priorité](#job-status-per-queue-with-priority-graph) | `active_job_queue_job_count` | <li>`status`</li><li>`queue`</li><li>`priority`</li> |
| [Débit par classe de tâche](#throughput-per-job-class-graph)                                    | `transaction_duration`       | <li>`namespace`</li><li>`action`</li>                |

Les tags vous donnent une répartition contextuelle des informations de performance Active Job. Actuellement, AppSignal signale les tags suivants pour les tâches Active Job :

| Nom        | Description                                                                                                                           |
| ---------- | ------------------------------------------------------------------------------------------------------------------------------------- |
| `action`   | Le nom de l'action à partir de laquelle la métrique a été signalée (par ex. : `YourWorker#perform`).                                  |
| `queue`    | File d'attente nommée dans laquelle les tâches sont traitées, par exemple `default` ou `mailer`.                                      |
| `status`   | Statut de chaque tâche, soit `processed` soit `failed`. <br />Les tâches qui sont `failed` sont également comptées comme `processed`. |
| `priority` | La priorité donnée à chaque tâche, par exemple `0` ou `1`.                                                                            |

Chaque tag sera représenté par une ligne colorée sur le graphique :

<img src="https://mintcdn.com/appsignal-715f5a51/4TRZP0Sq9Zq7PAPW/assets/images/screenshots/ruby/integrations/active-job/dashboard.png?fit=max&auto=format&n=4TRZP0Sq9Zq7PAPW&q=85&s=a5675ac1b157ee8ba348e3a1563b5793" alt="Exemple de dashboard Active Job" width="1432" height="672" data-path="assets/images/screenshots/ruby/integrations/active-job/dashboard.png" />

### Graphique Durée par classe de tâche

Le graphique Durée par classe de tâche montre le temps qu'il a fallu aux tâches pour s'exécuter, regroupées par la classe qui définit la tâche.

Vous pouvez utiliser ce graphique pour surveiller la performance des tâches, par classe, vous donnant une vue d'ensemble de la performance des tâches et vous permettant d'identifier et d'enquêter rapidement sur les pics de durée.

### Graphique Statut des tâches par file d'attente

Le graphique Statut des tâches par file d'attente avec priorité montre le nombre de tâches exécutées, regroupées par leur statut résultant, par la file d'attente dans laquelle elles ont été mises en file d'attente.

Vous pouvez utiliser ce graphique pour surveiller le nombre d'erreurs des tâches et leur performance en fonction de la file d'attente, identifier les goulots d'étranglement et optimiser vos tâches en arrière-plan pour l'évolutivité.

### Graphique Statut des tâches par file d'attente avec priorité

<Tip>
  Tous les [adaptateurs Active Job](#supported-adapters) ne prennent pas en charge la priorité
  des tâches. Si les tâches n'ont pas de valeurs de priorité, le graphique sera vide.
</Tip>

Le graphique Statut des tâches par file d'attente avec priorité montre le nombre de tâches exécutées,
regroupées par leur statut résultant, par la file d'attente dans laquelle elles ont été mises en file d'attente, et par
la priorité qui leur a été donnée.

Vous pouvez utiliser ce graphique pour surveiller le nombre d'erreurs des tâches et leur performance en fonction de la file d'attente et de la priorité, identifier les goulots d'étranglement et optimiser vos tâches en arrière-plan pour l'évolutivité.

### Graphique Débit par classe de tâche

Le graphique Débit par classe de tâche montre le nombre de tâches exécutées, regroupées par la classe qui définit la tâche.

Vous pouvez utiliser ce graphique pour surveiller le nombre de tâches exécutées, regroupées par la classe qui définit la tâche.