> ## 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) is een eenvoudige en efficiënte background processor voor Ruby. Het is ook de processor die wij gebruiken om jobs in AppSignal te verwerken.

Wanneer AppSignal Sidekiq-metrieken detecteert, maakt het een [Magic Dashboard](#magic-dashboard) aan, waardoor u kerncijfers visueel kunt monitoren.

## Sidekiq-monitoring voor Ruby on Rails-apps

De AppSignal Ruby-gem voegt automatisch een listener in de middleware-stack van de Sidekiq-server in als de `Sidekiq`-module aanwezig is wanneer u Rails gebruikt. Er zijn geen verdere acties nodig.

De Sidekiq-integratie is compatibel met [Active Job](/ruby/integrations/active-job).

## Sidekiq-monitoring voor Ruby-apps

Het toevoegen van deze configuratie is alleen nodig wanneer Sidekiq AppSignal niet automatisch laadt via het framework van de app, zoals Rails.

Voeg dit snippet toe aan uw Sidekiq-configuratie met de juiste omgeving en naam:

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

## Performance-monitoring

Zodra AppSignal begint met het rapporteren van Sidekiq-metrieken, geeft AppSignal u prestatie-inzichten via:

* [Event-tijdlijn](#event-timeline)
* [Foutopsporing](#error-tracking)
* [Incident-groepering](#incident-grouping)
* [Sample-overzicht](#sample-breakdown)

### Event-tijdlijn

`perform_job.sidekiq`-events worden weergegeven in de event-tijdlijn op de performance-incidentdetailpagina:

<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="Example event timeline" width="1314" height="488" data-path="assets/images/screenshots/ruby/integrations/sidekiq/event-timeline.png" />

### Foutopsporing

Volg excepties die optreden bij het uitvoeren van Sidekiq-jobs.

Wanneer Sidekiq een probleem tegenkomt vóór of nadat een job is verwerkt, zoals het parsen van JSON uit Redis, zal het een fout opwerpen. Deze fout wordt gerapporteerd onder de actie SidekiqInternal in de background-namespace, omdat de jobcontext onbekend is op het moment dat de fout optreedt.

<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="Example sidekiq error" width="1310" height="482" data-path="assets/images/screenshots/ruby/integrations/sidekiq/error.png" />

#### Fouten rapporteren bij job-discard

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

Stel de [configuratieoptie `sidekiq_report_errors`](/ruby/configuration/options#option-sidekiq_report_errors) in op `discard` om alleen fouten te rapporteren wanneer een job wordt verworpen. Wanneer een job wordt verworpen, zijn alle pogingen van de job uitgeput en wordt de job niet langer opnieuw geprobeerd. Lees de [Sidekiq-documentatie](https://github.com/sidekiq/sidekiq/wiki/Error-Handling) voor meer informatie over Sidekiq-exceptieafhandeling en mislukte job-pogingen.

<Warning>
  Bij gebruik van Sidekiq met het retry-systeem van Active Job, configureert u
  dit [om fouten alleen bij
  discard](/ruby/integrations/active-job#report-errors-on-job-discard) te
  rapporteren, zodat fouten niet meerdere keren worden gerapporteerd.

  Nadat de Active Job-pogingen zijn uitgeput, neemt het Sidekiq-retry-systeem het
  over. Schakel het Sidekiq-retry-systeem uit als dit ongewenst gedrag is.
</Warning>

### Incident-groepering

Jobnamen worden automatisch gedetecteerd op basis van de naam van de Sidekiq-workerklasse en voorzien van de methodenaam `perform`, wat resulteert in iets als: `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="Example performance incident grouping" width="983" height="362" data-path="assets/images/screenshots/ruby/integrations/sidekiq/job-performance-samples.png" />

### Sample-prestaties

Met sample-overzichten kunt u de prestaties van Sidekiq snel beoordelen en prestatieproblemen opsporen zonder diep in de details te hoeven duiken.

<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="Example Sidekiq performance sample" width="1310" height="436" data-path="assets/images/screenshots/ruby/integrations/sidekiq/sample-breakdown.png" />

## Magic dashboard

Wanneer AppSignal Sidekiq-metrieken ontvangt, wordt er een Sidekiq magic dashboard aangemaakt, beschikbaar in de dashboardsectie van de AppSignal-app.

Het Sidekiq magic dashboard bevat de volgende grafieken:

| Grafiek                                                | Metrieken                                                          | 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`                            |

Tags geven u een contextueel overzicht van Sidekiq-prestatie-informatie. AppSignal rapporteert de volgende tags voor Sidekiq-jobs:

| Naam        | Beschrijving                                                                                                            |
| ----------- | ----------------------------------------------------------------------------------------------------------------------- |
| `action`    | De naam van de actie waarvan de metriek is gerapporteerd (bijv. `YourWorker#perform`).                                  |
| `hostname`  | De naam van de host waarvan de metriek is gerapporteerd.                                                                |
| `namespace` | De naam van de namespace waarvan de metriek is gerapporteerd.                                                           |
| `queue`     | Benoemde wachtrij waarin jobs worden verwerkt, bijv. `default` of `mailer`.                                             |
| `status`    | Status van elke job, ofwel `processed` of `failed`. <br />Jobs die `failed` zijn, worden ook als `processed` meegeteld. |

Elke tag wordt op de grafiek weergegeven met een gekleurde lijn:

<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="Example Sidekiq dashboard" width="1432" height="672" data-path="assets/images/screenshots/ruby/integrations/sidekiq/dashboard.png" />

### Connection count-grafiek

De Connection count-grafiek toont het aantal Sidekiq-verbindingen per host.

U kunt de Connection count-grafiek gebruiken om Sidekiq-verbindingen per host te monitoren, verbindingstrends en bottlenecks op te sporen en bronnen te optimaliseren.

### Duration per worker-grafiek

De Duration per worker-grafiek toont hoe lang het duurde voordat jobs werden uitgevoerd, gegroepeerd op namespace en actie.

U kunt de Duration per worker-grafiek gebruiken om de prestaties van workers per actie en namespace te monitoren, waardoor u een helikopterview van Sidekiq-prestaties krijgt en snel pieken in de duur kunt identificeren en onderzoeken.

### Job status per queue-grafiek

De grafiek job-status per queue met een prioriteit toont het aantal jobs dat is uitgevoerd, gegroepeerd op hun resulterende status, per wachtrij waarin ze in de wachtrij zijn geplaatst.

U kunt de Job status per queue-grafiek gebruiken om job-foutaantallen en -prestaties op basis van wachtrij te monitoren, bottlenecks te identificeren en uw background jobs te optimaliseren voor schaalbaarheid.

### Overall job status-grafiek

De grafiek overall job status toont het aantal verwachte Sidekiq-jobs per status en namespace.

U kunt de Overall job status-grafiek gebruiken om mislukte jobs te monitoren en de verdeling van jobs over namespaces te volgen.

### Queue latency-grafiek

De Queue latency-grafiek toont de latency die de wachtrij ondervond op het meetmoment. [Sidekiq berekent dit](https://github.com/mperham/sidekiq/wiki/API) door het tijdstip waarop de laatste job in de wachtrij werd geplaatst af te trekken van het meetmoment. Deze waarde wordt gerapporteerd in milliseconden.

U kunt de Queue latency-grafiek gebruiken om vertragingen bij het verwerken van jobs op te sporen, congestie in de wachtrij te detecteren en te begrijpen hoe snel background jobs starten.

### Queue length-grafiek

De Queue length-grafiek toont de lengte van Sidekiq-wachtrijen per wachtrij en namespace.

U kunt de Queue length-grafiek gebruiken om de prestaties van de wachtrij te monitoren en Sidekiq-bottlenecks op te sporen en op te lossen.

### Redis memory usage-grafiek

De Redis memory usage-grafiek toont:

* Het Virtual Memory Size-geheugengebruik van Redis (`sidekiq_memory_usage_rss`)
* Het Resident Set Size-geheugengebruik van Redis (`sidekiq_memory_usage_rss`)

U kunt de Redis memory usage-grafiek gebruiken om het geheugengebruik van Sidekiq te monitoren, het resourcebeheer te verbeteren en geheugenintensieve jobs te optimaliseren.

### Throughput per worker-grafiek

De Throughput per worker-grafiek toont het aantal jobs dat is uitgevoerd, gegroepeerd op hostname.

U kunt deze grafiek gebruiken om de prestaties van workers te monitoren, gegroepeerd op de klasse die de job definieert.

### Worker/processes count-grafiek

De Worker/processes count-grafiek toont het aantal Sidekiq-workers en uitgevoerde processen.

U kunt de Worker/processes count-grafiek gebruiken om de werkverdeling te beheren, de toewijzing van bronnen te optimaliseren en prestatieproblemen te identificeren.

## Hostname-configuratie

AppSignal probeert de hostname van het Redis-exemplaar dat uw Sidekiq-exemplaar gebruikt om zijn wachtrijen op te slaan, te detecteren. Als de detectie niet nauwkeurig is, is het mogelijk om de hostname-configuratie aan te passen door de standaard Sidekiq-probe te overschrijven.

Eerst moet u [de standaard Sidekiq-probe overschrijven](/ruby/instrumentation/minutely-probes#overriding-default-probes) door een nieuwe probe met dezelfde naam (`:sidekiq`) te registreren. Deze probe heeft een configuratie-hash nodig, inclusief de `:hostname`-sleutel, met de nieuwe hostname-waarde. Door de `:hostname`-configuratieoptie te specificeren in de Sidekiq minutely-probe, worden de metrieken getagd met de opgegeven hostname-waarde. De waarde van de `:hostname`-configuratieoptie wordt niet gebruikt om een Redis- of Sidekiq-verbinding tot stand te brengen.

Bijvoorbeeld:

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

In versie 2.11.0 van de Ruby-gem is de constante `SidekiqProbe` verplaatst naar zijn eigen module. Bij het aanroepen van de constante wordt een waarschuwing afgedrukt en gelogd. Werk bij naar de nieuwe constantenaam `Appsignal::Probes::SidekiqProbe` om de waarschuwing te verwijderen.