activesupport 7.0.8 → 7.2.2

data/lib/active_support/notifications/fanout.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "mutex_m"
 require "concurrent/map"
 require "set"
 require "active_support/core_ext/object/try"
@@ -17,30 +16,62 @@ module ActiveSupport
       end
     end
 
+    module FanoutIteration # :nodoc:
+      private
+        def iterate_guarding_exceptions(collection)
+          exceptions = nil
+
+          collection.each do |s|
+            yield s
+          rescue Exception => e
+            exceptions ||= []
+            exceptions << e
+          end
+
+          if exceptions
+            exceptions = exceptions.flat_map do |exception|
+              exception.is_a?(InstrumentationSubscriberError) ? exception.exceptions : [exception]
+            end
+            if exceptions.size == 1
+              raise exceptions.first
+            else
+              raise InstrumentationSubscriberError.new(exceptions), cause: exceptions.first
+            end
+          end
+
+          collection
+        end
+    end
+
     # This is a default queue implementation that ships with Notifications.
     # It just pushes events to all registered log subscribers.
     #
     # This class is thread safe. All methods are reentrant.
     class Fanout
-      include Mutex_m
-
       def initialize
-        @string_subscribers = Hash.new { |h, k| h[k] = [] }
+        @mutex = Mutex.new
+        @string_subscribers = Concurrent::Map.new { |h, k| h.compute_if_absent(k) { [] } }
         @other_subscribers = []
-        @listeners_for = Concurrent::Map.new
-        super
+        @all_listeners_for = Concurrent::Map.new
+        @groups_for = Concurrent::Map.new
+        @silenceable_groups_for = Concurrent::Map.new
+      end
+
+      def inspect # :nodoc:
+        total_patterns = @string_subscribers.size + @other_subscribers.size
+        "#<#{self.class} (#{total_patterns} patterns)>"
       end
 
       def subscribe(pattern = nil, callable = nil, monotonic: false, &block)
         subscriber = Subscribers.new(pattern, callable || block, monotonic)
-        synchronize do
+        @mutex.synchronize do
           case pattern
           when String
             @string_subscribers[pattern] << subscriber
-            @listeners_for.delete(pattern)
+            clear_cache(pattern)
           when NilClass, Regexp
             @other_subscribers << subscriber
-            @listeners_for.clear
+            clear_cache
           else
             raise ArgumentError,  "pattern must be specified as a String, Regexp or empty"
           end
@@ -49,73 +80,236 @@ module ActiveSupport
       end
 
       def unsubscribe(subscriber_or_name)
-        synchronize do
+        @mutex.synchronize do
           case subscriber_or_name
           when String
             @string_subscribers[subscriber_or_name].clear
-            @listeners_for.delete(subscriber_or_name)
+            clear_cache(subscriber_or_name)
             @other_subscribers.each { |sub| sub.unsubscribe!(subscriber_or_name) }
           else
             pattern = subscriber_or_name.try(:pattern)
             if String === pattern
               @string_subscribers[pattern].delete(subscriber_or_name)
-              @listeners_for.delete(pattern)
+              clear_cache(pattern)
             else
               @other_subscribers.delete(subscriber_or_name)
-              @listeners_for.clear
+              clear_cache
             end
           end
         end
       end
 
-      def start(name, id, payload)
-        iterate_guarding_exceptions(listeners_for(name)) { |s| s.start(name, id, payload) }
+      def clear_cache(key = nil) # :nodoc:
+        if key
+          @all_listeners_for.delete(key)
+          @groups_for.delete(key)
+          @silenceable_groups_for.delete(key)
+        else
+          @all_listeners_for.clear
+          @groups_for.clear
+          @silenceable_groups_for.clear
+        end
       end
 
-      def finish(name, id, payload, listeners = listeners_for(name))
-        iterate_guarding_exceptions(listeners) { |s| s.finish(name, id, payload) }
+      class BaseGroup # :nodoc:
+        include FanoutIteration
+
+        def initialize(listeners, name, id, payload)
+          @listeners = listeners
+        end
+
+        def each(&block)
+          iterate_guarding_exceptions(@listeners, &block)
+        end
       end
 
