> ## 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-Task-Monitoring

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

Jede in einem [Rake][rake]-Task aufgezeichnete Ausnahme wird an AppSignal gesendet und unter dem [Namespace](/application/namespaces) „Background" abgelegt. Beachten Sie, dass wir nur Ausnahmen in Rake-Tasks erfassen. Für Rake-Tasks gibt es kein Performance-Monitoring.

(Um Performance-Monitoring manuell in ausgewählte Rake-Tasks zu integrieren, sehen Sie sich bitte unseren [Integrationsleitfaden][integration] und unseren [Leitfaden zur benutzerdefinierten Instrumentation][custom-instrumentation] an.)

Je nachdem, welche Version des AppSignal-Gems Sie verwenden und in welchem Kontext, sind einige manuelle Schritte erforderlich.

## Integrationen

### Rails-Anwendungen

Stellen Sie für Rails-Anwendungen sicher, dass Sie vom `:environment`-Task abhängig sind. Dieser lädt die Rails-Anwendung in den Speicher und startet AppSignal als Teil der Anwendung.

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

#### Rakefile

Die `Rakefile`-Datei Ihrer Rails-Anwendung sollte etwa wie im folgenden Beispiel aussehen. Dies sollte bereits der Fall sein, eine Änderung ist nicht erforderlich.

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

(Für ältere Versionen des AppSignal-Gems, Versionen `< 1`, müssen Sie die Rake-Integration manuell laden. Sie wird ab Version `1.x` automatisch geladen.)

### Ruby-Anwendungen

Für reine Ruby-Anwendungen sind einige zusätzliche Schritte erforderlich, um AppSignal zu laden. AppSignal muss eingebunden, konfiguriert und geladen werden. Siehe auch unseren [Integrationsleitfaden][integration].

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

  Appsignal.start

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

## Performance von Rake-Tasks überwachen

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

Um die Performance von Rake-Tasks und alle Events, die im Task auftreten, zu überwachen, konfigurieren Sie AppSignal mit der [Konfigurationsoption `enable_rake_performance_instrumentation`](/ruby/configuration/options#option-enable_rake_performance_instrumentation) auf `true`.

Wenn diese Funktion aktiviert ist, werden alle Rake-Tasks instrumentiert und auf Ihren Plan angerechnet.

## Stop-Anforderung

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

Für Rake-Tasks, die auf kurzlebigen Hosts laufen, ist es erforderlich, das AppSignal-Ruby-Gem zu stoppen, bevor der Rake-Prozess beendet wird.
Dadurch wird sichergestellt, dass die Daten der Rake-Tasks an AppSignal gemeldet werden, bevor der Host heruntergefahren wird.

Dieses Verhalten ist nur in solchen Szenarien erforderlich:

* Wenn ein geplanter Rake-Task (ein Cron-Job) von einem Hosting-Dienst ausgeführt wird.
* Wenn ein Rake-Task auf einem Container ausgeführt wird, der startet, um diesen Rake-Task auszuführen, und beim Beenden des Rake-Tasks herunterfährt.
* Wenn ein Rake-Task auf einem Heroku-Runner oder bei ähnlichen Hosting-Anbietern ausgeführt wird.

Es ist nicht erforderlich, das AppSignal-Ruby-Gem zu stoppen, wenn der Host, auf dem das Skript gestartet wird, nach dem Beenden des Skripts weiterläuft.

AppSignal wird automatisch gestoppt, wenn der Rake-Task beendet wird und eine Container- oder Hosting-Umgebung wie Heroku erkannt wird.

Dieses Verhalten wird durch die [Option `enable_at_exit_hook`](/ruby/configuration/options#option-enable_at_exit_hook) gesteuert.
Stellen Sie sicher, dass diese Option für Skripte, die das Stoppen von AppSignal erfordern, auf true gesetzt ist, falls sie nicht automatisch erkannt wird.

Möglicherweise muss ein zusätzlicher `sleep`-Aufruf von einigen Sekunden hinzugefügt werden, um sicherzustellen, dass genügend Zeit zum Senden aller Daten zur Verfügung steht. Verwenden Sie bei Bedarf das `at_exit`-Beispiel aus dem folgenden 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>

### Legacy-Stop-Anforderung

<Warning>
  Der folgende Abschnitt gilt für Anwendungen, die Ruby Gem 4.5.7 oder älter verwenden.
  Diese Versionen enthalten nicht die [Option `enable_at_exit_hook`](/ruby/configuration/options#option-enable_at_exit_hook), die dieses Verhalten automatisiert.

  Für neuere Versionen des Ruby-Gems siehe den Abschnitt [Stop-Anforderung](#stop-requirement).
</Warning>

Wenn ein einzelner Rake-Task auf einem kurzlebigen Host ausgeführt wird (z. B. mit Docker-Containern, Kubernetes oder Heroku-Schedulern), gibt es drei Anforderungen.
Dies garantiert, dass die AppSignal-Extension der App Zeit hat, die Daten an den Agent zu übermitteln, und der Agent Zeit hat, die Daten an unsere API zu senden, bevor (der Container) heruntergefahren wird.

**Die Anforderungen sind:**

* `Appsignal.stop` muss im Rake-Task aufgerufen werden.
  * Wenn das [Performance-Monitoring für Rake-Tasks](#monitoring-rake-task-performance) aktiviert ist, geschieht dies automatisch für alle Tasks.
* [`running_in_container`](/ruby/configuration/options#option-running_in_container) muss in der Konfiguration auf true gesetzt sein.
  * Für die meisten Container-Typen wird `running_in_container` automatisch auf true gesetzt, wenn es erkannt wird, für andere ist eine manuelle Konfiguration erforderlich.
* Ein Sleep von z. B. 10 Sekunden, um dem AppSignal-Agent Zeit zum Senden der Daten zu geben

Ein Beispiel, wie `Appsignal.stop` im Rakefile aufgerufen wird:

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

**Hinweis**: Am Ende des Rake-Task-Beispiels wurde im obigen Beispiel ein Sleep von 10 Sekunden hinzugefügt.
Dies ist für Tasks erforderlich, die auf kurzlebigen Hosts ausgeführt werden.
Wenn der Task abgeschlossen ist, stoppt der Prozess.
Der `Appsignal.stop`-Aufruf übermittelt alle aktuell in der AppSignal-Extension befindlichen Transaktionsdaten an unseren Agent.
Anschließend schläft er 10 Sekunden, um dem Agent das Senden der Daten vor dem Herunterfahren zu ermöglichen.

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

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

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