> ## 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) ist ein einfacher und effizienter Background-Prozessor für Ruby. Es ist auch der Prozessor, den wir zur Verarbeitung von Jobs in AppSignal verwenden.

Wenn AppSignal Sidekiq-Metriken erkennt, wird ein [Magic Dashboard](#magic-dashboard) erstellt, mit dem Sie zentrale Metriken visuell überwachen können.

## Sidekiq-Monitoring für Ruby-on-Rails-Apps

Das AppSignal-Ruby-Gem fügt automatisch einen Listener in den Sidekiq-Server-Middleware-Stack ein, wenn das Modul `Sidekiq` vorhanden ist und Sie Rails verwenden. Weitere Maßnahmen sind nicht erforderlich.

Die Sidekiq-Integration ist mit [Active Job](/ruby/integrations/active-job) kompatibel.

## Sidekiq-Monitoring für Ruby-Apps

Das Hinzufügen dieser Konfiguration sollte nur erforderlich sein, wenn Sidekiq AppSignal nicht automatisch über das Framework der App, z. B. Rails, lädt.

Fügen Sie diesen Code-Schnipsel mit der richtigen Umgebung und dem richtigen Namen zu Ihrer Sidekiq-Konfiguration hinzu:

<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

Sobald AppSignal beginnt, Sidekiq-Metriken zu melden, erhalten Sie Performance-Einblicke über:

* [Event-Timeline](#event-timeline)
* [Fehlererfassung](#error-tracking)
* [Incident-Gruppierung](#incident-grouping)
* [Sample-Breakdown](#sample-breakdown)

### Event-Timeline

`perform_job.sidekiq`-Events werden in der Event-Timeline auf der Detailseite eines Performance-Incidents angezeigt:

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

### Fehlererfassung

Erfassen Sie Ausnahmen, die beim Ausführen von Sidekiq-Jobs auftreten.

Wenn Sidekiq vor oder nach der Verarbeitung eines Jobs auf ein Problem stößt, etwa beim Parsen von JSON aus Redis, wird ein Fehler ausgelöst. Dieser Fehler wird unter der Action SidekiqInternal im Namespace Background gemeldet, da der Job-Kontext beim Auftreten des Fehlers unbekannt ist.

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

#### Fehler beim Verwerfen eines Jobs melden

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

Setzen Sie die [Konfigurationsoption `sidekiq_report_errors`](/ruby/configuration/options#option-sidekiq_report_errors) auf `discard`, um Fehler nur dann zu melden, wenn ein Job verworfen wird. Wenn ein Job verworfen wird, sind alle Job-Wiederholungen aufgebraucht, und der Job wird nicht erneut versucht. Lesen Sie die [Sidekiq-Dokumentation](https://github.com/sidekiq/sidekiq/wiki/Error-Handling), um mehr über die Ausnahmebehandlung von Sidekiq und fehlgeschlagene Job-Wiederholungen zu erfahren.

<Warning>
  Wenn Sie Sidekiq mit dem Retry-System von Active Job verwenden, konfigurieren Sie es,
  [Fehler nur beim Verwerfen zu melden](/ruby/integrations/active-job#report-errors-on-job-discard),
  damit Fehler nicht mehrfach gemeldet werden.

  Nachdem die Active-Job-Wiederholungen aufgebraucht sind, übernimmt das Sidekiq-Retry-System.
  Deaktivieren Sie das Sidekiq-Retry-System, falls dieses Verhalten unerwünscht ist.
</Warning>

### Incident-Gruppierung

Job-Namen werden automatisch basierend auf dem Klassennamen des Sidekiq-Workers erkannt und mit dem Methodennamen `perform` ergänzt, was zu etwas wie `MyWorker#perform` führt.

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

Sample-Breakdowns ermöglichen es Ihnen, die Performance von Sidekiq schnell zu überprüfen und Performance-Probleme zu erkennen, ohne tief in die Details eintauchen zu müssen.

<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

Wenn AppSignal Sidekiq-Metriken empfängt, wird ein Sidekiq Magic Dashboard erstellt, das im Dashboard-Bereich der AppSignal-App verfügbar ist.

Das Sidekiq Magic Dashboard enthält die folgenden Graphen:

| Graph                                                 | Metriken                                                           | Tags                                  |
| ----------------------------------------------------- | ------------------------------------------------------------------ | ------------------------------------- |
| [Connection Count](#connection-count-graph)           | `sidekiq_connection_count`                                         | `hostname`                            |
| [Dauer pro Worker](#duration-per-worker-graph)        | `transaction_duration`                                             | <li>`action`</li><li>`namespace`</li> |
| [Job-Status pro Queue](#job-status-per-queue-graph)   | `sidekiq_queue_job_count`                                          | <li>`status`</li><li>`queue`</li>     |
| [Gesamter Job-Status](#overall-job-status-graph)      | `sidekiq_job_count`                                                | <li>`status`</li><li>`hostname`</li>  |
| [Queue-Latenz](#queue-latency-graph)                  | `sidekiq_queue_latency`                                            | <li>`hostname`</li><li>`queue`</li>   |
| [Queue-Länge](#queue-length-graph)                    | `sidekiq_queue_length`                                             | <li>`hostname`</li><li>`queue`</li>   |
| [Redis-Speichernutzung](#redis-memory-usage-graph)    | <li>`sidekiq_memory_usage`</li><li>`sidekiq_memory_usage_rss`</li> | `hostname`                            |
| [Throughput pro Worker](#throughput-per-worker-graph) | `transaction_duration`                                             | <li>`action`</li><li>`namespace`</li> |
| [Worker-/Prozessanzahl](#workerprocesses-count-graph) | <li>`sidekiq_worker_count`</li><li>`sidekiq_process_count`</li>    | `hostname`                            |

Tags geben Ihnen eine kontextbezogene Aufschlüsselung der Sidekiq-Performance-Informationen. AppSignal meldet die folgenden Tags für Sidekiq-Jobs:

| Name        | Beschreibung                                                                                                                   |
| ----------- | ------------------------------------------------------------------------------------------------------------------------------ |
| `action`    | Der Name der Action, von der die Metrik gemeldet wurde (z. B. `YourWorker#perform`).                                           |
| `hostname`  | Der Name des Hosts, von dem die Metrik gemeldet wurde.                                                                         |
| `namespace` | Der Name des Namespaces, von dem die Metrik gemeldet wurde.                                                                    |
| `queue`     | Benannte Queue, in der Jobs verarbeitet werden, z. B. `default` oder `mailer`.                                                 |
| `status`    | Status jedes Jobs, entweder `processed` oder `failed`. <br />Jobs mit dem Status `failed` werden auch als `processed` gezählt. |

Jedes Tag wird durch eine farbige Linie im Graphen dargestellt:

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

Der Connection-Count-Graph zeigt die Anzahl der Sidekiq-Verbindungen pro Host.

Sie können den Connection-Count-Graphen verwenden, um Sidekiq-Verbindungen pro Host zu überwachen, Verbindungstrends und Engpässe zu erkennen und Ressourcen zu optimieren.

### Dauer-pro-Worker-Graph

Der Dauer-pro-Worker-Graph zeigt die Zeit, die zum Ausführen von Jobs benötigt wurde, gruppiert nach Namespace und Action.

Sie können den Dauer-pro-Worker-Graphen verwenden, um die Performance der Worker pro Action und Namespace zu überwachen. So erhalten Sie einen Überblick über die Sidekiq-Performance und können Spitzen in der Dauer schnell identifizieren und untersuchen.

### Job-Status-pro-Queue-Graph

Der Job-Status-pro-Queue-mit-Priorität-Graph zeigt die Anzahl der ausgeführten Jobs, gruppiert nach ihrem resultierenden Status und nach der Queue, in der sie eingereiht wurden.

Sie können den Job-Status-pro-Queue-Graphen verwenden, um Fehlerzählungen und die Performance pro Queue zu überwachen, Engpässe zu identifizieren und Ihre Background-Jobs für die Skalierbarkeit zu optimieren.

### Gesamter-Job-Status-Graph

Der gesamte Job-Status-Graph zeigt die Anzahl der erwarteten Sidekiq-Jobs pro Status und Namespace.

Sie können den Gesamter-Job-Status-Graphen verwenden, um fehlgeschlagene Jobs zu überwachen und die Verteilung der Jobs über Namespaces hinweg zu verfolgen.

### Queue-Latenz-Graph

Der Queue-Latenz-Graph zeigt die Latenz, die die Queue zum Zeitpunkt der Messung erfahren hat. [Sidekiq berechnet dies](https://github.com/mperham/sidekiq/wiki/API), indem die Zeit, zu der der letzte Job eingereiht wurde, von der Messzeit subtrahiert wird. Dieser Wert wird in Millisekunden gemeldet.

Sie können den Queue-Latenz-Graphen verwenden, um Verzögerungen bei der Verarbeitung von Jobs zu erkennen, Queue-Engpässe zu identifizieren und zu verstehen, wie schnell Background-Jobs starten.

### Queue-Länge-Graph

Der Queue-Länge-Graph zeigt die Länge der Sidekiq-Queues pro Queue und Namespace.

Sie können den Queue-Länge-Graphen verwenden, um die Queue-Performance zu überwachen sowie Sidekiq-Engpässe zu erkennen und zu beheben.

### Redis-Speichernutzungs-Graph

Der Redis-Speichernutzungs-Graph zeigt:

* Die Virtual-Memory-Size-Speichernutzung von Redis (`sidekiq_memory_usage_rss`)
* Die Resident-Set-Size-Speichernutzung von Redis (`sidekiq_memory_usage_rss`)

Sie können den Redis-Speichernutzungs-Graphen verwenden, um die Speichernutzung von Sidekiq zu überwachen, das Ressourcenmanagement zu verbessern und speicherintensive Jobs zu optimieren.

### Throughput-pro-Worker-Graph

Der Throughput-pro-Worker-Graph zeigt die Anzahl der ausgeführten Jobs, gruppiert nach Hostname.

Sie können diesen Graphen verwenden, um die Worker-Performance, gruppiert nach der Klasse, die den Job definiert, zu überwachen.

### Worker-/Prozessanzahl-Graph

Der Worker-/Prozessanzahl-Graph zeigt die Anzahl der Sidekiq-Worker und der ausgeführten Prozesse.

Sie können den Worker-/Prozessanzahl-Graphen verwenden, um die Workload-Verteilung zu verwalten, die Ressourcenzuweisung zu optimieren und Performance-Probleme zu identifizieren.

## Hostname-Konfiguration

AppSignal versucht, den Hostnamen der Redis-Instanz zu erkennen, die Ihre Sidekiq-Instanz zum Speichern ihrer Queues verwendet. Wenn die Erkennung nicht genau ist, können Sie die Hostname-Konfiguration anpassen, indem Sie die Standard-Sidekiq-Probe überschreiben.

Zuerst müssen Sie [die Standard-Sidekiq-Probe überschreiben](/ruby/instrumentation/minutely-probes#overriding-default-probes), indem Sie eine neue Probe mit demselben Namen (`:sidekiq`) registrieren. Diese Probe benötigt einen Konfigurations-Hash, einschließlich des Schlüssels `:hostname` mit dem neuen Hostname-Wert. Durch Angabe der Konfigurationsoption `:hostname` in der Sidekiq-Minutely-Probe werden die Metriken mit dem angegebenen Hostname-Wert getaggt. Der Wert der Konfigurationsoption `:hostname` wird nicht verwendet, um eine Redis- oder Sidekiq-Verbindung herzustellen.

Zum Beispiel:

<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 Version 2.11.0 des Ruby-Gems wurde die Konstante `SidekiqProbe` in ein eigenes Modul verschoben. Beim Aufruf der Konstante wird eine Warnung ausgegeben und protokolliert. Aktualisieren Sie auf den neuen Konstantennamen `Appsignal::Probes::SidekiqProbe`, um die Warnung zu entfernen.