This feature requires{" "}
{v.name} version {v.version}
{getBoundText(v.bound)}.
)}
;
};
AppSignal unterstützt [viele Gems out-of-the-box][integrations] und benötigt keine zusätzliche Instrumentierung, um Fehler- und Performance-Daten zu melden. Für benutzerdefinierte Skripte und Bibliotheken, die wir nicht unterstützen, können Sie diesem Leitfaden folgend Monitoring hinzufügen.
## Skripte überwachen
Ein AppSignal-Sample besteht aus zwei Elementen: einer Transaktion und Events. Bevor Sie Events mit [unseren Instrumentierungs-Helpern](#instrumentation-events) melden, müssen Sie zuerst eine Transaktion erstellen.
Verwenden Sie den `Appsignal.monitor`-Helper, um eine Transaktion zu erstellen und sie für die Dauer des angegebenen Blocks aktiv zu machen.
Der Monitor-Helper meldet den instrumentierten Codeblock als Performance-Messungen, die im Performance-Bereich in der AppSignal-UI aufgeführt werden, gruppiert nach Action-Name. Er verfolgt die Dauer des Blocks und meldet Exceptions, die darin auftreten.
```ruby Ruby theme={null}
class CronJobScript
def call
Appsignal.monitor(
:namespace => "cron",
:action => "CronJobScript#call"
) do
# Your code
end
end
end
```
Der `monitor`-Helper akzeptiert zwei Keyword-Argumente:
* `namespace` (optional): Passen Sie den Namespace der Transaktion an. Standardmäßig "web".
* `action` (erforderlich): Wir gruppieren die Samples des Skripts nach diesem Action-Namen für die Erstellung von Issues und Benachrichtigungen. Ohne Action-Name werden keine Informationen über den überwachten Block gemeldet, da wir nicht wissen, wie wir die Daten gruppieren sollen.
### Action-Namen später setzen
Das `action`-Argument des `Appsignal.monitor`-Helpers kann auf nil belassen oder explizit auf `:set_later` gesetzt werden, jedoch nur, wenn der Helper `Appsignal.set_action` weiterhin innerhalb des Blocks aufgerufen wird, um den Action-Namen zu setzen. Ohne Action-Name werden keine Daten über den instrumentierten Block gemeldet. Diese Methode zum Setzen des Action-Namens kann hilfreich sein, wenn der Action-Name nur in einem Verarbeitungsschritt innerhalb des Blocks bestimmt werden kann.
```ruby Ruby theme={null}
class CronJobScript
def call
Appsignal.monitor(
:action => :set_later
) do
# Your code
# Set action name later
Appsignal.set_action("My action name")
end
end
end
```
### Instrumentierungs-Events
Standardmäßig meldet das Ruby-Gem Events von [unterstützten Integrationen][integrations]. Diese Events erscheinen in der Event-Timeline. Verwenden Sie [unsere Instrumentierungs-Helper](/ruby/instrumentation/instrumentation), um Ihre eigenen Events zur Event-Timeline hinzuzufügen. Dies erzeugt eine detailliertere Aufschlüsselung dessen, was im überwachten Block geschieht.
```ruby Ruby theme={null}
class CronJobScript
def call
Appsignal.monitor(
:namespace => "cron",
:action => "CronJobScript#call"
) do
Appsignal.instrument "fetch.plans" do
# Complex part of fetching payment plans
end
Appsignal.instrument "send.invoices" do
# Complex part of sending invoices
end
end
end
end
```
## Stopp-Anforderung
Für Skripte, die auf kurzlebigen Hosts laufen, ist es erforderlich, das AppSignal Ruby-Gem zu stoppen, bevor das Skript beendet wird.
Dies stellt sicher, dass die Daten aus dem Skript an AppSignal gemeldet werden, bevor der Host heruntergefahren wird.
Dieses Verhalten ist nur in solchen Szenarien erforderlich:
* Wenn ein geplanter Task (ein Cron-Job) von einem Hosting-Dienst ausgeführt wird.
* Wenn ein Skript auf einem Container ausgeführt wird, der zur Ausführung dieses Skripts startet und herunterfährt, wenn das Skript beendet wird.
* Wenn ein Skript auf einem Heroku-Runner oder ä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 Beendigung des Skripts weiterhin läuft.
AppSignal wird automatisch gestoppt, wenn das Skript beendet wird und ein Container oder eine Hosting-Umgebung wie Heroku erkannt wird.
Dieses Verhalten wird durch die [`enable_at_exit_hook`-Option](/ruby/configuration/options#option-enable_at_exit_hook) gesteuert.
Stellen Sie sicher, dass diese Option auf true gesetzt ist für Skripte, die ein Stoppen von AppSignal erfordern, falls dies nicht automatisch erkannt wird.
Möglicherweise müssen Sie einen zusätzlichen `sleep`-Aufruf von einigen Sekunden hinzufügen, um sicherzustellen, dass genügend Zeit ist, um alle Daten zu senden. Verwenden Sie bei Bedarf das `at_exit`-Verwendungsbeispiel aus dem unten stehenden Code.
```ruby Ruby theme={null}
# 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 }
# Your script code
```
### Monitor-and-Stop-Helper
Der `Appsignal.monitor_and_stop`-Helper ist zugunsten der [`enable_at_exit_hook`-Option](/ruby/configuration/options#option-enable_at_exit_hook) veraltet, die sicherstellt, dass `Appsignal.stop` aufgerufen wird, wenn der Prozess beendet wird, und nicht jedes Mal, wenn der `Appsignal.monitor_and_stop`-Helper aufgerufen wird.
Seine Verwendung ist im Abschnitt darüber beschrieben.
Verwenden Sie diesen Helper nur in Versionen des Ruby-Gems, die die [`enable_at_exit_hook`-Option](/ruby/configuration/options#option-enable_at_exit_hook) nicht unterstützen.
Wenn Ihr Prozess immer einen Task/Job ausführt und unmittelbar danach beendet wird, können Sie den `Appsignal.monitor_and_stop`-Helper verwenden. Dies stellt sicher, dass AppSignal nach der Ausführung des Blocks automatisch stoppt.
```ruby Ruby theme={null}
# This block is called right before the script exits
# Ensures the AppSignal agent has enough time to send the data to the AppSignal servers
at_exit do
sleep 10
end
class CronJobScript
def call
Appsignal.monitor_and_stop(
:namespace => "cron",
:action => "CronJobScript#call"
) do
# Your code
end
end
end
```
[integrations]: /ruby/integrations.html