activesupport 8.0.3 → 8.1.0.rc1

data/lib/active_support/message_pack/extensions.rb

@@ -7,6 +7,7 @@ require "pathname"
 require "uri/generic"
 require "msgpack/bigint"
 require "active_support/hash_with_indifferent_access"
+require "active_support/core_ext/string/output_safety"
 require "active_support/time"
 
 module ActiveSupport
@@ -102,6 +103,10 @@ module ActiveSupport
           packer: method(:write_hash_with_indifferent_access),
           unpacker: method(:read_hash_with_indifferent_access),
           recursive: true
+
+        registry.register_type 18, ActiveSupport::SafeBuffer,
+          packer: :to_s,
+          unpacker: :new
       end
 
       def install_unregistered_type_error(registry)

data/lib/active_support/message_verifiers.rb

@@ -26,6 +26,9 @@ module ActiveSupport
     # as the first rotation and <tt>transitional = true</tt>. Then, after all
     # servers have been updated, perform a second rolling deploy with
     # <tt>transitional = false</tt>.
+    #
+    #--
+    # Implemented by ActiveSupport::Messages::RotationCoordinator#transitional
 
     ##
     # :singleton-method: new
@@ -42,6 +45,9 @@ module ActiveSupport
     #   end
     #
     #   verifiers.rotate(base: "...")
+    #
+    #--
+    # Implemented by ActiveSupport::Messages::RotationCoordinator#initialize
 
     ##
     # :method: []
@@ -50,12 +56,18 @@ module ActiveSupport
     # Returns a MessageVerifier configured with a secret derived from the
     # given +salt+, and options from #rotate. MessageVerifier instances will
     # be memoized, so the same +salt+ will return the same instance.
+    #
+    #--
+    # Implemented by ActiveSupport::Messages::RotationCoordinator#[]
 
     ##
     # :method: []=
     # :call-seq: []=(salt, verifier)
     #
     # Overrides a MessageVerifier instance associated with a given +salt+.
+    #
+    #--
+    # Implemented by ActiveSupport::Messages::RotationCoordinator#[]=
 
     ##
     # :method: rotate
@@ -104,18 +116,55 @@ module ActiveSupport
     #
     #   # Uses `serializer: Marshal, url_safe: false`.
     #   verifiers[:baz]
+    #
+    #--
+    # Implemented by ActiveSupport::Messages::RotationCoordinator#rotate
+
+    ##
+    # :method: prepend
+    # :call-seq:
+    #   prepend(**options)
+    #   prepend(&block)
+    #
+    # Just like #rotate, but prepends the given options or block to the list of
+    # option sets.
+    #
+    # This can be useful when you have an already-configured +MessageVerifiers+
+    # instance, but you want to override the way messages are signed.
+    #
+    #   module ThirdParty
+    #     VERIFIERS = ActiveSupport::MessageVerifiers.new { ... }.
+    #       rotate(serializer: Marshal, url_safe: true).
+    #       rotate(serializer: Marshal, url_safe: false)
+    #   end
+    #
+    #   ThirdParty.VERIFIERS.prepend(serializer: JSON, url_safe: true)
+    #
+    #   # Uses `serializer: JSON, url_safe: true`.
+    #   # Falls back to `serializer: Marshal, url_safe: true` or
+    #   # `serializer: Marshal, url_safe: false`.
+    #   ThirdParty.VERIFIERS[:foo]
+    #
+    #--
+    # Implemented by ActiveSupport::Messages::RotationCoordinator#prepend
 
     ##
     # :method: rotate_defaults
     # :call-seq: rotate_defaults
     #
     # Invokes #rotate with the default options.
+    #
+    #--
+    # Implemented by ActiveSupport::Messages::RotationCoordinator#rotate_defaults
 
     ##
     # :method: clear_rotations
     # :call-seq: clear_rotations
     #
     # Clears the list of option sets.
+    #
+    #--
+    # Implemented by ActiveSupport::Messages::RotationCoordinator#clear_rotations
 
     ##
     # :method: on_rotation
@@ -127,6 +176,9 @@ module ActiveSupport
     # For example, this callback could log each time it is called, and thus
     # indicate whether old option sets are still in use or can be removed from
     # rotation.
+    #
+    #--
+    # Implemented by ActiveSupport::Messages::RotationCoordinator#on_rotation
 
     ##
     private

data/lib/active_support/messages/rotation_coordinator.rb

@@ -32,6 +32,15 @@ module ActiveSupport
         self
       end
 