-      def publish(name, *args)
-        iterate_guarding_exceptions(listeners_for(name)) { |s| s.publish(name, *args) }
+      class BaseTimeGroup < BaseGroup # :nodoc:
+        def start(name, id, payload)
+          @start_time = now
+        end
+
+        def finish(name, id, payload)
+          stop_time = now
+          each do |listener|
+            listener.call(name, @start_time, stop_time, id, payload)
+          end
+        end
       end
 
-      def publish_event(event)
-        iterate_guarding_exceptions(listeners_for(event.name)) { |s| s.publish_event(event) }
+      class MonotonicTimedGroup < BaseTimeGroup # :nodoc:
+        private
+          def now
+            Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          end
       end
 
-      def iterate_guarding_exceptions(listeners)
-        exceptions = nil
+      class TimedGroup < BaseTimeGroup # :nodoc:
+        private
+          def now
+            Time.now
+          end
+      end
 
-        listeners.each do |s|
-          yield s
-        rescue Exception => e
-          exceptions ||= []
-          exceptions << e
+      class EventedGroup < BaseGroup # :nodoc:
+        def start(name, id, payload)
+          each do |s|
+            s.start(name, id, payload)
+          end
         end
 
-        if exceptions
-          if exceptions.size == 1
-            raise exceptions.first
-          else
-            raise InstrumentationSubscriberError.new(exceptions), cause: exceptions.first
+        def finish(name, id, payload)
+          each do |s|
+            s.finish(name, id, payload)
+          end
+        end
+      end
+
+      class EventObjectGroup < BaseGroup # :nodoc:
+        def start(name, id, payload)
+          @event = build_event(name, id, payload)
+          @event.start!
+        end
+
+        def finish(name, id, payload)
+          @event.payload = payload
+          @event.finish!
+
+          each do |s|
+            s.call(@event)
           end
         end
 
-        listeners
+        private
+          def build_event(name, id, payload)
+            ActiveSupport::Notifications::Event.new name, nil, nil, id, payload
+          end
       end
 
-      def listeners_for(name)
+      def groups_for(name) # :nodoc:
+        groups = @groups_for.compute_if_absent(name) do
+          all_listeners_for(name).reject(&:silenceable).group_by(&:group_class).transform_values do |s|
+            s.map(&:delegate)
+          end
+        end
+
+        silenceable_groups = @silenceable_groups_for.compute_if_absent(name) do
+          all_listeners_for(name).select(&:silenceable).group_by(&:group_class).transform_values do |s|
+            s.map(&:delegate)
+          end
+        end
+
+        unless silenceable_groups.empty?
+          groups = groups.dup
+          silenceable_groups.each do |group_class, subscriptions|
+            active_subscriptions = subscriptions.reject { |s| s.silenced?(name) }
+            unless active_subscriptions.empty?
+              groups[group_class] = (groups[group_class] || []) + active_subscriptions
+            end
+          end
+        end
+
+        groups
+      end
+
+      # A +Handle+ is used to record the start and finish time of event.
+      #
+      # Both #start and #finish must each be called exactly once.
+      #
+      # Where possible, it's best to use the block form: ActiveSupport::Notifications.instrument.
+      # +Handle+ is a low-level API intended for cases where the block form can't be used.
+      #
+      #   handle = ActiveSupport::Notifications.instrumenter.build_handle("my.event", {})
+      #   begin
+      #     handle.start
+      #     # work to be instrumented
+      #   ensure
+      #     handle.finish
+      #   end
+      class Handle
+        include FanoutIteration
+
+        def initialize(notifier, name, id, payload) # :nodoc:
+          @name = name
+          @id = id
+          @payload = payload
+          @groups = notifier.groups_for(name).map do |group_klass, grouped_listeners|
+            group_klass.new(grouped_listeners, name, id, payload)
+          end
+          @state = :initialized
+        end
+
+        def start
+          ensure_state! :initialized
+          @state = :started
+
+          iterate_guarding_exceptions(@groups) do |group|
+            group.start(@name, @id, @payload)
+          end
+        end
+
+        def finish
+          finish_with_values(@name, @id, @payload)
+        end
+
+        def finish_with_values(name, id, payload) # :nodoc:
+          ensure_state! :started
+          @state = :finished
+
+          iterate_guarding_exceptions(@groups) do |group|
+            group.finish(name, id, payload)
+          end
+        end
+
+        private
+          def ensure_state!(expected)
+            if @state != expected
+              raise ArgumentError, "expected state to be #{expected.inspect} but was #{@state.inspect}"
+            end
+          end
+      end
+
+      include FanoutIteration
+
+      def build_handle(name, id, payload)
+        Handle.new(self, name, id, payload)
+      end
+
+      def start(name, id, payload)
+        handle_stack = (IsolatedExecutionState[:_fanout_handle_stack] ||= [])
+        handle = build_handle(name, id, payload)
+        handle_stack << handle
+        handle.start
+      end
+
+      def finish(name, id, payload, listeners = nil)
+        handle_stack = IsolatedExecutionState[:_fanout_handle_stack]
+        handle = handle_stack.pop
+        handle.finish_with_values(name, id, payload)
+      end
+
+      def publish(name, *args)
+        iterate_guarding_exceptions(listeners_for(name)) { |s| s.publish(name, *args) }
+      end
+
+      def publish_event(event)
+        iterate_guarding_exceptions(listeners_for(event.name)) { |s| s.publish_event(event) }
+      end
+
+      def all_listeners_for(name)
         # this is correctly done double-checked locking (Concurrent::Map's lookups have volatile semantics)
-        @listeners_for[name] || synchronize do
+        @all_listeners_for[name] || @mutex.synchronize do
           # use synchronisation when accessing @subscribers
-          @listeners_for[name] ||=
+          @all_listeners_for[name] ||=
             @string_subscribers[name] + @other_subscribers.select { |s| s.subscribed_to?(name) }
         end
       end
 
+      def listeners_for(name)
+        all_listeners_for(name).reject { |s| s.silenced?(name) }
+      end
+
       def listening?(name)
-        listeners_for(name).any?
+        all_listeners_for(name).any? { |s| !s.silenced?(name) }
       end
 
       # This is a sync queue, so there is no waiting.
@@ -180,15 +374,20 @@ module ActiveSupport
         end
 
         class Evented # :nodoc:
-          attr_reader :pattern
+          attr_reader :pattern, :delegate, :silenceable
 
           def initialize(pattern, delegate)
             @pattern = Matcher.wrap(pattern)
             @delegate = delegate
+            @silenceable = delegate.respond_to?(:silenced?)
             @can_publish = delegate.respond_to?(:publish)
             @can_publish_event = delegate.respond_to?(:publish_event)
           end
 
+          def group_class
+            EventedGroup
+          end
+
           def publish(name, *args)
             if @can_publish
               @delegate.publish name, *args
@@ -203,12 +402,8 @@ module ActiveSupport
             end
           end
 
-          def start(name, id, payload)
-            @delegate.start name, id, payload
-          end
-
-          def finish(name, id, payload)
-            @delegate.finish name, id, payload
+          def silenced?(name)
+            @silenceable && @delegate.silenced?(name)
           end
 
           def subscribed_to?(name)
@@ -221,63 +416,29 @@ module ActiveSupport
         end
 
         class Timed < Evented # :nodoc:
-          def publish(name, *args)
-            @delegate.call name, *args
-          end
-
-          def start(name, id, payload)
-            timestack = IsolatedExecutionState[:_timestack] ||= []
-            timestack.push Time.now
+          def group_class
+            TimedGroup
           end
 
-          def finish(name, id, payload)
-            timestack = IsolatedExecutionState[:_timestack]
-            started = timestack.pop
-            @delegate.call(name, started, Time.now, id, payload)
-          end
-        end
-
-        class MonotonicTimed < Evented # :nodoc:
           def publish(name, *args)
             @delegate.call name, *args
           end
+        end
 
-          def start(name, id, payload)
-            timestack = IsolatedExecutionState[:_timestack_monotonic] ||= []
-            timestack.push Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          end
-
-          def finish(name, id, payload)
-            timestack = IsolatedExecutionState[:_timestack_monotonic]
-            started = timestack.pop
-            @delegate.call(name, started, Process.clock_gettime(Process::CLOCK_MONOTONIC), id, payload)
+        class MonotonicTimed < Timed # :nodoc:
+          def group_class
+            MonotonicTimedGroup
           end
         end
 
         class EventObject < Evented
-          def start(name, id, payload)
-            stack = IsolatedExecutionState[:_event_stack] ||= []
-            event = build_event name, id, payload
-            event.start!
-            stack.push event
-          end
-
-          def finish(name, id, payload)
-            stack = IsolatedExecutionState[:_event_stack]
-            event = stack.pop
-            event.payload = payload
-            event.finish!
-            @delegate.call event
+          def group_class
+            EventObjectGroup
           end
 
           def publish_event(event)
             @delegate.call event
           end
-
-          private
-            def build_event(name, id, payload)
-              ActiveSupport::Notifications::Event.new name, nil, nil, id, payload
-            end
         end
       end
     end

data/lib/active_support/notifications/instrumenter.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/module/delegation"
 require "securerandom"
 
 module ActiveSupport
@@ -9,17 +10,50 @@ module ActiveSupport
       attr_reader :id
 
       def initialize(notifier)
+        unless notifier.respond_to?(:build_handle)
+          notifier = LegacyHandle::Wrapper.new(notifier)
+        end
+
         @id       = unique_id
         @notifier = notifier
       end
 
+      class LegacyHandle # :nodoc:
+        class Wrapper # :nodoc:
+          def initialize(notifier)
+            @notifier = notifier
+          end
+
+          def build_handle(name, id, payload)
+            LegacyHandle.new(@notifier, name, id, payload)
+          end
+
+          delegate :start, :finish, to: :@notifier
+        end
+
+        def initialize(notifier, name, id, payload)
+          @notifier = notifier
+          @name = name
+          @id = id
+          @payload = payload
+        end
+
+        def start
+          @listener_state = @notifier.start @name, @id, @payload
+        end
+
+        def finish
+          @notifier.finish(@name, @id, @payload, @listener_state)
+        end
+      end
+
       # Given a block, instrument it by measuring the time taken to execute
       # and publish it. Without a block, simply send a message via the
       # notifier. Notice that events get sent even if an error occurs in the
       # passed-in block.
       def instrument(name, payload = {})
-        # some of the listeners might have state
-        listeners_state = start name, payload
+        handle = build_handle(name, payload)
+        handle.start
         begin
           yield payload if block_given?
         rescue Exception => e
@@ -27,10 +61,24 @@ module ActiveSupport
           payload[:exception_object] = e
           raise e
         ensure
-          finish_with_state listeners_state, name, payload
+          handle.finish
         end
       end
 
+      # Returns a "handle" for an event with the given +name+ and +payload+.
+      #
+      # #start and #finish must each be called exactly once on the returned object.
+      #
+      # Where possible, it's best to use #instrument, which will record the
+      # start and finish of the event and correctly handle any exceptions.
+      # +build_handle+ is a low-level API intended for cases where using
+      # +instrument+ isn't possible.
+      #
+      # See ActiveSupport::Notifications::Fanout::Handle.
+      def build_handle(name, payload)
+        @notifier.build_handle(name, @id, payload)
+      end
+
       def new_event(name, payload = {}) # :nodoc:
         Event.new(name, nil, nil, @id, payload)
       end
@@ -56,7 +104,7 @@ module ActiveSupport
     end
 
     class Event
-      attr_reader :name, :time, :end, :transaction_id, :children
+      attr_reader :name, :transaction_id
       attr_accessor :payload
 
       def initialize(name, start, ending, transaction_id, payload)
@@ -65,14 +113,23 @@ module ActiveSupport
         @time           = start ? start.to_f * 1_000.0 : start
         @transaction_id = transaction_id
         @end            = ending ? ending.to_f * 1_000.0 : ending
-        @children       = []
         @cpu_time_start = 0.0
         @cpu_time_finish = 0.0
         @allocation_count_start = 0
         @allocation_count_finish = 0
+        @gc_time_start = 0
+        @gc_time_finish = 0
       end
 
-      def record
+      def time
+        @time / 1000.0 if @time
+      end
+
+      def end
+        @end / 1000.0 if @end
+      end
+
+      def record # :nodoc:
         start!
         begin
           yield payload if block_given?
@@ -89,39 +146,48 @@ module ActiveSupport
       def start!
         @time = now
         @cpu_time_start = now_cpu
+        @gc_time_start = now_gc
         @allocation_count_start = now_allocations
       end
 
       # Record information at the time this event finishes
       def finish!
         @cpu_time_finish = now_cpu
+        @gc_time_finish = now_gc
         @end = now
         @allocation_count_finish = now_allocations
       end
 
-      # Returns the CPU time (in milliseconds) passed since the call to
-      # +start!+ and the call to +finish!+
+      # Returns the CPU time (in milliseconds) passed between the call to
+      # #start! and the call to #finish!.
       def cpu_time
         @cpu_time_finish - @cpu_time_start
       end
 
-      # Returns the idle time time (in milliseconds) passed since the call to
-      # +start!+ and the call to +finish!+
+      # Returns the idle time time (in milliseconds) passed between the call to
+      # #start! and the call to #finish!.
       def idle_time
-        duration - cpu_time
+        diff = duration - cpu_time
+        diff > 0.0 ? diff : 0.0
       end
 
-      # Returns the number of allocations made since the call to +start!+ and
-      # the call to +finish!+
+      # Returns the number of allocations made between the call to #start! and
+      # the call to #finish!.
       def allocations
         @allocation_count_finish - @allocation_count_start
       end
 
+      # Returns the time spent in GC (in milliseconds) between the call to #start!
+      # and the call to #finish!
+      def gc_time
+        (@gc_time_finish - @gc_time_start) / 1_000_000.0
+      end
+
       # Returns the difference in milliseconds between when the execution of the
       # event started and when it ended.
       #
-      #   ActiveSupport::Notifications.subscribe('wait') do |*args|
-      #     @event = ActiveSupport::Notifications::Event.new(*args)
+      #   ActiveSupport::Notifications.subscribe('wait') do |event|
+      #     @event = event
       #   end
       #
       #   ActiveSupport::Notifications.instrument('wait') do
@@ -130,15 +196,7 @@ module ActiveSupport
       #
       #   @event.duration # => 1000.138
       def duration
-        self.end - time
-      end
-
-      def <<(event)
-        @children << event
-      end
-
-      def parent_of?(event)
-        @children.include? event
+        @end - @time
       end
 
       private
@@ -153,11 +211,21 @@ module ActiveSupport
             Process.clock_gettime(Process::CLOCK_THREAD_CPUTIME_ID, :float_millisecond)
           end
         rescue
-          def now_cpu # rubocop:disable Lint/DuplicateMethods
+          def now_cpu
             0.0
           end
         end
 
+        if GC.respond_to?(:total_time)
+          def now_gc
+            GC.total_time
+          end
+        else
+          def now_gc
+            0
+          end
+        end
+
         if GC.stat.key?(:total_allocated_objects)
           def now_allocations
             GC.stat(:total_allocated_objects)