activesupport 4.0.12 → 7.0.2.4

data/lib/active_support/notifications/fanout.rb

@@ -1,8 +1,22 @@
-require 'mutex_m'
-require 'thread_safe'
+# frozen_string_literal: true
+
+require "mutex_m"
+require "concurrent/map"
+require "set"
+require "active_support/core_ext/object/try"
 
 module ActiveSupport
   module Notifications
+    class InstrumentationSubscriberError < RuntimeError
+      attr_reader :exceptions
+
+      def initialize(exceptions)
+        @exceptions = exceptions
+        exception_class_names = exceptions.map { |e| e.class.name }
+        super "Exception(s) occurred within instrumentation subscribers: #{exception_class_names.join(', ')}"
+      end
+    end
+
     # This is a default queue implementation that ships with Notifications.
     # It just pushes events to all registered log subscribers.
     #
@@ -11,44 +25,92 @@ module ActiveSupport
       include Mutex_m
 
       def initialize
-        @subscribers = []
-        @listeners_for = ThreadSafe::Cache.new
+        @string_subscribers = Hash.new { |h, k| h[k] = [] }
+        @other_subscribers = []
+        @listeners_for = Concurrent::Map.new
         super
       end
 
-      def subscribe(pattern = nil, block = Proc.new)
-        subscriber = Subscribers.new pattern, block
+      def subscribe(pattern = nil, callable = nil, monotonic: false, &block)
+        subscriber = Subscribers.new(pattern, callable || block, monotonic)
         synchronize do
-          @subscribers << subscriber
-          @listeners_for.clear
+          case pattern
+          when String
+            @string_subscribers[pattern] << subscriber
+            @listeners_for.delete(pattern)
+          when NilClass, Regexp
+            @other_subscribers << subscriber
+            @listeners_for.clear
+          else
+            raise ArgumentError,  "pattern must be specified as a String, Regexp or empty"
+          end
         end
         subscriber
       end
 
-      def unsubscribe(subscriber)
+      def unsubscribe(subscriber_or_name)
         synchronize do
-          @subscribers.reject! { |s| s.matches?(subscriber) }
-          @listeners_for.clear
+          case subscriber_or_name
+          when String
+            @string_subscribers[subscriber_or_name].clear
+            @listeners_for.delete(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)
+            else
+              @other_subscribers.delete(subscriber_or_name)
+              @listeners_for.clear
+            end
+          end
         end
       end
 
       def start(name, id, payload)
-        listeners_for(name).each { |s| s.start(name, id, payload) }
+        iterate_guarding_exceptions(listeners_for(name)) { |s| s.start(name, id, payload) }
       end
 
-      def finish(name, id, payload)
-        listeners_for(name).each { |s| s.finish(name, id, payload) }
+      def finish(name, id, payload, listeners = listeners_for(name))
+        iterate_guarding_exceptions(listeners) { |s| s.finish(name, id, payload) }
       end
 
       def publish(name, *args)
