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

# Delayed::Job

[Delayed::Job](https://github.com/collectiveidea/delayed_job) est créé par les excellentes équipes de [Shopify](https://shopifyengineering.myshopify.com/) et constitue l'un des processeurs d'arrière-plan les plus populaires pour Ruby et Rails.

La gem AppSignal détecte Delayed Job lorsqu'il est présent et se branche sur les callbacks standard de Delayed Job. Aucune autre action n'est requise pour activer l'intégration.

Cette intégration vise à prendre en charge toutes les différentes méthodes de mise en file d'attente de Delayed::Job. Certaines méthodes peuvent avoir des limitations et des options de personnalisation.

## Classes avec des méthodes `#perform`

<Tip>
  **Remarque** : le reporting des jobs utilisant cette méthode est pris en
  charge depuis la version 2.11.0 de la gem AppSignal pour Ruby.
</Tip>

Delayed Job prend en charge la mise en file d'attente de jobs basés sur des instances de classes ou de structs qui écoutent une méthode d'instance `perform`, lorsqu'ils sont mis en file d'attente avec `Delayed::Job.enqueue`. AppSignal utilisera le nom de classe de l'objet comme nom d'action, en ajoutant `#perform` au nom d'action. Un job pour `StructJob` est signalé comme `StructJob#perform`.

<CodeGroup>
  ```ruby Ruby theme={null}
  class StructJob < Struct.new(:id)
    def perform
      # Do stuff
    end
  end

  Delayed::Job.enqueue(StructJob.new("id"))
  # Reported as "StructJob#perform"
  ```
</CodeGroup>

Notez que cette méthode de mise en file d'attente ne prend pas en charge les arguments, car un objet entier est mis en file d'attente. Les objets de job sont sérialisés lors de la mise en file d'attente et désérialisés lors de leur traitement. AppSignal ne lit pas l'état de l'objet désérialisé. L'argument `id` pour le `StructJob` dans l'exemple ci-dessus n'est pas signalé.

## Jobs utilisant `display_name`

Delayed Job permet à toute classe de définir son propre `display_name`. Cette valeur `display_name` peut interférer avec le reporting d'AppSignal si elle est construite à l'aide de valeurs dynamiques, telles que les arguments donnés au job.

Si la valeur de retour de la méthode `display_name` ne renvoie pas une chaîne au format `ClassName#method_name`, AppSignal traitera chaque job comme une entité distincte, créant de nombreux incidents et notifications. Cela rompt le regroupement effectué par AppSignal pour ces jobs, ce qui entraîne le signalement par AppSignal de nombreuses variations uniques d'incidents pour le job et des métriques inutilisables dans les graphiques.

Pour éviter cela, définissez une méthode `appsignal_name` qui renvoie un nom de job au format `ClassName#method_name`. De cette manière, les jobs seront à nouveau correctement regroupés.

<CodeGroup>
  ```ruby Ruby theme={null}
  class StructJobWithName < Struct.new(:id)
    def perform
      # Do stuff
    end

    # This returns an unique job name, creating new incidents and graphs for each
    # unique job name.
    def display_name
      "StructJobWithName-#{id}"
    end

    # This will group the jobs back to a single entity, allowing incidents
    # and graphs to work properly.
    def appsignal_name
      "StructJobWithName#perform"
    end
  end

  Delayed::Job.enqueue(StructJobWithName.new("id"))
  # Reported as "StructJobWithName#perform"
  ```
</CodeGroup>

## Prise en charge de l'appel de méthode `delay`

Les appels de méthode mis en file d'attente avec l'extension `delay` seront signalés avec un nom d'action similaire à la façon dont ils sont appelés.

Les arguments fournis à la méthode différée seront signalés comme les arguments du job.

<CodeGroup>
  ```ruby Ruby theme={null}
  Post.delay.archive_all("some selector")
  # Reported as "Post.archive_all"

  Post.create(:title => "Post title").delay.send_mail("mail subject")
  # Reported as "Post#send_mail"
  ```
</CodeGroup>

## Prise en charge de Delayed::Job.enqueue

<Tip>
  **Remarque** : la détection du nom du job a été ajoutée dans la version 2.11.0 de la gem Ruby.
</Tip>

Les objets de jobs personnalisés mis en file d'attente avec `Delayed::Job.enqueue` seront signalés normalement, mais ne signaleront pas les arguments. Un objet entier est donné à Delayed::Job, et sérialisé en YAML puis désérialisé. Nous ne pouvons pas détecter les arguments dans ce scénario.

<CodeGroup>
  ```ruby Ruby theme={null}
  Delayed::Job.enqueue job_object
  ```
</CodeGroup>

## Prise en charge d'Active Job

L'intégration Delayed Job est compatible avec [Active Job](/ruby/integrations/active-job). Elle signalera les [temps de file d'attente dans les graphiques](https://appsignal.com/redirect-to/app?to=performance/graphs), les files d'attente et les priorités si elles sont définies sur le job.

Effectuez une mise à niveau vers la version 2.11.0 ou plus récente de la gem Ruby pour une prise en charge améliorée.

## Modifications apportées à l'intégration

### Temps de file d'attente

Dans la gem AppSignal pour Ruby 2.3.0, une modification a été apportée à l'enregistrement du temps de file d'attente. Dans la [PR #297](https://github.com/appsignal/appsignal-ruby/pull/297), l'heure de début du job a été utilisée plutôt que l'heure de création du job.

Cela signifie que le temps entre la création d'un job et le moment où il doit démarrer n'est plus enregistré comme temps de file d'attente. Cela évitera que des temps de file d'attente très longs ne faussent les graphiques de temps de file d'attente sur AppSignal.com.

## Exemples d'applications

Vous trouverez ci-dessous une liste d'exemples d'applications disponibles pour tester l'intégration de Delayed::Job avec :

* [AppSignal + Rails 5 + Delayed::Job](https://github.com/appsignal/appsignal-examples/tree/rails-5+delayed_job)
  * L'exemple montre comment configurer AppSignal avec Delayed::Job et Rails. Dans le fichier `README`, il répertorie toutes les méthodes connues et testées de mise en file d'attente des jobs prises en charge par AppSignal.