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

# Monitoramento de Rake tasks

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: "0.11.13" }
]}
/>

Toda exception registrada em uma [Rake][rake] task será enviada para o AppSignal e arquivada no [namespace](/application/namespaces) "Background". Observe que rastreamos apenas exceptions em Rake tasks. Não há performance monitoring para Rake tasks.

(Para integrar manualmente o performance monitoring em Rake tasks selecionadas, consulte nosso [guia de integração][integration] e [guia de custom instrumentation][custom-instrumentation].)

Dependendo de qual versão da gem AppSignal você usa e em qual contexto, alguns passos manuais são necessários.

## Integrações

### Aplicações Rails

Para aplicações Rails, certifique-se de depender da task `:environment`. Isso carrega a aplicação Rails na memória e inicia o AppSignal como parte da aplicação.

<CodeGroup>
  ```ruby Ruby theme={null}
  # lib/tasks/my_task.rb
  task :my_task => :environment do
    # faça algo
  end
  ```
</CodeGroup>

#### Rakefile

O `Rakefile` da sua aplicação Rails deve se parecer com o exemplo abaixo. Isso já deveria estar acontecendo, não há necessidade de alterá-lo.

<CodeGroup>
  ```ruby Ruby theme={null}
  # Rakefile
  require File.expand_path("../config/application", __FILE__)

  # Requer este arquivo apenas para versões da gem < 1.0
  # require "appsignal/integrations/rake"

  Rails.application.load_tasks
  ```
</CodeGroup>

(Para versões mais antigas da gem AppSignal, versões `< 1`, você precisará requerer a integração Rake manualmente. Ela é carregada automaticamente para a versão `1.x` e superiores.)

### Aplicações Ruby

Para aplicações Ruby puras, alguns passos extras são necessários para carregar o AppSignal. O AppSignal precisa ser requerido, configurado e carregado. Veja também nosso [guia de integração][integration].

<CodeGroup>
  ```ruby Ruby theme={null}
  # Rakefile
  require "appsignal"

  Appsignal.start

  task :foo do
    raise "bar"
  end
  ```
</CodeGroup>

## Monitorando performance de Rake tasks

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

Para monitorar a performance de Rake tasks e todos os eventos que ocorrem na task, configure o AppSignal com a [opção de configuração `enable_rake_performance_instrumentation`](/ruby/configuration/options#option-enable_rake_performance_instrumentation) definida como `true`.

Com esta funcionalidade habilitada, todas as Rake tasks serão instrumentadas e contadas em direção ao seu plano.

## Requisito de stop

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

Para Rake tasks executando em hosts de curta duração, é necessário parar a gem AppSignal Ruby antes que o processo Rake termine.
Isso garantirá que ele reporte os dados das Rake tasks ao AppSignal antes que o host seja desligado.

Esse comportamento é necessário apenas em cenários como:

* Quando uma Rake task agendada (um cron job) é executada por um serviço de hospedagem.
* Quando uma Rake task é executada em um container que inicia para executar esta Rake task e desliga quando a Rake task termina.
* Quando uma Rake task é executada em um Heroku runner ou provedores de hospedagem similares.

Não é necessário parar a gem AppSignal Ruby se o host no qual o script é iniciado continuar rodando após o término do script.

O AppSignal é parado automaticamente quando a Rake task termina e um container ou ambiente de hospedagem como Heroku é detectado.

Este comportamento é controlado pela [opção `enable_at_exit_hook`](/ruby/configuration/options#option-enable_at_exit_hook).
Certifique-se de que esta opção esteja definida como true para scripts que exigem que o AppSignal seja parado, caso não seja detectado automaticamente.

Pode ser necessário adicionar uma chamada adicional de `sleep` de alguns segundos para garantir que haja tempo suficiente para enviar todos os dados. Use o exemplo de uso de `at_exit` do código abaixo, se necessário.

<CodeGroup>
  ```ruby Rakefile theme={null}
  # Exemplo de task em host de curta duração

  # Este bloco é chamado depois que todas as tasks são executadas
  # Garante que o AppSignal agent tenha tempo suficiente para enviar os dados para os servidores AppSignal
  at_exit { sleep 10 }

  task :foo do
    # O código da sua Rake task
  end
  ```
</CodeGroup>

### Requisito de stop legado

<Warning>
  A seção abaixo é para aplicações usando a gem Ruby 4.5.7 e versões inferiores.
  Essas versões não incluem a [opção `enable_at_exit_hook`](/ruby/configuration/options#option-enable_at_exit_hook) que automatiza esse comportamento.

  Para versões mais novas da gem Ruby, veja a seção [requisito de stop](#stop-requirement).
</Warning>

Ao executar uma única Rake task em um host de curta duração (por exemplo, com containers Docker, Kubernetes ou Heroku schedulers) existem três requisitos.
Isso garante que a extensão AppSignal do app tenha tempo de descarregar os dados para o agent e o agent tenha tempo de enviar os dados para a nossa API antes de desligar (o container).

**Os requisitos são:**

* `Appsignal.stop` deve ser chamado na Rake task.
  * Quando o [performance monitoring de Rake task](#monitoring-rake-task-performance) está habilitado, isso é feito automaticamente para todas as tasks.
* [`running_in_container`](/ruby/configuration/options#option-running_in_container) deve ser definido como true na config.
  * Para a maioria dos tipos de container, `running_in_container` é automaticamente definido como true quando detectado; para outros, configuração manual é necessária.
* Um sleep de, por exemplo, 10 segundos para dar tempo ao AppSignal agent de enviar os dados

Um exemplo de como `Appsignal.stop` é chamado no Rakefile:

<CodeGroup>
  ```ruby Rakefile theme={null}
  # Exemplo de task em host de curta duração

  # Este bloco é chamado depois que todas as tasks são executadas
  # O argumento "rake" é o nome do nome do processo pai que está sendo
  # parado e o registra como o motivo pelo qual o AppSignal está parando.
  at_exit do
    Appsignal.stop "rake"
    sleep 10 # Para hosts de curta duração, dê tempo ao AppSignal agent de enviar os dados
  end

  task :foo do
    # Rastreando dados com o AppSignal na sua task
    Appsignal.increment_counter "my_custom_counter"
  end
  ```
</CodeGroup>

**Observação**: Um sleep de 10 segundos foi adicionado ao final do exemplo de Rake task acima.
Isso é necessário para tasks que são executadas em hosts de curta duração.
Quando a task é concluída, o processo é interrompido.
A chamada `Appsignal.stop` descarrega todos os dados de transaction atualmente na extensão AppSignal para o nosso agent.
Em seguida, ele dorme por 10 segundos para permitir que o agent envie os dados antes de desligar.

[rake]: https://github.com/ruby/rake

[integration]: /ruby/instrumentation/integrating-appsignal.html

[custom-instrumentation]: /ruby/instrumentation/instrumentation.html