activesupport 7.0.4 → 7.1.5.1

data/lib/active_support/notifications/fanout.rb

@@ -17,6 +17,33 @@ 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.
     #
@@ -25,22 +52,29 @@ module ActiveSupport
       include Mutex_m
 
       def initialize
-        @string_subscribers = Hash.new { |h, k| h[k] = [] }
+        @string_subscribers = Concurrent::Map.new { |h, k| h.compute_if_absent(k) { [] } }
         @other_subscribers = []
-        @listeners_for = Concurrent::Map.new
+        @all_listeners_for = Concurrent::Map.new
+        @groups_for = Concurrent::Map.new
+        @silenceable_groups_for = Concurrent::Map.new
         super
       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
           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
@@ -53,69 +87,232 @@ module ActiveSupport
           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
 
-        listeners
+        def finish(name, id, payload)
+          @event.payload = payload
+          @event.finish!
+
+          each do |s|
+            s.call(@event)
+          end
+        end
+
+        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] || 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 +377,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 +405,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 +419,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,21 @@ 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
       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?
@@ -99,24 +154,42 @@ module ActiveSupport
         @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
 
+      def children # :nodoc:
+        ActiveSupport.deprecator.warn <<~EOM
+          ActiveSupport::Notifications::Event#children is deprecated and will
+          be removed in Rails 7.2.
+        EOM
+        []
+      end
+
+      def parent_of?(event) # :nodoc:
+        ActiveSupport.deprecator.warn <<~EOM
+          ActiveSupport::Notifications::Event#parent_of? is deprecated and will
+          be removed in Rails 7.2.
+        EOM
+        start = (time - event.time) * 1000
+        start <= 0 && (start + duration >= event.duration)
+      end
+
       # Returns the difference in milliseconds between when the execution of the
       # event started and when it ended.
       #
@@ -130,15 +203,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

data/lib/active_support/notifications.rb

@@ -6,7 +6,7 @@ require "active_support/notifications/fanout"
 module ActiveSupport
   # = \Notifications
   #
-  # <tt>ActiveSupport::Notifications</tt> provides an instrumentation API for
+  # +ActiveSupport::Notifications+ provides an instrumentation API for
   # Ruby.
   #
   # == Instrumenters
@@ -237,8 +237,8 @@ module ActiveSupport
       #
       # Raises an error if invalid event name type is passed:
       #
-      #  ActiveSupport::Notifications.subscribe(:render) {|*args| ...}
-      #  #=> ArgumentError (pattern must be specified as a String, Regexp or empty)
+      #   ActiveSupport::Notifications.subscribe(:render) {|*args| ...}
+      #   #=> ArgumentError (pattern must be specified as a String, Regexp or empty)
       #
       def subscribe(pattern = nil, callback = nil, &block)
         notifier.subscribe(pattern, callback, monotonic: false, &block)

data/lib/active_support/number_helper/number_converter.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
+require "bigdecimal"
+require "bigdecimal/util"
 require "active_support/core_ext/big_decimal/conversions"
-require "active_support/core_ext/object/blank"
 require "active_support/core_ext/hash/keys"
 require "active_support/i18n"
 require "active_support/core_ext/class/attribute"
@@ -122,13 +123,14 @@ module ActiveSupport
 
       def initialize(number, options)
         @number = number
-        @opts   = options.symbolize_keys
+        @opts = options.symbolize_keys
+        @options = nil
       end
 
       def execute
         if !number
           nil
-        elsif validate_float? && !valid_float?
+        elsif validate_float? && !valid_bigdecimal
           number
         else
           convert
@@ -173,8 +175,15 @@ module ActiveSupport
           key.split(".").reduce(DEFAULTS) { |defaults, k| defaults[k.to_sym] }
         end
 
-        def valid_float?
-          Float(number, exception: false)
+        def valid_bigdecimal
+          case number
+          when Float, Rational
+            number.to_d(0)
+          when String
+            BigDecimal(number, exception: false)
+          else
+            number.to_d rescue nil
+          end
         end
     end
   end