Active Support is a part of core Rails that provides Ruby language extensions, utilities, and other things. One of the things it includes is an instrumentation API that can be used inside an application to measure certain actions that occur within Ruby code, such as those inside a Rails application or the framework itself. It is not limited to Rails, however. It can be used independently in other Ruby scripts if desired.
In this guide, you will learn how to use the Active Support's instrumentation API to measure events inside of Rails and other Ruby code.
After reading this guide, you will know:
What instrumentation can provide.
How to add a subscriber to a hook.
The hooks inside the Rails framework for instrumentation.
How to build a custom instrumentation implementation.
The instrumentation API provided by Active Support allows developers to provide hooks which other developers may hook into. There are several of these within the Rails framework. With this API, developers can choose to be notified when certain events occur inside their application or another piece of Ruby code.
For example, there is a hook provided within Active Record that is called every time Active Record uses an SQL query on a database. This hook could be subscribed to, and used to track the number of queries during a certain action. There's another hook around the processing of an action of a controller. This could be used, for instance, to track how long a specific action has taken.
You are even able to create your own events inside your application which you can later subscribe to.
A unique ID for the instrumenter that fired the event
The payload for the event
ActiveSupport::Notifications.subscribe"process_action.action_controller"do|name,started,finished,unique_id,data|# your own custom stuffRails.logger.info"#{name} Received! (started: #{started}, finished: #{finished})"# process_action.action_controller Received (started: 2019-05-05 13:43:57 -0800, finished: 2019-05-05 13:43:58 -0800)end
If you are concerned about the accuracy of started and finished to compute a precise elapsed time, then use ActiveSupport::Notifications.monotonic_subscribe. The given block would receive the same arguments as above, but the started and finished will have values with an accurate monotonic time instead of wall-clock time.
ActiveSupport::Notifications.monotonic_subscribe"process_action.action_controller"do|name,started,finished,unique_id,data|# your own custom stuffRails.logger.info"#{name} Received! (started: #{started}, finished: #{finished})"# process_action.action_controller Received (started: 1560978.425334, finished: 1560979.429234)end
Defining all those block arguments each time can be tedious. You can easily create an ActiveSupport::Notifications::Event
from block arguments like this:
ActiveSupport::Notifications.subscribe"process_action.action_controller"do|*args|event=ActiveSupport::Notifications::Event.new*argsevent.name# => "process_action.action_controller"event.duration# => 10 (in milliseconds)event.payload# => {:extra=>information}Rails.logger.info"#{event} Received!"end
You may also pass a block that accepts only one argument, and it will receive an event object:
ActiveSupport::Notifications.subscribe"process_action.action_controller"do|event|event.name# => "process_action.action_controller"event.duration# => 10 (in milliseconds)event.payload# => {:extra=>information}Rails.logger.info"#{event} Received!"end
You may also subscribe to events matching a regular expression. This enables you to subscribe to
multiple events at once. Here's how to subscribe to everything from ActionController:
ActiveSupport::Notifications.subscribe/action_controller/do|*args|# inspect all ActionController eventsend
Adding your own events is easy as well. Active Support will take care of
all the heavy lifting for you. Simply call ActiveSupport::Notifications.instrument with a name, payload, and a block.
The notification will be sent after the block returns. Active Support will generate the start and end times,
and add the instrumenter's unique ID. All data passed into the instrument call will make
it into the payload.
Here's an example:
ActiveSupport::Notifications.instrument"my.custom.event",this: :datado# do your custom stuff hereend
You should follow Rails conventions when defining your own events. The format is: event.library.
If your application is sending Tweets, you should create an event named tweet.twitter.
Feedback
You're encouraged to help improve the quality of this guide.
Please contribute if you see any typos or factual errors.
To get started, you can read our documentation contributions section.
You may also find incomplete content or stuff that is not up to date.
Please do add any missing documentation for main. Make sure to check
Edge Guides first to verify
if the issues are already fixed or not on the main branch.
Check the Ruby on Rails Guides Guidelines
for style and conventions.
If for whatever reason you spot something to fix but cannot patch it yourself, please
open an issue.
And last but not least, any kind of discussion regarding Ruby on Rails
documentation is very welcome on the official Ruby on Rails Forum.