Introduce 'ActiveSupport::Notifications::Fanout::Subscribers::MonotonicTimed' and 'ActiveSupport::Notifications::monotonic_subscribe'

Also, change the signature of ‘ActiveSupport::Notifications::Fanout#subscribe’ to accept optional ‘monotonic’ boolean argument. Then initialize either a ‘Timed’ or ‘MonotonicTimed’ subscriber based on the value of ‘monotonic’ parameter.

Introduce ‘ActiveSupport::Notifications::monotonic_subscribe’ method

Also, provision ‘ActiveSupport::Notifications::subscribed’ to optionally accept ‘monotonic’ boolean argument.

Update documentation for ActiveSupport::Notifications

Add tests

Update guides documentation under the 'Active Support Instrumentation' chapter

Incorporate feedback: use optional keyword argument to specify optional 'monotonic' option to 'subscribed' method

Fix a typo

1 files changed, 21 insertions, 4 deletions

diff --git a/activesupport/lib/active_support/notifications/fanout.rb b/activesupport/lib/active_support/notifications/fanout.rb
index c506b35b1e..c37bec4ee5 100644
--- a/activesupport/lib/active_support/notifications/fanout.rb
+++ b/activesupport/lib/active_support/notifications/fanout.rb
@@ -20,8 +20,8 @@ module ActiveSupport
         super
       end
 
-      def subscribe(pattern = nil, callable = nil, &block)
-        subscriber = Subscribers.new(pattern, callable || block)
+      def subscribe(pattern = nil, callable = nil, monotonic = false, &block)
+        subscriber = Subscribers.new(monotonic, pattern, callable || block)
         synchronize do
           if String === pattern
             @string_subscribers[pattern] << subscriber
@@ -84,8 +84,8 @@ module ActiveSupport
       end
 
       module Subscribers # :nodoc:
-        def self.new(pattern, listener)
-          subscriber_class = Timed
+        def self.new(monotonic, pattern, listener)
+          subscriber_class = monotonic ? MonotonicTimed : Timed
 
           if listener.respond_to?(:start) && listener.respond_to?(:finish)
             subscriber_class = Evented
@@ -190,6 +190,23 @@ module ActiveSupport
           end
         end
 
+        class MonotonicTimed < Evented # :nodoc:
+          def publish(name, *args)
+            @delegate.call name, *args
+          end
+
+          def start(name, id, payload)
+            timestack = Thread.current[:_timestack_monotonic] ||= []
+            timestack.push Concurrent.monotonic_time
+          end
+
+          def finish(name, id, payload)
+            timestack = Thread.current[:_timestack_monotonic]
+            started = timestack.pop
+            @delegate.call(name, started, Concurrent.monotonic_time, id, payload)
+          end
+        end
+
         class EventObject < Evented
           def start(name, id, payload)
             stack = Thread.current[:_event_stack] ||= []