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

# Rake-taken monitoren

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

Elke exceptie die in een [Rake][rake]-taak wordt geregistreerd, wordt naar AppSignal verzonden en geregistreerd onder de "Background"-[namespace](/application/namespaces). Houd er rekening mee dat we alleen excepties in Rake-taken bijhouden. Er is geen prestatie-monitoring voor Rake-taken.

(Om handmatig prestatie-monitoring te integreren in geselecteerde Rake-taken, zie onze [integratiehandleiding][integration] en [handleiding voor aangepaste instrumentatie][custom-instrumentation].)

Afhankelijk van welke versie van de AppSignal-gem u gebruikt en in welke context zijn enkele handmatige stappen vereist.

## Integraties

### Rails-applicaties

Voor Rails-applicaties zorgt u ervoor dat u afhankelijk bent van de `:environment`-taak. Dit laadt de Rails-applicatie in het geheugen en start AppSignal als onderdeel van de applicatie.

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

#### Rakefile

Het `Rakefile` van uw Rails-applicatie zou er ongeveer uit moeten zien als het onderstaande voorbeeld. Dit zou al het geval moeten zijn, u hoeft het niet te wijzigen.

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

  # Only require this file for gem version < 1.0
  # require "appsignal/integrations/rake"

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

(Voor oudere versies van de AppSignal-gem, versies `< 1`, moet u de Rake-integratie handmatig requiren. Deze wordt automatisch geladen voor versie `1.x` en hoger.)

### Ruby-applicaties

Voor pure Ruby-applicaties zijn er enkele extra stappen nodig om AppSignal te laden. AppSignal moet worden gerequired, geconfigureerd en geladen. Zie ook onze [integratiehandleiding][integration].

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

  Appsignal.start

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

## Prestaties van Rake-taken monitoren

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

Om de prestaties van Rake-taken en alle events die in de taak plaatsvinden te monitoren, configureert u AppSignal met de [configuratieoptie `enable_rake_performance_instrumentation`](/ruby/configuration/options#option-enable_rake_performance_instrumentation) ingesteld op `true`.

Met deze functie ingeschakeld worden alle Rake-taken geïnstrumenteerd en meegeteld voor uw abonnement.

## Stop-vereiste

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

Voor Rake-taken die op kortlevende hosts draaien, is het vereist om de AppSignal Ruby-gem te stoppen voordat het Rake-proces wordt afgesloten.
Dit zorgt ervoor dat de gegevens van de Rake-taken aan AppSignal worden gerapporteerd voordat de host wordt afgesloten.

Dit gedrag is alleen nodig in dergelijke scenario's zoals:

* Wanneer een geplande Rake-taak (een cron job) wordt uitgevoerd door een hostingservice.
* Wanneer een Rake-taak wordt uitgevoerd op een container die start om deze Rake-taak uit te voeren en wordt afgesloten wanneer de Rake-taak eindigt.
* Wanneer een Rake-taak wordt uitgevoerd op een Heroku-runner of vergelijkbare hostingproviders.

Het is niet nodig om de AppSignal Ruby-gem te stoppen als de host waarop het script wordt gestart, blijft draaien nadat het script is afgesloten.

AppSignal wordt automatisch gestopt wanneer de Rake-taak wordt afgesloten en een container of hosting-omgeving zoals Heroku wordt gedetecteerd.

Dit gedrag wordt beheerd door [de optie `enable_at_exit_hook`](/ruby/configuration/options#option-enable_at_exit_hook).
Zorg ervoor dat deze optie op true staat voor scripts waarvoor AppSignal moet worden gestopt, als dit niet automatisch wordt gedetecteerd.

Het kan nodig zijn om een extra `sleep`-aanroep van een paar seconden toe te voegen om ervoor te zorgen dat er voldoende tijd is om alle gegevens te verzenden. Gebruik indien nodig het `at_exit`-gebruiksvoorbeeld uit de onderstaande code.

<CodeGroup>
  ```ruby Rakefile theme={null}
  # Short-lived host example task

  # This block is called after all tasks are ran
  # Ensures the AppSignal agent has enough time to send the data to the AppSignal servers
  at_exit { sleep 10 }

  task :foo do
    # Your Rake task code
  end
  ```
</CodeGroup>

### Stop-vereiste legacy

<Warning>
  De onderstaande sectie is voor applicaties die Ruby-gem 4.5.7 en lager gebruiken.
  Deze versies bevatten niet [de optie `enable_at_exit_hook`](/ruby/configuration/options#option-enable_at_exit_hook) die dit gedrag automatiseert.

  Voor nieuwere versies van de Ruby-gem, zie de [sectie stop-vereiste](#stop-requirement).
</Warning>

Bij het uitvoeren van een enkele Rake-taak op een kortlevende host (bijv. met Docker-containers, Kubernetes of Heroku-schedulers) zijn er drie vereisten.
Dit garandeert dat de AppSignal-extensie van de app tijd heeft om de gegevens naar de agent door te spoelen en dat de agent tijd heeft om de gegevens naar onze API te verzenden voordat (de container) wordt afgesloten.

**De vereisten zijn:**

* `Appsignal.stop` moet worden aangeroepen in de Rake-taak.
  * Wanneer [Rake-taakprestatiemonitoring](#monitoring-rake-task-performance) is ingeschakeld, gebeurt dit automatisch voor alle taken.
* [`running_in_container`](/ruby/configuration/options#option-running_in_container) moet op true worden ingesteld in de configuratie.
  * Voor de meeste containertypes wordt `running_in_container` automatisch op true ingesteld wanneer gedetecteerd, voor andere is handmatige configuratie vereist.
* Een sleep van bijv. 10 seconden om de AppSignal-agent tijd te geven om de gegevens te verzenden

Een voorbeeld van hoe `Appsignal.stop` in de Rakefile wordt aangeroepen:

<CodeGroup>
  ```ruby Rakefile theme={null}
  # Short-lived host example task

  # This block is called after all tasks are ran
  # The argument "rake" is the name of the parent process name which is being
  # stopped and logs it as the reason why AppSignal is stopping.
  at_exit do
    Appsignal.stop "rake"
    sleep 10 # For short-lived hosts, give the AppSignal agent time to send the data
  end

  task :foo do
    # Tracking data with AppSignal in your task
    Appsignal.increment_counter "my_custom_counter"
  end
  ```
</CodeGroup>

**Let op**: In het bovenstaande voorbeeld is een sleep van 10 seconden toegevoegd aan het einde van het Rake-taakvoorbeeld.
Dit is vereist voor taken die op kortlevende hosts worden uitgevoerd.
Wanneer de taak voltooid is, stopt het proces.
De aanroep van `Appsignal.stop` spoelt alle transactiegegevens die zich momenteel in de AppSignal-extensie bevinden door naar onze agent.
Vervolgens slaapt het 10 seconden om de agent in staat te stellen de gegevens te verzenden voordat het wordt afgesloten.

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

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

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