> ## 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 é um framework para declarar jobs e fazê-los rodar em diversos backends de filas, fornecido com o Rails.

A integração do Active Job rastreia a execução e eventos do job sendo executado.

Quando o AppSignal detecta métricas do Active Job, ele cria um [Magic Dashboard](#magic-dashboard), permitindo monitorar visualmente as métricas principais.

## Adapters suportados

A integração do Active Job suporta todos os [adapters do Active Job](https://api.rubyonrails.org/classes/ActiveJob/QueueAdapters.html).

Ela também pode oferecer suporte para adapters não listados naquela página, que são acessíveis através de uma gem separada. No entanto, observe que esses adapters não foram testados.

## Integração com bibliotecas suportadas pelo AppSignal

As seguintes bibliotecas de background jobs que o AppSignal suporta são automaticamente integradas com o Active Job, permitindo que o AppSignal te dê insights de desempenho mais aprofundados:

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

## Reportar erros no descarte do job

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

Defina a [opção de configuração `activejob_report_errors`](/ruby/configuration/options#option-activejob_report_errors) como `discard` para reportar erros apenas quando um job for descartado. Quando um job é descartado, todas as tentativas de retry do job foram esgotadas e o job não é mais reprocessado. Leia a [documentação do Active Job](https://guides.rubyonrails.org/active_job_basics.html#exceptions) para saber mais sobre tratamento de exceções do Active Job e retries de jobs com falha.

<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>
  Alguns adapters do Active Job (como Sidekiq, Delayed::Job, etc.) têm seu próprio
  sistema de retry. Após o Active Job ter esgotado seus retries, essas bibliotecas
  podem acionar seu próprio sistema de retry de jobs.

  Isso fará retry dos jobs mesmo após terem sido esgotados os retries do Active Job e
  o job ter sido descartado. Para evitar fazer retry de jobs após o Active Job ter parado
  de fazer retry do job e relatar erros para esses retries, certifique-se de que o
  sistema de retry do adapter esteja desabilitado.

  Ao depender do sistema de retry do Sidekiq, também configure-o [para reportar erros
  somente no descarte](/ruby/integrations/sidekiq#report-errors-on-job-discard),
  para que ele não reporte erros múltiplas vezes.
</Warning>

## Metadados

O AppSignal coleta os seguintes metadados para jobs do Active Job:

| Metadado        | Descrição                                                                           |
| --------------- | ----------------------------------------------------------------------------------- |
| Active Job ID   | O Active Job ID é reportado pelo adapter do Active Job.                             |
| Arguments       | Argumentos passados ao job ao chamar `perform_later`.                               |
| Events          | Todos os eventos `*.active_job`.                                                    |
| Job name        | ex. `MyBackgroundJob#perform` usado para agrupar o job para incidents do AppSignal. |
| Priority        | A prioridade da amostra, se usar um adapter que suporte prioridade de job.          |
| Provider job ID | O ID do job reportado pelo adapter do Active Job.                                   |
| Queue           | O nome da fila da amostra, se usar um adapter que suporte múltiplas filas.          |
| Queue time\*    | Tempo decorrido desde que um job foi enfileirado até ser executado.                 |

*\*A partir do Rails versão 6, queue times são reportados para o namespace de onde são reportados e podem ser visualizados nos [Gráficos de Performance](https://appsignal.com/redirect-to/app?to=performance/graphs) do AppSignal.*

O AppSignal usa os metadados do Active Job para te dar insights contextuais mais profundos sobre o desempenho do job. Ao inspecionar amostras do Active Job no AppSignal:

* O Job name será usado para agrupar o job para incidents do AppSignal:

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

* Os metadados (exceto job name e events) estarão disponíveis como tags filtráveis nas amostras de incident:

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

* Eventos `*.active_job` serão mostrados na timeline de eventos para amostras de desempenho:

<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

Quando o AppSignal recebe métricas do Active Job, ele cria um magic dashboard do Active Job, disponível na seção de dashboards do app do AppSignal.

O magic dashboard do Active Job terá os seguintes gráficos:

| Gráfico                                                                         | Métricas                     | [Tags](#tags)                                        |
| ------------------------------------------------------------------------------- | ---------------------------- | ---------------------------------------------------- |
| [Duration per job class](#duration-per-job-class-graph)                         | `transaction_duration`       | <li>`namespace`</li><li>`action`</li>                |
| [Job status per queue](#job-status-per-queue-graph)                             | `active_job_queue_job_count` | <li>`status`</li><li>`queue`</li>                    |
| [Job status per queue with priority](#job-status-per-queue-with-priority-graph) | `active_job_queue_job_count` | <li>`status`</li><li>`queue`</li><li>`priority`</li> |
| [Throughput per job class](#throughput-per-job-class-graph)                     | `transaction_duration`       | <li>`namespace`</li><li>`action`</li>                |

As tags fornecem um detalhamento contextual de informações de desempenho do Active Job. Atualmente, o AppSignal reporta as seguintes tags para jobs do Active Job:

| Nome       | Descrição                                                                                                    |
| ---------- | ------------------------------------------------------------------------------------------------------------ |
| `action`   | O nome da action a partir da qual a métrica foi reportada (ex.: `YourWorker#perform`).                       |
| `queue`    | Fila nomeada em que os jobs são processados, ex. `default` ou `mailer`.                                      |
| `status`   | Status de cada job, `processed` ou `failed`. <br />Jobs `failed` também são contabilizados como `processed`. |
| `priority` | A prioridade dada a cada job, ex. `0` ou `1`.                                                                |

Cada tag será representada com uma linha colorida no gráfico:

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

### Gráfico Duration per job class

O gráfico Duration per job class mostra a quantidade de tempo que os jobs levaram para executar, agrupados pela classe que define o job.

Você pode usar este gráfico para monitorar o desempenho dos jobs, por classe, dando uma visão geral do desempenho dos jobs e permitindo identificar e investigar rapidamente picos no tempo de duração.

### Gráfico Job status per queue

O gráfico Job status per queue with priority mostra o número de jobs que foram executados, agrupados pelo status resultante, pela fila em que foram enfileirados.

Você pode usar este gráfico para monitorar contagens de erros e desempenho de jobs com base na fila, identificar gargalos e otimizar seus background jobs para escalabilidade.

### Gráfico Job status per queue with priority

<Tip>
  Nem todos os [adapters do Active Job](#supported-adapters) suportam prioridade de job. Se
  os jobs não têm valores de prioridade, o gráfico ficará vazio.
</Tip>

O gráfico Job status per queue with priority mostra o número de jobs que foram executados,
agrupados pelo status resultante, pela fila em que foram enfileirados e pela
prioridade que lhes foi atribuída.

Você pode usar este gráfico para monitorar contagens de erros e desempenho de jobs com base em fila e prioridade, identificar gargalos e otimizar seus background jobs para escalabilidade.

### Gráfico Throughput per job class

O gráfico Throughput per job class mostra a quantidade de jobs que foram executados, agrupados pela classe que define o job.

Você pode usar este gráfico para monitorar quantos jobs são executados, agrupados pela classe que define o job.