This feature requires{" "}
{v.name} version {v.version}
{getBoundText(v.bound)}.
)}
;
};
AppSignal ondersteunt [veel gems out-of-the-box][integrations] en vereist geen aanvullende instrumentation om error- en performancedata te rapporteren. Voor custom scripts en libraries die we niet ondersteunen, kunt u monitoring toevoegen door deze gids te volgen.
## Scripts monitoren
Een AppSignal-sample bestaat uit twee elementen: een transactie en events. Voordat u events rapporteert met [onze instrumentation-helpers](#instrumentation-events), moet u eerst een transactie aanmaken.
Gebruik de `Appsignal.monitor` helper om een transactie aan te maken en deze actief te maken voor de duur van het opgegeven block.
De monitor-helper rapporteert het geïnstrumenteerde codeblock als performance-metingen die worden vermeld in de Performance-sectie in de AppSignal UI, gegroepeerd op actienaam. Het houdt de duur van het block bij en rapporteert exceptions die erin optreden.
```ruby Ruby theme={null}
class CronJobScript
def call
Appsignal.monitor(
:namespace => "cron",
:action => "CronJobScript#call"
) do
# Your code
end
end
end
```
De `monitor`-helper accepteert twee keyword-argumenten:
* `namespace` (Optioneel): Pas de namespace van de transactie aan. Standaard "web".
* `action` (Vereist): We groeperen de samples van het script op deze actienaam voor het aanmaken van issues en meldingen. Zonder actienaam wordt er geen informatie over het gemonitorde block gerapporteerd, omdat we niet weten hoe de data te groeperen.
### Stel de actienaam later in
Het `action`-argument van de `Appsignal.monitor`-helper kan nil gelaten worden of expliciet ingesteld worden op `:set_later`, maar alleen als de `Appsignal.set_action`-helper nog binnen het block wordt aangeroepen om de actienaam in te stellen. Zonder actienaam wordt er geen data over het geïnstrumenteerde block gerapporteerd. Deze methode om de actienaam in te stellen kan nuttig zijn als de actienaam pas in een verwerkingsstap binnen het block kan worden bepaald.
```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
```
### Instrumentation events
Standaard rapporteert de Ruby gem events van [ondersteunde integraties][integrations]. Deze events verschijnen in de event timeline. Gebruik [onze instrumentation-helpers](/ruby/instrumentation/instrumentation) om uw eigen events aan de event timeline toe te voegen. Hierdoor ontstaat een gedetailleerdere uitsplitsing van wat er binnen het gemonitorde block gebeurt.
```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
```
## Stop-vereiste
Voor scripts die op kortlevende hosts draaien, is het vereist om de AppSignal Ruby gem te stoppen voordat het script eindigt.
Hiermee wordt ervoor gezorgd dat de data van het script naar AppSignal wordt gerapporteerd voordat de host wordt afgesloten.
Dit gedrag is alleen nodig in scenario's zoals:
* Wanneer een geplande taak (een cron job) door een hostingdienst wordt uitgevoerd.
* Wanneer een script wordt uitgevoerd op een container die start om dit script uit te voeren en stopt zodra het script eindigt.
* Wanneer een script 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 is gestart, blijft draaien nadat het script is geëindigd.
AppSignal wordt automatisch gestopt wanneer het script eindigt en een container of hostingomgeving zoals Heroku wordt gedetecteerd.
Dit gedrag wordt beheerd door de [`enable_at_exit_hook`-optie](/ruby/configuration/options#option-enable_at_exit_hook).
Zorg ervoor dat deze optie op true staat voor scripts die vereisen dat AppSignal gestopt wordt, indien dit niet automatisch wordt gedetecteerd.
Het kan nodig zijn om een extra `sleep`-aanroep van enkele seconden toe te voegen om ervoor te zorgen dat er voldoende tijd is om alle data te verzenden. Gebruik het `at_exit`-gebruiksvoorbeeld uit de onderstaande code indien nodig.
```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
De `Appsignal.monitor_and_stop`-helper is verouderd ten gunste van de [`enable_at_exit_hook`-optie](/ruby/configuration/options#option-enable_at_exit_hook), die ervoor zorgt dat `Appsignal.stop` wordt aangeroepen wanneer het proces eindigt, in plaats van telkens wanneer de `Appsignal.monitor_and_stop`-helper wordt aangeroepen.
Het gebruik ervan is beschreven in de sectie boven deze.
Gebruik deze helper alleen in versies van de Ruby gem die de [`enable_at_exit_hook`-optie](/ruby/configuration/options#option-enable_at_exit_hook) niet ondersteunen.
Als uw proces altijd één taak/job uitvoert en daarna direct eindigt, kunt u de `Appsignal.monitor_and_stop`-helper gebruiken. Hiermee wordt ervoor gezorgd dat AppSignal automatisch stopt nadat het block is uitgevoerd.
```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