+      def prepend(**options, &block)
+        raise ArgumentError, "Options cannot be specified when using a block" if block && !options.empty?
+        changing_configuration!
+
+        @rotate_options.unshift(block || options)
+
+        self
+      end
+
       def rotate_defaults
         rotate()
       end

data/lib/active_support/messages/rotator.rb

@@ -45,6 +45,11 @@ module ActiveSupport
         end
       end
 
+      def initialize_dup(*)
+        super
+        @rotations = @rotations.dup
+      end
+
       private
         def build_rotation(*args, **options)
           self.class.new(*args, *@args.drop(args.length), **@options, **options)

data/lib/active_support/multibyte/chars.rb

@@ -53,7 +53,14 @@ module ActiveSupport # :nodoc:
       delegate :<=>, :=~, :match?, :acts_like_string?, to: :wrapped_string
 
       # Creates a new Chars instance by wrapping _string_.
-      def initialize(string)
+      def initialize(string, deprecation: true)
+        if deprecation
+          ActiveSupport.deprecator.warn(
+            "ActiveSupport::Multibyte::Chars is deprecated and will be removed in Rails 8.2. " \
+            "Use normal string methods instead."
+          )
+        end
+
         @wrapped_string = string
         if string.encoding != Encoding::UTF_8
           @wrapped_string = @wrapped_string.dup

data/lib/active_support/multibyte.rb

@@ -12,6 +12,10 @@ module ActiveSupport # :nodoc:
     #
     #   ActiveSupport::Multibyte.proxy_class = CharsForUTF32
     def self.proxy_class=(klass)
+      ActiveSupport.deprecator.warn(
+        "ActiveSupport::Multibyte.proxy_class= is deprecated and will be removed in Rails 8.2. " \
+        "Use normal string methods instead."
+      )
       @proxy_class = klass
     end
 

data/lib/active_support/notifications/fanout.rb

@@ -17,24 +17,30 @@ module ActiveSupport
 
     module FanoutIteration # :nodoc:
       private
-        def iterate_guarding_exceptions(collection)
-          exceptions = nil
-
-          collection.each do |s|
-            yield s
-          rescue Exception => e
-            exceptions ||= []
-            exceptions << e
-          end
+        def iterate_guarding_exceptions(collection, &block)
+          case collection.size
+          when 0
+          when 1
+            collection.each(&block)
+          else
+            exceptions = nil
 
-          if exceptions
-            exceptions = exceptions.flat_map do |exception|
-              exception.is_a?(InstrumentationSubscriberError) ? exception.exceptions : [exception]
+            collection.each do |s|
+              yield s
+            rescue Exception => e
+              exceptions ||= []
+              exceptions << e
             end
-            if exceptions.size == 1
-              raise exceptions.first
-            else
-              raise InstrumentationSubscriberError.new(exceptions), cause: exceptions.first
+
+            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
           end
 
@@ -53,7 +59,6 @@ module ActiveSupport
         @other_subscribers = []
         @all_listeners_for = Concurrent::Map.new
         @groups_for = Concurrent::Map.new
-        @silenceable_groups_for = Concurrent::Map.new
       end
 
       def inspect # :nodoc:
@@ -102,11 +107,9 @@ module ActiveSupport
         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
 
@@ -184,25 +187,25 @@ module ActiveSupport
           end
       end
 
-      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
+      def group_listeners(listeners) # :nodoc:
+        listeners.group_by(&:group_class).transform_values do |s|
+          s.map(&:delegate).freeze
+        end.freeze
+      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
+      def groups_for(name) # :nodoc:
+        silenceable_groups, groups = @groups_for.compute_if_absent(name) do
+          listeners = all_listeners_for(name)
+          listeners.partition(&:silenceable).map { |l| group_listeners(l) }
         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
+              groups = groups.dup if groups.frozen?
+              base_groups = groups[group_class]
+              groups[group_class] = base_groups ? base_groups + active_subscriptions : active_subscriptions
             end
           end
         end
@@ -227,13 +230,11 @@ module ActiveSupport
       class Handle
         include FanoutIteration
 
