activesupport 7.0.8 → 7.1.0.beta1

data/lib/active_support/notifications/fanout.rb

@@ -17,6 +17,29 @@ module ActiveSupport
       end
     end
 
+    module FanoutIteration # :nodoc:
+      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
+    end
+
     # This is a default queue implementation that ships with Notifications.
     # It just pushes events to all registered log subscribers.
     #
@@ -25,22 +48,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 +83,230 @@ 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
 
-        listeners
+      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
+
+        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
+        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
+
+          @groups.each 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
+
+          @groups.each 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 +371,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 +399,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 +413,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
-          end
-
-          def finish(name, id, payload)
-            timestack = IsolatedExecutionState[:_timestack]
-            started = timestack.pop
-            @delegate.call(name, started, Time.now, id, payload)
+          def group_class
+            TimedGroup
           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, :time, :end, :transaction_id
       attr_accessor :payload
 
       def initialize(name, start, ending, transaction_id, payload)
@@ -65,7 +113,6 @@ 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
@@ -108,7 +155,8 @@ module ActiveSupport
       # Returns the idle time time (in milliseconds) passed since 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
@@ -117,6 +165,23 @@ module ActiveSupport
         @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.
       #
@@ -133,14 +198,6 @@ module ActiveSupport
         self.end - time
       end
 
-      def <<(event)
-        @children << event
-      end
-
-      def parent_of?(event)
-        @children.include? event
-      end
-
       private
         def now
           Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)

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

data/lib/active_support/number_helper/number_converter.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 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,7 +121,8 @@ module ActiveSupport
 
       def initialize(number, options)
         @number = number
-        @opts   = options.symbolize_keys
+        @opts = options.symbolize_keys
+        @options = nil
       end
 
       def execute

data/lib/active_support/number_helper/number_to_human_size_converter.rb

@@ -5,7 +5,7 @@ require "active_support/number_helper/number_converter"
 module ActiveSupport
   module NumberHelper
     class NumberToHumanSizeConverter < NumberConverter # :nodoc:
-      STORAGE_UNITS = [:byte, :kb, :mb, :gb, :tb, :pb, :eb]
+      STORAGE_UNITS = [:byte, :kb, :mb, :gb, :tb, :pb, :eb, :zb]
 
       self.namespace      = :human
       self.validate_float = true

data/lib/active_support/number_helper/number_to_phone_converter.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/object/blank"
 require "active_support/number_helper/number_converter"
 
 module ActiveSupport

data/lib/active_support/ordered_hash.rb

@@ -7,7 +7,7 @@ YAML.add_builtin_type("omap") do |type, val|
 end
 
 module ActiveSupport
-  # DEPRECATED: <tt>ActiveSupport::OrderedHash</tt> implements a hash that preserves
+  # DEPRECATED: +ActiveSupport::OrderedHash+ implements a hash that preserves
   # insertion order.
   #
   #   oh = ActiveSupport::OrderedHash.new
@@ -17,9 +17,9 @@ module ActiveSupport
   #
   # Also, maps the +omap+ feature for YAML files
   # (See https://yaml.org/type/omap.html) to support ordered items
-  # when loading from yaml.
+  # when loading from YAML.
   #
-  # <tt>ActiveSupport::OrderedHash</tt> is namespaced to prevent conflicts
+  # +ActiveSupport::OrderedHash+ is namespaced to prevent conflicts
   # with other implementations.
   class OrderedHash < ::Hash # :nodoc:
     def to_yaml_type

data/lib/active_support/ordered_options.rb

@@ -3,6 +3,8 @@
 require "active_support/core_ext/object/blank"
 
 module ActiveSupport
+  # = Ordered Options
+  #
   # +OrderedOptions+ inherits from +Hash+ and provides dynamic accessor methods.
   #
   # With a +Hash+, key-value pairs are typically managed like this:
@@ -40,6 +42,10 @@ module ActiveSupport
       super(key.to_sym)
     end
 
+    def dig(*keys)
+      super(*keys.flatten.map(&:to_sym))
+    end
+
     def method_missing(name, *args)
       name_string = +name.to_s
       if name_string.chomp!("=")
@@ -68,6 +74,8 @@ module ActiveSupport
     end
   end
 
+  # = Inheritable Options
+  #
   # +InheritableOptions+ provides a constructor to build an OrderedOptions
   # hash inherited from another hash.
   #
@@ -76,6 +84,12 @@ module ActiveSupport
   #   h = ActiveSupport::InheritableOptions.new({ girl: 'Mary', boy: 'John' })
   #   h.girl # => 'Mary'
   #   h.boy  # => 'John'
+  #
+  # If the existing hash has string keys, call Hash#symbolize_keys on it.
+  #
+  #   h = ActiveSupport::InheritableOptions.new({ 'girl' => 'Mary', 'boy' => 'John' }.symbolize_keys)
+  #   h.girl # => 'Mary'
+  #   h.boy  # => 'John'
   class InheritableOptions < OrderedOptions
     def initialize(parent = nil)
       if parent.kind_of?(OrderedOptions)