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

# Sidekiq

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

[Sidekiq](http://sidekiq.org) est un processeur d'arrière-plan simple et efficace pour Ruby. C'est également le processeur que nous utilisons pour traiter les jobs dans AppSignal.

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

## Surveillance Sidekiq pour les applications Ruby on Rails

La gem AppSignal Ruby insère automatiquement un listener dans la pile de middlewares du serveur Sidekiq si le module `Sidekiq` est présent et si vous utilisez Rails. Aucune autre action n'est requise.

L'intégration Sidekiq est compatible avec [Active Job](/ruby/integrations/active-job).

## Surveillance Sidekiq pour les applications Ruby

L'ajout de cette configuration ne devrait être nécessaire que lorsque Sidekiq ne charge pas automatiquement AppSignal via le framework de l'application, comme Rails.

Ajoutez ce snippet à votre configuration Sidekiq avec le bon environnement et le bon nom :

<CodeGroup>
  ```ruby Ruby theme={null}
  require 'appsignal'

  Sidekiq.configure_server do |config|
    config.on(:startup) do
      # Start AppSignal
      Appsignal.start
    end

    config.on(:shutdown) do
      # Stop the agent
      Appsignal.stop('Sidekiq shutdown')
    end
  end
  ```
</CodeGroup>

## Surveillance des performances

Une fois qu'AppSignal commence à signaler les métriques Sidekiq, AppSignal vous donnera des informations sur les performances via :

* [Chronologie des événements](#event-timeline)
* [Suivi des erreurs](#error-tracking)
* [Regroupement d'incidents](#incident-grouping)
* [Décomposition des échantillons](#sample-breakdown)

### Chronologie des événements

Les événements `perform_job.sidekiq` seront affichés dans la chronologie des événements sur la page de détail de l'incident de performance :

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

### Suivi des erreurs

Suivez les exceptions qui se produisent lors de l'exécution des jobs Sidekiq.

Lorsque Sidekiq rencontre un problème avant ou après le traitement d'un job, comme l'analyse de JSON depuis Redis, il lèvera une erreur. Cette erreur est signalée sous l'action SidekiqInternal dans le namespace background, car le contexte du job est inconnu au moment où l'erreur se produit.

<img src="https://mintcdn.com/appsignal-715f5a51/MS9b5WO71lSfD5jG/assets/images/screenshots/ruby/integrations/sidekiq/error.png?fit=max&auto=format&n=MS9b5WO71lSfD5jG&q=85&s=1b07bec6ca219e7c991108eda21173eb" alt="Exemple d'erreur sidekiq" width="1310" height="482" data-path="assets/images/screenshots/ruby/integrations/sidekiq/error.png" />

#### Signaler les erreurs lors de l'abandon du job

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

Définissez l'[option de configuration `sidekiq_report_errors`](/ruby/configuration/options#option-sidekiq_report_errors) sur `discard` pour ne signaler les erreurs que lorsqu'un job est abandonné. Lorsqu'un job est abandonné, toutes les nouvelles tentatives ont été épuisées et le job n'est plus réessayé. Lisez la [documentation Sidekiq](https://github.com/sidekiq/sidekiq/wiki/Error-Handling) pour en savoir plus sur la gestion des exceptions Sidekiq et les nouvelles tentatives de jobs échoués.

<Warning>
  Lorsque vous utilisez Sidekiq avec le système de nouvelles tentatives d'Active Job, configurez-le [pour
  ne signaler les erreurs qu'à
  l'abandon](/ruby/integrations/active-job#report-errors-on-job-discard), afin
  qu'il ne signale pas les erreurs plusieurs fois.

  Une fois les tentatives d'Active Job épuisées, le système de nouvelles tentatives de Sidekiq prendra le
  relais. Désactivez le système de nouvelles tentatives Sidekiq si ce comportement n'est pas souhaité.
</Warning>

### Regroupement d'incidents

Les noms de jobs sont automatiquement détectés en fonction du nom de classe du worker Sidekiq et suffixés par le nom de la méthode `perform`, ce qui donne quelque chose comme : `MyWorker#perform`.

<img src="https://mintcdn.com/appsignal-715f5a51/MS9b5WO71lSfD5jG/assets/images/screenshots/ruby/integrations/sidekiq/job-performance-samples.png?fit=max&auto=format&n=MS9b5WO71lSfD5jG&q=85&s=dadb8d091a692cc8b45c9a003d639a9e" alt="Exemple de regroupement d'incidents de performance" width="983" height="362" data-path="assets/images/screenshots/ruby/integrations/sidekiq/job-performance-samples.png" />

### Performances de l'échantillon

Les décompositions d'échantillons vous permettent d'examiner rapidement les performances de Sidekiq et de repérer les problèmes de performances sans avoir à plonger dans les détails.

<img src="https://mintcdn.com/appsignal-715f5a51/MS9b5WO71lSfD5jG/assets/images/screenshots/ruby/integrations/sidekiq/sample-breakdown.png?fit=max&auto=format&n=MS9b5WO71lSfD5jG&q=85&s=916a9579cc0f297c62ff6100be90c5db" alt="Exemple d'échantillon de performance Sidekiq" width="1310" height="436" data-path="assets/images/screenshots/ruby/integrations/sidekiq/sample-breakdown.png" />

## Magic dashboard

Lorsqu'AppSignal reçoit des métriques Sidekiq, il créera un magic dashboard Sidekiq, disponible dans la section dashboard de l'application AppSignal.

Le magic dashboard Sidekiq contiendra les graphiques suivants :

| Graphique                                              | Métriques                                                          | Tags                                  |
| ------------------------------------------------------ | ------------------------------------------------------------------ | ------------------------------------- |
| [Connection count](#connection-count-graph)            | `sidekiq_connection_count`                                         | `hostname`                            |
| [Duration per worker](#duration-per-worker-graph)      | `transaction_duration`                                             | <li>`action`</li><li>`namespace`</li> |
| [Job status per queue](#job-status-per-queue-graph)    | `sidekiq_queue_job_count`                                          | <li>`status`</li><li>`queue`</li>     |
| [Overall job status](#overall-job-status-graph)        | `sidekiq_job_count`                                                | <li>`status`</li><li>`hostname`</li>  |
| [Queue latency](#queue-latency-graph)                  | `sidekiq_queue_latency`                                            | <li>`hostname`</li><li>`queue`</li>   |
| [Queue length](#queue-length-graph)                    | `sidekiq_queue_length`                                             | <li>`hostname`</li><li>`queue`</li>   |
| [Redis memory usage](#redis-memory-usage-graph)        | <li>`sidekiq_memory_usage`</li><li>`sidekiq_memory_usage_rss`</li> | `hostname`                            |
| [Throughput per worker](#throughput-per-worker-graph)  | `transaction_duration`                                             | <li>`action`</li><li>`namespace`</li> |
| [Worker/processes count](#workerprocesses-count-graph) | <li>`sidekiq_worker_count`</li><li>`sidekiq_process_count`</li>    | `hostname`                            |

Les tags vous offrent une décomposition contextuelle des informations de performance de Sidekiq. AppSignal signale les tags suivants pour les jobs Sidekiq :

| Nom         | Description                                                                                                              |
| ----------- | ------------------------------------------------------------------------------------------------------------------------ |
| `action`    | Le nom de l'action depuis laquelle la métrique a été signalée (par exemple, `YourWorker#perform`).                       |
| `hostname`  | Le nom de l'hôte depuis lequel la métrique a été signalée.                                                               |
| `namespace` | Le nom du namespace depuis lequel la métrique a été signalée.                                                            |
| `queue`     | File d'attente nommée dans laquelle les jobs sont traités, par exemple `default` ou `mailer`.                            |
| `status`    | Statut de chaque job, soit `processed`, soit `failed`. <br />Les jobs `failed` sont également comptés comme `processed`. |

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/sidekiq/dashboard.png?fit=max&auto=format&n=4TRZP0Sq9Zq7PAPW&q=85&s=142e1a00e315e511d35fb80892957e22" alt="Exemple de dashboard Sidekiq" width="1432" height="672" data-path="assets/images/screenshots/ruby/integrations/sidekiq/dashboard.png" />

### Graphique Connection count

Le graphique Connection count montre le nombre de connexions Sidekiq par hôte.

Vous pouvez utiliser le graphique Connection count pour surveiller les connexions Sidekiq par hôte, repérer les tendances et goulots d'étranglement de connexion, et optimiser les ressources.

### Graphique Duration per worker

Le graphique Duration per worker montre le temps qu'il a fallu aux jobs pour s'exécuter, regroupés par namespace et action.

Vous pouvez utiliser le graphique Duration per worker pour surveiller les performances des workers par action et namespace, vous donnant une vue d'ensemble des performances de Sidekiq et vous permettant d'identifier et d'enquêter rapidement sur les pics de durée.

### Graphique Job status per queue

Le graphique job status per queue avec une priorité montre le nombre de jobs qui ont été exécutés, regroupés par leur statut résultant, par la file d'attente dans laquelle ils ont été mis en file.

Vous pouvez utiliser le graphique Job status per queue pour surveiller les nombres d'erreurs et les performances des jobs en fonction de la file d'attente, identifier les goulots d'étranglement et optimiser vos jobs en arrière-plan pour la mise à l'échelle.

### Graphique Overall job status

Le graphique overall job status montre le nombre de jobs Sidekiq attendus par statut et namespace.

Vous pouvez utiliser le graphique Overall job status pour surveiller les jobs échoués et suivre la distribution des jobs entre les namespaces.

### Graphique Queue latency

Le graphique Queue latency montre la latence subie par la file d'attente au moment de la mesure. [Sidekiq calcule cela](https://github.com/mperham/sidekiq/wiki/API) en soustrayant l'heure à laquelle le dernier job a été mis en file d'attente de l'heure de la mesure. Cette valeur est rapportée en millisecondes.

Vous pouvez utiliser le graphique Queue latency pour repérer les retards dans le traitement des jobs, détecter la congestion des files d'attente et comprendre la rapidité avec laquelle les jobs en arrière-plan démarrent.

### Graphique Queue length

Le graphique Queue length montre la longueur des files d'attente Sidekiq par file et namespace.

Vous pouvez utiliser le graphique Queue length pour surveiller les performances des files d'attente et repérer et résoudre les goulots d'étranglement Sidekiq.

### Graphique Redis memory usage

Le graphique Redis memory usage affiche :

* L'utilisation de la mémoire Virtual Memory Size de Redis (`sidekiq_memory_usage_rss`)
* L'utilisation de la mémoire Resident Set Size de Redis (`sidekiq_memory_usage_rss`)

Vous pouvez utiliser le graphique Redis memory usage pour surveiller l'utilisation de la mémoire de Sidekiq, améliorer la gestion des ressources et optimiser les jobs intensifs en mémoire.

### Graphique Throughput per worker

Le graphique Throughput per worker montre le nombre de jobs qui ont été exécutés, regroupés par hostname.

Vous pouvez utiliser ce graphique pour surveiller les performances des workers, regroupées par la classe qui définit le job.

### Graphique Worker/processes count

Le graphique Worker/processes count montre le nombre de workers Sidekiq et de processus exécutés.

Vous pouvez utiliser le graphique Worker/processes count pour gérer la distribution de la charge de travail, optimiser l'allocation des ressources et identifier les problèmes de performances.

## Configuration du nom d'hôte

AppSignal tente de détecter le nom d'hôte de l'instance Redis utilisée par votre instance Sidekiq pour stocker ses files d'attente. Si la détection n'est pas précise, il est possible de personnaliser la configuration du nom d'hôte en remplaçant la sonde Sidekiq par défaut.

Tout d'abord, vous devrez [remplacer la sonde Sidekiq par défaut](/ruby/instrumentation/minutely-probes#overriding-default-probes) en enregistrant une nouvelle sonde avec le même nom (`:sidekiq`). Cette sonde aura besoin d'un hash de configuration, comprenant la clé `:hostname`, avec la nouvelle valeur du nom d'hôte. En spécifiant l'option de configuration `:hostname` dans la sonde minute par minute Sidekiq, les métriques seront marquées avec la valeur de nom d'hôte donnée. La valeur de l'option de configuration `:hostname` n'est pas utilisée pour établir une connexion Redis ou Sidekiq.

Par exemple :

<CodeGroup>
  ```ruby Ruby theme={null}
  # config/initializers/appsignal.rb or a file that's loaded on boot

  # Ruby gem 2.11.0 and newer
  Appsignal::Minutely.probes.register(
    :sidekiq, # Use the same key as the default Sidekiq probe to override it
    Appsignal::Probes::SidekiqProbe.new(:hostname => "my_sidekiq_hostname")
  )

  # Ruby gem 2.10.x and older
  Appsignal::Minutely.probes.register(
    :sidekiq, # Use the same key as the default Sidekiq probe to override it
    Appsignal::Hooks::SidekiqProbe.new(:hostname => "my_sidekiq_hostname")
  )
  ```
</CodeGroup>

Dans la version 2.11.0 de la gem Ruby, la constante `SidekiqProbe` a été déplacée vers son propre module. Lors de l'appel à la constante, un avertissement sera imprimé et journalisé. Mettez à jour vers le nouveau nom de constante `Appsignal::Probes::SidekiqProbe` pour supprimer l'avertissement.