> ## 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 ist ein Framework zum Deklarieren von Jobs und deren Ausführung auf einer Vielzahl von Queuing-Backends, das mit Rails ausgeliefert wird.

Die Active-Job-Integration verfolgt die Ausführung und Events des ausgeführten Jobs.

Wenn AppSignal Active-Job-Metriken erkennt, erstellt es ein [Magic Dashboard](#magic-dashboard), mit dem Sie die Kernmetriken visuell überwachen können.

## Unterstützte Adapter

Die Active-Job-Integration unterstützt alle [Active-Job-Adapter](https://api.rubyonrails.org/classes/ActiveJob/QueueAdapters.html).

Sie kann auch Adapter unterstützen, die nicht auf dieser Seite aufgeführt sind und über ein separates Gem erreichbar sind. Bitte beachten Sie jedoch, dass diese Adapter nicht getestet wurden.

## Integration mit von AppSignal unterstützten Bibliotheken

Die folgenden von AppSignal unterstützten Hintergrundjob-Bibliotheken sind automatisch in Active Job integriert, sodass AppSignal Ihnen tiefere Performance-Einblicke geben kann:

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

## Fehler bei Job-Verwerfen melden

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

Setzen Sie die [`activejob_report_errors`-Konfigurationsoption](/ruby/configuration/options#option-activejob_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 mehr wiederholt. Lesen Sie die [Active-Job-Dokumentation](https://guides.rubyonrails.org/active_job_basics.html#exceptions), um mehr über Active-Job-Exception-Handling und fehlgeschlagene Job-Wiederholungen zu erfahren.

<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>
  Einige Active-Job-Adapter (wie Sidekiq, Delayed::Job usw.) haben ihr eigenes
  Retry-System. Nachdem Active Job seine Wiederholungen aufgebraucht hat, können diese Bibliotheken
  ihr eigenes Job-Retry-System auslösen.

  Dies wird Jobs auch dann wiederholen, wenn Active Job die Active-Job-Wiederholungen aufgebraucht und
  den Job verworfen hat. Um zu vermeiden, dass Jobs nach Beendigung der Active-Job-Wiederholungen
  weiter wiederholt werden und Fehler für diese Wiederholungen gemeldet werden, stellen Sie sicher, dass das
  Retry-System des Adapters deaktiviert ist.

  Wenn Sie sich auf Sidekiqs Retry-System verlassen, konfigurieren Sie es auch so, dass es [Fehler
  nur bei Verwerfen meldet](/ruby/integrations/sidekiq#report-errors-on-job-discard),
  damit Fehler nicht mehrfach gemeldet werden.
</Warning>

## Metadaten

AppSignal sammelt die folgenden Metadaten für Active-Job-Jobs:

| Metadaten       | Beschreibung                                                                                       |
| --------------- | -------------------------------------------------------------------------------------------------- |
| Active Job ID   | Die Active Job ID wird vom Active-Job-Adapter gemeldet.                                            |
| Argumente       | Beim Aufruf von `perform_later` an den Job übergebene Argumente.                                   |
| Events          | Alle `*.active_job`-Events.                                                                        |
| Job-Name        | z. B. `MyBackgroundJob#perform`, wird verwendet, um den Job für AppSignal-Incidents zu gruppieren. |
| Priorität       | Die Priorität des Samples, falls ein Adapter verwendet wird, der Job-Prioritäten unterstützt.      |
| Provider-Job-ID | Die vom Active-Job-Adapter gemeldete Job-ID.                                                       |
| Queue           | Der Queue-Name des Samples, falls ein Adapter verwendet wird, der mehrere Queues unterstützt.      |
| Queue-Zeit\*    | Verstrichene Zeit zwischen Einreihen und Ausführen eines Jobs.                                     |

*\*Ab Rails-Version 6 werden Queue-Zeiten für den Namespace gemeldet, aus dem sie gemeldet werden, und können in den [Performance-Graphen](https://appsignal.com/redirect-to/app?to=performance/graphs) von AppSignal angezeigt werden.*

AppSignal verwendet Active-Job-Metadaten, um Ihnen tiefere kontextbezogene Einblicke in die Job-Performance zu geben. Beim Inspizieren von Active-Job-Samples in AppSignal:

* Der Job-Name wird verwendet, um den Job für AppSignal-Incidents zu gruppieren:

<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="Example performance issues overview" width="983" height="362" data-path="assets/images/screenshots/ruby/integrations/active-job/job-performance-samples.png" />

* Metadaten (außer Job-Name und Events) sind als filterbare Tags auf Incident-Samples verfügbar:

<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="Example Active Job tags" width="1432" height="672" data-path="assets/images/screenshots/ruby/integrations/active-job/job-tags.png" />

* `*.active_job`-Events werden in der Event-Timeline für Performance-Samples angezeigt:

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

## Magic Dashboard

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

Das Active-Job-Magic-Dashboard enthält die folgenden Graphen:

| Graph                                                                           | Metriken                     | [Tags](#tags)                                        |
| ------------------------------------------------------------------------------- | ---------------------------- | ---------------------------------------------------- |
| [Dauer pro Job-Klasse](#duration-per-job-class-graph)                           | `transaction_duration`       | <li>`namespace`</li><li>`action`</li>                |
| [Job-Status pro Queue](#job-status-per-queue-graph)                             | `active_job_queue_job_count` | <li>`status`</li><li>`queue`</li>                    |
| [Job-Status pro Queue mit Priorität](#job-status-per-queue-with-priority-graph) | `active_job_queue_job_count` | <li>`status`</li><li>`queue`</li><li>`priority`</li> |
| [Durchsatz pro Job-Klasse](#throughput-per-job-class-graph)                     | `transaction_duration`       | <li>`namespace`</li><li>`action`</li>                |

Tags geben Ihnen eine kontextbezogene Aufschlüsselung der Active-Job-Performance-Informationen, derzeit meldet AppSignal die folgenden Tags für Active-Job-Jobs:

| Name       | Beschreibung                                                                                                             |
| ---------- | ------------------------------------------------------------------------------------------------------------------------ |
| `action`   | Der Name der Action, aus der die Metrik gemeldet wurde (z. B.: `YourWorker#perform`).                                    |
| `queue`    | Benannte Queue, in der Jobs verarbeitet werden, z. B. `default` oder `mailer`.                                           |
| `status`   | Status jedes Jobs, entweder `processed` oder `failed`. <br />Jobs mit `failed` werden ebenfalls als `processed` gezählt. |
| `priority` | Die jedem Job zugewiesene Priorität, z. B. `0` oder `1`.                                                                 |

Jedes Tag wird durch eine farbige Linie im Graph dargestellt:

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

### Graph "Dauer pro Job-Klasse"

Der Graph "Dauer pro Job-Klasse" zeigt die Zeit, die zur Ausführung von Jobs benötigt wurde, gruppiert nach der Klasse, die den Job definiert.

Mit diesem Graph können Sie die Performance von Jobs pro Klasse überwachen und erhalten so eine Übersicht über die Job-Performance, mit der Sie Spitzen in der Ausführungszeit schnell identifizieren und untersuchen können.

### Graph "Job-Status pro Queue"

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

Mit diesem Graph können Sie Fehleranzahlen und Performance von Jobs basierend auf der Queue überwachen, Bottlenecks identifizieren und Ihre Hintergrundjobs auf Skalierbarkeit optimieren.

### Graph "Job-Status pro Queue mit Priorität"

<Tip>
  Nicht alle [Active-Job-Adapter](#supported-adapters) unterstützen Job-Prioritäten. Wenn
  Jobs keine Prioritätswerte haben, ist der Graph leer.
</Tip>

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

Mit diesem Graph können Sie Fehleranzahlen und Performance von Jobs basierend auf Queue und Priorität überwachen, Bottlenecks identifizieren und Ihre Hintergrundjobs auf Skalierbarkeit optimieren.

### Graph "Durchsatz pro Job-Klasse"

Der Graph "Durchsatz pro Job-Klasse" zeigt die Anzahl der ausgeführten Jobs, gruppiert nach der Klasse, die den Job definiert.

Mit diesem Graph können Sie überwachen, wie viele Jobs ausgeführt werden, gruppiert nach der Klasse, die den Job definiert.