-        listeners_for(name).each { |s| s.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 iterate_guarding_exceptions(listeners)
+        exceptions = nil
+
+        listeners.each do |s|
+          yield s
+        rescue Exception => e
+          exceptions ||= []
+          exceptions << e
+        end
+
+        if exceptions
+          if exceptions.size == 1
+            raise exceptions.first
+          else
+            raise InstrumentationSubscriberError.new(exceptions), cause: exceptions.first
+          end
+        end
+
+        listeners
       end
 
       def listeners_for(name)
-        # this is correctly done double-checked locking (ThreadSafe::Cache's lookups have volatile semantics)
+        # this is correctly done double-checked locking (Concurrent::Map's lookups have volatile semantics)
         @listeners_for[name] || synchronize do
           # use synchronisation when accessing @subscribers
-          @listeners_for[name] ||= @subscribers.select { |s| s.subscribed_to?(name) }
+          @listeners_for[name] ||=
+            @string_subscribers[name] + @other_subscribers.select { |s| s.subscribed_to?(name) }
         end
       end
 
@@ -61,25 +123,70 @@ module ActiveSupport
       end
 
       module Subscribers # :nodoc:
-        def self.new(pattern, listener)
-          if listener.respond_to?(:start) and listener.respond_to?(:finish)
-            subscriber = Evented.new pattern, listener
+        def self.new(pattern, listener, monotonic)
+          subscriber_class = monotonic ? MonotonicTimed : Timed
+
+          if listener.respond_to?(:start) && listener.respond_to?(:finish)
+            subscriber_class = Evented
           else
-            subscriber = Timed.new pattern, listener
+            # Doing this to detect a single argument block or callable
+            # like `proc { |x| }` vs `proc { |*x| }`, `proc { |**x| }`,
+            # or `proc { |x, **y| }`
+            procish = listener.respond_to?(:parameters) ? listener : listener.method(:call)
+
+            if procish.arity == 1 && procish.parameters.length == 1
+              subscriber_class = EventObject
+            end
           end
 
-          unless pattern
-            AllMessages.new(subscriber)
-          else
-            subscriber
+          subscriber_class.new(pattern, listener)
+        end
+
+        class Matcher # :nodoc:
+          attr_reader :pattern, :exclusions
+
+          def self.wrap(pattern)
+            if String === pattern
+              pattern
+            elsif pattern.nil?
+              AllMessages.new
+            else
+              new(pattern)
+            end
+          end
+
+          def initialize(pattern)
+            @pattern = pattern
+            @exclusions = Set.new
+          end
+
+          def unsubscribe!(name)
+            exclusions << -name if pattern === name
+          end
+
+          def ===(name)
+            pattern === name && !exclusions.include?(name)
+          end
+
+          class AllMessages
+            def ===(name)
+              true
+            end
+
+            def unsubscribe!(*)
+              false
+            end
           end
         end
 
-        class Evented #:nodoc:
+        class Evented # :nodoc:
+          attr_reader :pattern
+
           def initialize(pattern, delegate)
-            @pattern = pattern
+            @pattern = Matcher.wrap(pattern)
             @delegate = delegate
             @can_publish = delegate.respond_to?(:publish)
+            @can_publish_event = delegate.respond_to?(:publish_event)
           end
 
           def publish(name, *args)
@@ -88,6 +195,14 @@ module ActiveSupport
             end
           end
 
+          def publish_event(event)
+            if @can_publish_event
+              @delegate.publish_event event
+            else
+              publish(event.name, event.time, event.end, event.transaction_id, event.payload)
+            end
+          end
+
           def start(name, id, payload)
             @delegate.start name, id, payload
           end
@@ -97,54 +212,72 @@ module ActiveSupport
           end
 
           def subscribed_to?(name)
-            @pattern === name.to_s
+            pattern === name
           end
 
-          def matches?(subscriber_or_name)
-            self === subscriber_or_name ||
-              @pattern && @pattern === subscriber_or_name
+          def unsubscribe!(name)
+            pattern.unsubscribe!(name)
           end
         end
 
-        class Timed < Evented
+        class Timed < Evented # :nodoc:
           def publish(name, *args)
             @delegate.call name, *args
           end
 
           def start(name, id, payload)
-            timestack = Thread.current[:_timestack] ||= []
+            timestack = IsolatedExecutionState[:_timestack] ||= []
             timestack.push Time.now
           end
 
           def finish(name, id, payload)
-            timestack = Thread.current[:_timestack]
+            timestack = IsolatedExecutionState[:_timestack]
             started = timestack.pop
             @delegate.call(name, started, Time.now, id, payload)
           end
         end
 
-        class AllMessages # :nodoc:
-          def initialize(delegate)
-            @delegate = delegate
+        class MonotonicTimed < Evented # :nodoc:
+          def publish(name, *args)
+            @delegate.call name, *args
           end
 
           def start(name, id, payload)
-            @delegate.start name, id, payload
+            timestack = IsolatedExecutionState[:_timestack_monotonic] ||= []
+            timestack.push Process.clock_gettime(Process::CLOCK_MONOTONIC)
           end
 
           def finish(name, id, payload)
-            @delegate.finish name, id, payload
+            timestack = IsolatedExecutionState[:_timestack_monotonic]
+            started = timestack.pop
+            @delegate.call(name, started, Process.clock_gettime(Process::CLOCK_MONOTONIC), id, payload)
           end
+        end
 
-          def publish(name, *args)
-            @delegate.publish name, *args
+        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 subscribed_to?(name)
-            true
+          def finish(name, id, payload)
+            stack = IsolatedExecutionState[:_event_stack]
+            event = stack.pop
+            event.payload = payload
+            event.finish!
+            @delegate.call event
           end
 
-          alias :matches? :===
+          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,4 +1,6 @@
-require 'securerandom'
+# frozen_string_literal: true
+
+require "securerandom"
 
 module ActiveSupport
   module Notifications
@@ -11,21 +13,28 @@ module ActiveSupport
         @notifier = notifier
       end
 
-      # Instrument the given block by measuring the time taken to execute it
-      # and publish it. Notice that events get sent even if an error occurs
-      # in the passed-in block.
-      def instrument(name, payload={})
-        start name, payload
+      # 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
         begin
-          yield payload
+          yield payload if block_given?
         rescue Exception => e
           payload[:exception] = [e.class.name, e.message]
+          payload[:exception_object] = e
           raise e
         ensure
-          finish name, payload
+          finish_with_state listeners_state, name, payload
         end
       end
 
+      def new_event(name, payload = {}) # :nodoc:
+        Event.new(name, nil, nil, @id, payload)
+      end
+
       # Send a start notification with +name+ and +payload+.
       def start(name, payload)
         @notifier.start name, @id, payload
@@ -36,28 +45,92 @@ module ActiveSupport
         @notifier.finish name, @id, payload
       end
 
-      private
-
-      def unique_id
-        SecureRandom.hex(10)
+      def finish_with_state(listeners_state, name, payload)
+        @notifier.finish name, @id, payload, listeners_state
       end
+
+      private
+        def unique_id
+          SecureRandom.hex(10)
+        end
     end
 
     class Event
-      attr_reader :name, :time, :transaction_id, :payload, :children
-      attr_accessor :end
+      attr_reader :name, :time, :end, :transaction_id, :children
+      attr_accessor :payload
 
       def initialize(name, start, ending, transaction_id, payload)
         @name           = name
         @payload        = payload.dup
-        @time           = start
+        @time           = start ? start.to_f * 1_000.0 : start
         @transaction_id = transaction_id
-        @end            = ending
+        @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
+      end
+
+      def record
+        start!
+        begin
+          yield payload if block_given?
+        rescue Exception => e
+          payload[:exception] = [e.class.name, e.message]
+          payload[:exception_object] = e
+          raise e
+        ensure
+          finish!
+        end
+      end
+
+      # Record information at the time this event starts
+      def start!
+        @time = now
+        @cpu_time_start = now_cpu
+        @allocation_count_start = now_allocations
       end
 
+      # Record information at the time this event finishes
+      def finish!
+        @cpu_time_finish = now_cpu
+        @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!+
+      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!+
+      def idle_time
+        duration - cpu_time
+      end
+
+      # Returns the number of allocations made since the call to +start!+ and
+      # the call to +finish!+
+      def allocations
+        @allocation_count_finish - @allocation_count_start
+      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)
+      #   end
+      #
+      #   ActiveSupport::Notifications.instrument('wait') do
+      #     sleep 1
+      #   end
+      #
+      #   @event.duration # => 1000.138
       def duration
-        1000.0 * (self.end - time)
+        self.end - time
       end
 
       def <<(event)
@@ -67,6 +140,33 @@ module ActiveSupport
       def parent_of?(event)
         @children.include? event
       end
+
+      private
+        def now
+          Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
+        end
+
+        begin
+          Process.clock_gettime(Process::CLOCK_THREAD_CPUTIME_ID, :float_millisecond)
+
+          def now_cpu
+            Process.clock_gettime(Process::CLOCK_THREAD_CPUTIME_ID, :float_millisecond)
+          end
+        rescue
+          def now_cpu # rubocop:disable Lint/DuplicateMethods
+            0.0
+          end
+        end
+
+        if GC.stat.key?(:total_allocated_objects)
+          def now_allocations
+            GC.stat(:total_allocated_objects)
+          end
+        else # Likely on JRuby, TruffleRuby
+          def now_allocations
+            0
+          end
+        end
     end
   end
 end