-        def initialize(notifier, name, id, payload) # :nodoc:
+        def initialize(notifier, name, id, groups, 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
+          @groups = groups
           @state = :initialized
         end
 
@@ -267,10 +268,31 @@ module ActiveSupport
           end
       end
 
+      module NullHandle # :nodoc:
+        extend self
+
+        def start
+        end
+
+        def finish
+        end
+
+        def finish_with_values(_name, _id, _payload)
+        end
+      end
+
       include FanoutIteration
 
       def build_handle(name, id, payload)
-        Handle.new(self, name, id, payload)
+        groups = groups_for(name).map do |group_klass, grouped_listeners|
+          group_klass.new(grouped_listeners, name, id, payload)
+        end
+
+        if groups.empty?
+          NullHandle
+        else
+          Handle.new(self, name, id, groups, payload)
+        end
       end
 
       def start(name, id, payload)
@@ -286,8 +308,8 @@ module ActiveSupport
         handle.finish_with_values(name, id, payload)
       end
 
-      def publish(name, *args)
-        iterate_guarding_exceptions(listeners_for(name)) { |s| s.publish(name, *args) }
+      def publish(name, ...)
+        iterate_guarding_exceptions(listeners_for(name)) { |s| s.publish(name, ...) }
       end
 
       def publish_event(event)
@@ -387,9 +409,9 @@ module ActiveSupport
             EventedGroup
           end
 
-          def publish(name, *args)
+          def publish(...)
             if @can_publish
-              @delegate.publish name, *args
+              @delegate.publish(...)
             end
           end
 
@@ -419,8 +441,8 @@ module ActiveSupport
             TimedGroup
           end
 
-          def publish(name, *args)
-            @delegate.call name, *args
+          def publish(...)
+            @delegate.call(...)
           end
         end
 

data/lib/active_support/notifications/instrumenter.rb

@@ -164,7 +164,7 @@ module ActiveSupport
         @cpu_time_finish - @cpu_time_start
       end
 
-      # Returns the idle time time (in milliseconds) passed between the call to
+      # Returns the idle time (in milliseconds) passed between the call to
       # #start! and the call to #finish!.
       def idle_time
         diff = duration - cpu_time

data/lib/active_support/railtie.rb

@@ -15,7 +15,7 @@ module ActiveSupport
 
     initializer "active_support.isolation_level" do |app|
       config.after_initialize do
-        if level = app.config.active_support.delete(:isolation_level)
+        if level = app.config.active_support.isolation_level
           ActiveSupport::IsolatedExecutionState.isolation_level = level
         end
       end
@@ -38,19 +38,35 @@ module ActiveSupport
       end
     end
 
-    initializer "active_support.reset_execution_context" do |app|
-      app.reloader.before_class_unload { ActiveSupport::ExecutionContext.clear }
-      app.executor.to_run              { ActiveSupport::ExecutionContext.clear }
-      app.executor.to_complete         { ActiveSupport::ExecutionContext.clear }
+    initializer "active_support.set_event_reporter_context_store" do |app|
+      config.after_initialize do
+        if klass = app.config.active_support.event_reporter_context_store
+          ActiveSupport::EventReporter.context_store = klass
+        end
+      end
     end
 
-    initializer "active_support.reset_all_current_attributes_instances" do |app|
-      app.reloader.before_class_unload { ActiveSupport::CurrentAttributes.clear_all }
-      app.executor.to_run              { ActiveSupport::CurrentAttributes.reset_all }
-      app.executor.to_complete         { ActiveSupport::CurrentAttributes.reset_all }
+    initializer "active_support.reset_execution_context" do |app|
+      app.reloader.before_class_unload do
+        ActiveSupport::CurrentAttributes.clear_all
+        ActiveSupport::ExecutionContext.clear
+        ActiveSupport.event_reporter.clear_context
+      end
+
+      app.executor.to_run do
+        ActiveSupport::ExecutionContext.push
+      end
+
+      app.executor.to_complete do
+        ActiveSupport::CurrentAttributes.clear_all
+        ActiveSupport::ExecutionContext.pop
+        ActiveSupport.event_reporter.clear_context
+      end
 
       ActiveSupport.on_load(:active_support_test_case) do
         if app.config.active_support.executor_around_test_case
+          ActiveSupport::ExecutionContext.nestable = true
+
           require "active_support/executor/test_helper"
           include ActiveSupport::Executor::TestHelper
         else
@@ -63,6 +79,13 @@ module ActiveSupport
       end
     end
 
+    initializer "active_support.set_filter_parameters" do |app|
+      config.after_initialize do
+        ActiveSupport.filter_parameters += Rails.application.config.filter_parameters
+        ActiveSupport.event_reporter.reload_payload_filter
+      end
+    end
+
     initializer "active_support.deprecation_behavior" do |app|
       if app.config.active_support.report_deprecations == false
         app.deprecators.silenced = true
@@ -96,12 +119,6 @@ module ActiveSupport
       config.eager_load_namespaces << TZInfo
     end
 
-    initializer "active_support.to_time_preserves_timezone" do |app|
-      config.after_initialize do
-        ActiveSupport.to_time_preserves_timezone = app.config.active_support.to_time_preserves_timezone
-      end
-    end
-
     # Sets the default week start
     # If assigned value is not a valid day symbol (e.g. :sunday, :monday, ...), an exception will be raised.
     initializer "active_support.initialize_beginning_of_week" do |app|

data/lib/active_support/structured_event_subscriber.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "active_support/subscriber"
+
+module ActiveSupport
+  # = Active Support Structured Event \Subscriber
+  #
+  # +ActiveSupport::StructuredEventSubscriber+ consumes ActiveSupport::Notifications
+  # in order to emit structured events via +Rails.event+.
+  #
+  # An example would be the Action Controller structured event subscriber, responsible for
+  # emitting request processing events:
+  #
+  #   module ActionController
+  #     class StructuredEventSubscriber < ActiveSupport::StructuredEventSubscriber
+  #       attach_to :action_controller
+  #
+  #       def start_processing(event)
+  #         emit_event("controller.request_started",
+  #           controller: event.payload[:controller],
+  #           action: event.payload[:action],
+  #           format: event.payload[:format]
+  #         )
+  #       end
+  #     end
+  #   end
+  #
+  # After configured, whenever a <tt>"start_processing.action_controller"</tt> notification is published,
+  # it will properly dispatch the event (+ActiveSupport::Notifications::Event+) to the +start_processing+ method.
+  # The subscriber can then emit a structured event via the +emit_event+ method.
+  class StructuredEventSubscriber < Subscriber
+    class_attribute :debug_methods, instance_accessor: false, default: [] # :nodoc:
+
+    DEBUG_CHECK = proc { !ActiveSupport.event_reporter.debug_mode? }
+
+    class << self
+      def attach_to(...) # :nodoc:
+        result = super
+        set_silenced_events
+        result
+      end
+
+      private
+        def set_silenced_events
+          if subscriber
+            subscriber.silenced_events = debug_methods.to_h { |method| ["#{method}.#{namespace}", DEBUG_CHECK] }
+          end
+        end
+
+        def debug_only(method)
+          self.debug_methods << method
+          set_silenced_events
+        end
+    end
+
+    def initialize
+      super
+      @silenced_events = {}
+    end
+
+    def silenced?(event)
+      ActiveSupport.event_reporter.subscribers.none? || @silenced_events[event]&.call
+    end
+
+    attr_writer :silenced_events # :nodoc:
+
+    # Emit a structured event via Rails.event.notify.
+    #
+    # ==== Arguments
+    #
+    # * +name+ - The event name as a string or symbol
+    # * +payload+ - The event payload as a hash or object
+    # * +caller_depth+ - Stack depth for source location (default: 1)
+    # * +kwargs+ - Additional payload data merged with the payload hash
+    def emit_event(name, payload = nil, caller_depth: 1, **kwargs)
+      ActiveSupport.event_reporter.notify(name, payload, caller_depth: caller_depth + 1, **kwargs)
+    rescue => e
+      handle_event_error(name, e)
+    end
+
+    # Like +emit_event+, but only emits when the event reporter is in debug mode
+    def emit_debug_event(name, payload = nil, caller_depth: 1, **kwargs)
+      ActiveSupport.event_reporter.debug(name, payload, caller_depth: caller_depth + 1, **kwargs)
+    rescue => e
+      handle_event_error(name, e)
+    end
+
+    def call(event)
+      super
+    rescue => e
+      handle_event_error(event.name, e)
+    end
+
+    private
+      def handle_event_error(name, error)
+        ActiveSupport.error_reporter.report(error, source: name)
+      end
+  end
+end

data/lib/active_support/subscriber.rb

@@ -137,10 +137,5 @@ module ActiveSupport
       method = event.name[0, event.name.index(".")]
       send(method, event)
     end
-
-    def publish_event(event) # :nodoc:
-      method = event.name[0, event.name.index(".")]
-      send(method, event)
-    end
   end
 end

data/lib/active_support/syntax_error_proxy.rb

@@ -18,6 +18,9 @@ module ActiveSupport
 
       def label
       end
+
+      def base_label
+      end
     end
 
     class BacktraceLocationProxy < DelegateClass(Thread::Backtrace::Location) # :nodoc: