> ## 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) é um processador de background simples e eficiente para Ruby. É também o processador que usamos para processar jobs no AppSignal.

Quando o AppSignal detecta métricas do Sidekiq, ele criará um [Magic Dashboard](#magic-dashboard), permitindo que você monitore métricas principais visualmente.

## Monitoramento Sidekiq para apps Ruby on Rails

A gem AppSignal Ruby insere automaticamente um listener na pilha de middleware do servidor Sidekiq se o módulo `Sidekiq` estiver presente, caso você use Rails. Nenhuma ação adicional é necessária.

A integração com o Sidekiq é compatível com [Active Job](/ruby/integrations/active-job).

## Monitoramento Sidekiq para apps Ruby

Adicionar esta config só deve ser necessário quando o Sidekiq não carrega o AppSignal automaticamente pelo framework do app, como o Rails.

Adicione este snippet à sua config do Sidekiq com o ambiente e o nome corretos:

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

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

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

## Performance monitoring

Uma vez que o AppSignal comece a reportar métricas do Sidekiq, ele fornecerá insights de performance via:

* [Event timeline](#event-timeline)
* [Error tracking](#error-tracking)
* [Incident grouping](#incident-grouping)
* [Sample breakdown](#sample-breakdown)

### Event timeline

Eventos `perform_job.sidekiq` serão mostrados na event timeline na página de detalhes do performance incident:

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

### Error tracking

Rastreie exceptions que ocorrem ao executar jobs do Sidekiq.

Quando o Sidekiq encontra um problema antes ou depois de um job ter sido processado, como ao fazer parse de JSON do Redis, ele gerará um erro. Esse erro é reportado sob a action SidekiqInternal no namespace background, pois o contexto do job é desconhecido quando o erro ocorre.

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

#### Reportar erros ao descartar job

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

Defina a [opção de configuração `sidekiq_report_errors`](/ruby/configuration/options#option-sidekiq_report_errors) como `discard` para reportar erros apenas quando um job é descartado. Quando um job é descartado, todas as tentativas de retry do job foram esgotadas, e o job não é mais executado novamente. Leia a [documentação do Sidekiq](https://github.com/sidekiq/sidekiq/wiki/Error-Handling) para saber mais sobre o tratamento de exceptions do Sidekiq e retries de jobs com falha.

<Warning>
  Ao usar o Sidekiq com o sistema de retry do Active Job, configure-o [para reportar
  erros apenas no
  discard](/ruby/integrations/active-job#report-errors-on-job-discard), para
  que ele não reporte erros várias vezes.

  Após o esgotamento dos retries do Active Job, o sistema de retry do Sidekiq irá
  assumir. Desabilite o sistema de retry do Sidekiq se este for um comportamento indesejado.
</Warning>

### Incident grouping

Os nomes dos jobs são detectados automaticamente com base no nome da classe do worker Sidekiq e sufixados com o nome do método `perform`, resultando em algo como: `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="Exemplo de agrupamento de performance incidents" width="983" height="362" data-path="assets/images/screenshots/ruby/integrations/sidekiq/job-performance-samples.png" />

### Sample performance

Os sample breakdowns permitem que você revise rapidamente a performance do Sidekiq e identifique problemas de performance sem precisar se aprofundar nos detalhes.

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

## Magic dashboard

Quando o AppSignal recebe métricas do Sidekiq, ele criará um magic dashboard do Sidekiq, disponível na seção de dashboard do app AppSignal.

O magic dashboard do Sidekiq terá os seguintes gráficos:

| Gráfico                                                | Métricas                                                           | 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`                            |

As tags fornecem um detalhamento contextual das informações de performance do Sidekiq. O AppSignal reporta as seguintes tags para jobs do Sidekiq:

| Nome        | Descrição                                                                                                      |
| ----------- | -------------------------------------------------------------------------------------------------------------- |
| `action`    | O nome da action da qual a métrica foi reportada (por exemplo, `YourWorker#perform`).                          |
| `hostname`  | O nome do host do qual a métrica foi reportada.                                                                |
| `namespace` | O nome do namespace do qual a métrica foi reportada.                                                           |
| `queue`     | Fila nomeada na qual os jobs são processados, por exemplo, `default` ou `mailer`.                              |
| `status`    | Status de cada job, `processed` ou `failed`. <br />Jobs que são `failed` também são contados como `processed`. |

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

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

### Gráfico Connection count

O gráfico Connection count mostra a contagem de conexões do Sidekiq por host.

Você pode usar o gráfico Connection count para monitorar conexões do Sidekiq por host, identificar tendências e gargalos de conexão e otimizar recursos.

### Gráfico Duration per worker

O gráfico Duration per worker mostra a quantidade de tempo que os jobs levaram para executar, agrupados por namespace e action.

Você pode usar o gráfico Duration per worker para monitorar a performance dos workers por action e namespace, dando a você uma visão geral da performance do Sidekiq 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 com uma prioridade mostra o número de jobs que foram executados, agrupados por seu status resultante, pela fila na qual foram enfileirados.

Você pode usar o gráfico Job status per queue para monitorar contagens de erros e performance dos jobs com base na fila, identificar gargalos e otimizar seus background jobs para escalabilidade.

### Gráfico Overall job status

O gráfico overall job status mostra o número de jobs Sidekiq esperados por status e namespace.

Você pode usar o gráfico Overall job status para monitorar jobs com falha e rastrear a distribuição de jobs entre namespaces.

### Gráfico Queue latency

O gráfico Queue latency mostra a latência que a fila experimentou no momento da medição. [O Sidekiq calcula isso](https://github.com/mperham/sidekiq/wiki/API) subtraindo o horário em que o último job foi enfileirado do horário da medição. Este valor é reportado em milissegundos.

Você pode usar o gráfico Queue latency para identificar atrasos no processamento de jobs, detectar congestionamento da fila e entender com que rapidez os background jobs iniciam.

### Gráfico Queue length

O gráfico Queue length mostra o comprimento das filas do Sidekiq por fila e namespace.

Você pode usar o gráfico Queue length para monitorar a performance da fila e identificar e resolver gargalos do Sidekiq.

### Gráfico Redis memory usage

O gráfico Redis memory usage mostra:

* O uso de memória Virtual Memory Size do Redis (`sidekiq_memory_usage_rss`)
* O uso de memória Resident Set Size do Redis (`sidekiq_memory_usage_rss`)

Você pode usar o gráfico Redis memory usage para monitorar o uso de memória do Sidekiq, melhorar o gerenciamento de recursos e otimizar jobs intensivos em memória.

### Gráfico Throughput per worker

O gráfico Throughput per worker mostra o número de jobs que foram executados, agrupados por hostname.

Você pode usar este gráfico para monitorar a performance do worker, agrupada pela classe que define o job.

### Gráfico Worker/processes count

O gráfico Worker/processes count mostra o número de workers e processos executados do Sidekiq.

Você pode usar o gráfico Worker/processes count para gerenciar a distribuição de carga de trabalho, otimizar a alocação de recursos e identificar problemas de performance.

## Configuração de hostname

O AppSignal tenta detectar o hostname da instância Redis que sua instância Sidekiq usa para armazenar suas filas. Se a detecção não for precisa, é possível personalizar a configuração do hostname sobrescrevendo o probe Sidekiq padrão.

Primeiro, você precisará [sobrescrever o probe Sidekiq padrão](/ruby/instrumentation/minutely-probes#overriding-default-probes) registrando um novo probe com o mesmo nome (`:sidekiq`). Este probe precisará de um hash de configuração, incluindo a chave `:hostname`, com o novo valor do hostname. Ao especificar a opção de configuração `:hostname` no minutely probe do Sidekiq, as métricas serão marcadas com o valor de hostname fornecido. O valor da opção de configuração `:hostname` não é usado para estabelecer uma conexão Redis ou Sidekiq.

Por exemplo:

<CodeGroup>
  ```ruby Ruby theme={null}
  # config/initializers/appsignal.rb ou um arquivo que é carregado no boot

  # Gem Ruby 2.11.0 e mais nova
  Appsignal::Minutely.probes.register(
    :sidekiq, # Use a mesma chave que o probe Sidekiq padrão para sobrescrevê-lo
    Appsignal::Probes::SidekiqProbe.new(:hostname => "my_sidekiq_hostname")
  )

  # Gem Ruby 2.10.x e mais antiga
  Appsignal::Minutely.probes.register(
    :sidekiq, # Use a mesma chave que o probe Sidekiq padrão para sobrescrevê-lo
    Appsignal::Hooks::SidekiqProbe.new(:hostname => "my_sidekiq_hostname")
  )
  ```
</CodeGroup>

Na versão 2.11.0 da gem Ruby, a constante `SidekiqProbe` foi movida para seu próprio módulo. Ao chamar a constante, um aviso será impresso e registrado. Atualize para o novo nome de constante `Appsignal::Probes::SidekiqProbe` para remover o aviso.