activesupport 7.2.3 → 8.0.0.beta1

data/lib/active_support/core_ext/benchmark.rb

@@ -1,17 +1,13 @@
 # frozen_string_literal: true
 
 require "benchmark"
-return if Benchmark.respond_to?(:ms)
 
 class << Benchmark
-  # Benchmark realtime in milliseconds.
-  #
-  #   Benchmark.realtime { User.all }
-  #   # => 8.0e-05
-  #
-  #   Benchmark.ms { User.all }
-  #   # => 0.074
-  def ms(&block)
-    1000 * realtime(&block)
+  def ms(&block) # :nodoc
+    # NOTE: Please also remove the Active Support `benchmark` dependency when removing this
+    ActiveSupport.deprecator.warn <<~TEXT
+      `Benchmark.ms` is deprecated and will be removed in Rails 8.1 without replacement.
+    TEXT
+    ActiveSupport::Benchmark.realtime(:float_millisecond, &block)
   end
 end

data/lib/active_support/core_ext/class/attribute.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/module/redefine_method"
+require "active_support/class_attribute"
 
 class Class
   # Declare a class-level attribute whose value is inheritable by subclasses.
@@ -83,32 +84,24 @@ class Class
   #
   #   class_attribute :settings, default: {}
   def class_attribute(*attrs, instance_accessor: true,
-    instance_reader: instance_accessor, instance_writer: instance_accessor, instance_predicate: true, default: nil
-  )
+    instance_reader: instance_accessor, instance_writer: instance_accessor, instance_predicate: true, default: nil)
+
     class_methods, methods = [], []
     attrs.each do |name|
       unless name.is_a?(Symbol) || name.is_a?(String)
         raise TypeError, "#{name.inspect} is not a symbol nor a string"
       end
 
-      class_methods << <<~RUBY # In case the method exists and is not public
-        silence_redefinition_of_method def #{name}
-        end
-      RUBY
-
-      methods << <<~RUBY if instance_reader
-        silence_redefinition_of_method def #{name}
-          defined?(@#{name}) ? @#{name} : self.class.#{name}
-        end
-      RUBY
+      name = name.to_sym
+      ::ActiveSupport::ClassAttribute.redefine(self, name, default)
 
-      class_methods << <<~RUBY
-        silence_redefinition_of_method def #{name}=(value)
-          redefine_method(:#{name}) { value } if singleton_class?
-          redefine_singleton_method(:#{name}) { value }
-          value
-        end
-      RUBY
+      unless singleton_class?
+        methods << <<~RUBY if instance_reader
+          silence_redefinition_of_method def #{name}
+            defined?(@#{name}) ? @#{name} : self.class.#{name}
+          end
+        RUBY
+      end
 
       methods << <<~RUBY if instance_writer
         silence_redefinition_of_method(:#{name}=)
@@ -125,7 +118,5 @@ class Class
 
     location = caller_locations(1, 1).first
     class_eval(["class << self", *class_methods, "end", *methods].join(";").tr("\n", ";"), location.path, location.lineno)
-
-    attrs.each { |name| public_send("#{name}=", default) }
   end
 end

data/lib/active_support/core_ext/date/conversions.rb

@@ -17,6 +17,7 @@ class Date
       date.strftime("%B #{day_format}, %Y") # => "April 25th, 2007"
     },
     rfc822: "%d %b %Y",
+    rfc2822: "%d %b %Y",
     iso8601: lambda { |date| date.iso8601 }
   }
 
@@ -34,6 +35,7 @@ class Date
   #   date.to_fs(:long)          # => "November 10, 2007"
   #   date.to_fs(:long_ordinal)  # => "November 10th, 2007"
   #   date.to_fs(:rfc822)        # => "10 Nov 2007"
+  #   date.to_fs(:rfc2822)       # => "10 Nov 2007"
   #   date.to_fs(:iso8601)       # => "2007-11-10"
   #
   # == Adding your own date formats to to_fs

data/lib/active_support/core_ext/date_and_time/compatibility.rb

@@ -26,8 +26,8 @@ module DateAndTime
         # Only warn once, the first time the value is used (which should
         # be the first time #to_time is called).
         ActiveSupport.deprecator.warn(
-          "to_time will always preserve the timezone offset of the receiver in Rails 8.0. " \
-          "To opt in to the new behavior, set `ActiveSupport.to_time_preserves_timezone = true`."
+          "`to_time` will always preserve the receiver timezone rather than system local time in Rails 8.0." \
+          "To opt in to the new behavior, set `config.active_support.to_time_preserves_timezone = :zone`."
         )
 
         @@preserve_timezone = false

data/lib/active_support/core_ext/date_time/conversions.rb

@@ -11,8 +11,7 @@ class DateTime
   #
   # This method is aliased to <tt>to_formatted_s</tt>.
   #
-  # ==== Examples
-  #
+  # === Examples
   #   datetime = DateTime.civil(2007, 12, 4, 0, 0, 0, 0)   # => Tue, 04 Dec 2007 00:00:00 +0000
   #
   #   datetime.to_fs(:db)            # => "2007-12-04 00:00:00"
@@ -24,8 +23,7 @@ class DateTime
   #   datetime.to_fs(:rfc822)        # => "Tue, 04 Dec 2007 00:00:00 +0000"
   #   datetime.to_fs(:iso8601)       # => "2007-12-04T00:00:00+00:00"
   #
-  # ==== Adding your own datetime formats to +to_fs+
-  #
+  # == Adding your own datetime formats to to_fs
   # DateTime formats are shared with Time. You can add your own to the
   # Time::DATE_FORMATS hash. Use the format name as the hash key and
   # either a strftime string or Proc instance that takes a time or

data/lib/active_support/core_ext/enumerable.rb

@@ -192,34 +192,27 @@ module Enumerable
   #   # => [ Person.find(1), Person.find(5), Person.find(3) ]
   #
   # If the +series+ include keys that have no corresponding element in the Enumerable, these are ignored.
-  # If the Enumerable has additional elements that aren't named in the +series+, these are not included in the result.
-  def in_order_of(key, series)
-    group_by(&key).values_at(*series).flatten(1).compact
+  # If the Enumerable has additional elements that aren't named in the +series+, these are not included in the result, unless
+  # the +filter+ option is set to +false+.
+  def in_order_of(key, series, filter: true)
+    if filter
+      group_by(&key).values_at(*series).flatten(1).compact
+    else
+      sort_by { |v| series.index(v.public_send(key)) || series.size }.compact
+    end
   end
 
   # Returns the sole item in the enumerable. If there are no items, or more
-  # than one item, raises Enumerable::SoleItemExpectedError.
+  # than one item, raises +Enumerable::SoleItemExpectedError+.
   #
   #   ["x"].sole          # => "x"
   #   Set.new.sole        # => Enumerable::SoleItemExpectedError: no item found
   #   { a: 1, b: 2 }.sole # => Enumerable::SoleItemExpectedError: multiple items found
   def sole
-    result = nil
-    found = false
-
-    each do |*element|
-      if found
-        raise SoleItemExpectedError, "multiple items found"
-      end
-
-      result = element.size == 1 ? element[0] : element
-      found = true
-    end
-
-    if found
-      result
-    else
-      raise SoleItemExpectedError, "no item found"
+    case count
+    when 1   then return first # rubocop:disable Style/RedundantReturn
+    when 0   then raise ActiveSupport::EnumerableCoreExt::SoleItemExpectedError, "no item found"
+    when 2.. then raise ActiveSupport::EnumerableCoreExt::SoleItemExpectedError, "multiple items found"
     end
   end
 end

data/lib/active_support/core_ext/erb/util.rb

@@ -174,7 +174,7 @@ class ERB
 
         case source.matched
         when start_re
-          tokens << [:TEXT, source.string.byteslice(pos, len)] if len > 0
+          tokens << [:TEXT, source.string[pos, len]] if len > 0
           tokens << [:OPEN, source.matched]
           if source.scan(/(.*?)(?=#{finish_re}|\z)/m)
             tokens << [:CODE, source.matched] unless source.matched.empty?
@@ -183,7 +183,7 @@ class ERB
             raise NotImplementedError
           end
         when finish_re
-          tokens << [:CODE, source.string.byteslice(pos, len)] if len > 0
+          tokens << [:CODE, source.string[pos, len]] if len > 0
           tokens << [:CLOSE, source.matched]
         else
           raise NotImplementedError, source.matched

data/lib/active_support/core_ext/hash/except.rb

@@ -1,18 +1,6 @@
 # frozen_string_literal: true
 
 class Hash
-  # Returns a hash that includes everything except given keys.
-  #   hash = { a: true, b: false, c: nil }
-  #   hash.except(:c)     # => { a: true, b: false }
-  #   hash.except(:a, :b) # => { c: nil }
-  #   hash                # => { a: true, b: false, c: nil }
-  #
-  # This is useful for limiting a set of parameters to everything but a few known toggles:
-  #   @person.update(params[:person].except(:admin))
-  def except(*keys)
-    slice(*self.keys - keys)
-  end unless method_defined?(:except)
-
   # Removes the given keys from hash and returns it.
   #   hash = { a: true, b: false, c: nil }
   #   hash.except!(:c) # => { a: true, b: false }

data/lib/active_support/core_ext/module/introspection.rb

@@ -10,9 +10,6 @@ class Module
     if defined?(@parent_name)
       @parent_name
     else
-      name = self.name
-      return if name.nil?
-
       parent_name = name =~ /::[^:]+\z/ ? -$` : nil
       @parent_name = parent_name unless frozen?
       parent_name

data/lib/active_support/core_ext/object/json.rb

@@ -65,11 +65,9 @@ class Object
   end
 end
 
-if RUBY_VERSION >= "3.2"
-  class Data # :nodoc:
-    def as_json(options = nil)
-      to_h.as_json(options)
-    end
+class Data # :nodoc:
+  def as_json(options = nil)
+    to_h.as_json(options)
   end
 end
 
@@ -105,7 +103,7 @@ end
 
 class Symbol
   def as_json(options = nil) # :nodoc:
-    to_s
+    name
   end
 end
 
@@ -164,7 +162,12 @@ end
 
 class Array
   def as_json(options = nil) # :nodoc:
-    map { |v| options ? v.as_json(options.dup) : v.as_json }
+    if options
+      options = options.dup.freeze unless options.frozen?
+      map { |v| v.as_json(options) }
+    else
+      map { |v| v.as_json }
+    end
   end
 end
 
@@ -184,8 +187,11 @@ class Hash
     end
 
     result = {}
-    subset.each do |k, v|
-      result[k.to_s] = options ? v.as_json(options.dup) : v.as_json
+    if options
+      options = options.dup.freeze unless options.frozen?
+      subset.each { |k, v| result[k.to_s] = v.as_json(options) }
+    else
+      subset.each { |k, v| result[k.to_s] = v.as_json }
     end
     result
   end
@@ -233,11 +239,9 @@ class Pathname # :nodoc:
   end
 end
 
-unless IPAddr.method_defined?(:as_json, false)
-  class IPAddr # :nodoc:
-    def as_json(options = nil)
-      to_s
-    end
+class IPAddr # :nodoc:
+  def as_json(options = nil)
+    to_s
   end
 end
 

data/lib/active_support/core_ext/object/try.rb

@@ -145,14 +145,14 @@ class NilClass
   #
   # With +try+
   #   @person.try(:children).try(:first).try(:name)
-  def try(*, &)
+  def try(*)
     nil
   end
 
   # Calling +try!+ on +nil+ always returns +nil+.
   #
   #   nil.try!(:name) # => nil
-  def try!(*, &)
+  def try!(*)
     nil
   end
 end

data/lib/active_support/core_ext/range.rb

@@ -4,4 +4,3 @@ require "active_support/core_ext/range/conversions"
 require "active_support/core_ext/range/compare_range"
 require "active_support/core_ext/range/overlap"
 require "active_support/core_ext/range/each"
-require "active_support/core_ext/range/sole"

data/lib/active_support/core_ext/securerandom.rb

@@ -16,18 +16,8 @@ module SecureRandom
   #
   #   p SecureRandom.base58 # => "4kUgL2pdQMSCQtjE"
   #   p SecureRandom.base58(24) # => "77TMHrHJFvFDwodq8w7Ev2m7"
-  if SecureRandom.method(:alphanumeric).parameters.size == 2 # Remove check when Ruby 3.3 is the minimum supported version
-    def self.base58(n = 16)
-      alphanumeric(n, chars: BASE58_ALPHABET)
-    end
-  else
-    def self.base58(n = 16)
-      SecureRandom.random_bytes(n).unpack("C*").map do |byte|
-        idx = byte % 64
-        idx = SecureRandom.random_number(58) if idx >= 58
-        BASE58_ALPHABET[idx]
-      end.join
-    end
+  def self.base58(n = 16)
+    SecureRandom.alphanumeric(n, chars: BASE58_ALPHABET)
   end
 
   # SecureRandom.base36 generates a random base36 string in lowercase.
@@ -41,17 +31,11 @@ module SecureRandom
   #
   #   p SecureRandom.base36 # => "4kugl2pdqmscqtje"
   #   p SecureRandom.base36(24) # => "77tmhrhjfvfdwodq8w7ev2m7"
-  if SecureRandom.method(:alphanumeric).parameters.size == 2 # Remove check when Ruby 3.3 is the minimum supported version
-    def self.base36(n = 16)
-      alphanumeric(n, chars: BASE36_ALPHABET)
-    end
-  else
-    def self.base36(n = 16)
-      SecureRandom.random_bytes(n).unpack("C*").map do |byte|
-        idx = byte % 64
-        idx = SecureRandom.random_number(36) if idx >= 36
-        BASE36_ALPHABET[idx]
-      end.join
-    end
+  def self.base36(n = 16)
+    SecureRandom.random_bytes(n).unpack("C*").map do |byte|
+      idx = byte % 64
+      idx = SecureRandom.random_number(36) if idx >= 36
+      BASE36_ALPHABET[idx]
+    end.join
   end
 end

data/lib/active_support/core_ext/string/filters.rb

@@ -88,11 +88,11 @@ class String
   # characters.
   #
   #   >> "🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪".size
-  #   # => 20
+  #   => 20
   #   >> "🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪".bytesize
-  #   # => 80
+  #   => 80
   #   >> "🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪".truncate_bytes(20)
-  #   # => "🔪🔪🔪🔪…"
+  #   => "🔪🔪🔪🔪…"
   #
   # The truncated text ends with the <tt>:omission</tt> string, defaulting
   # to "…", for a total length not exceeding <tt>truncate_to</tt>.

data/lib/active_support/core_ext/string/multibyte.rb

@@ -12,14 +12,14 @@ class String
   # class. If the proxy class doesn't respond to a certain method, it's forwarded to the encapsulated string.
   #
   #   >> "lj".mb_chars.upcase.to_s
-  #   # => "LJ"
+  #   => "LJ"
   #
   # NOTE: Ruby 2.4 and later support native Unicode case mappings:
   #
   #   >> "lj".upcase
-  #   # => "LJ"
+  #   => "LJ"
   #
-  # == \Method chaining
+  # == Method chaining
   #
   # All the methods on the Chars proxy which normally return a string will return a Chars object. This allows
   # method chaining on the result of any of these methods.

data/lib/active_support/core_ext/time/calculations.rb

@@ -147,6 +147,13 @@ class Time
     elsif zone.respond_to?(:utc_to_local)
       new_time = ::Time.new(new_year, new_month, new_day, new_hour, new_min, new_sec, zone)
 
+      # Some versions of Ruby have a bug where Time.new with a zone object and
+      # fractional seconds will end up with a broken utc_offset.
+      # This is fixed in Ruby 3.3.1 and 3.2.4
+      unless new_time.utc_offset.integer?
+        new_time += 0
+      end
+
       # When there are two occurrences of a nominal time due to DST ending,
       # `Time.new` chooses the first chronological occurrence (the one with a
       # larger UTC offset). However, for `change`, we want to choose the
@@ -217,8 +224,13 @@ class Time
   # Returns a new Time representing the time a number of seconds since the instance time
   def since(seconds)
     self + seconds
-  rescue
-    to_datetime.since(seconds)
+  rescue TypeError
+    result = to_datetime.since(seconds)
+    ActiveSupport.deprecator.warn(
+      "Passing an instance of #{seconds.class} to #{self.class}#since is deprecated. This behavior will raise " \
+      "a `TypeError` in Rails 8.1."
+    )
+    result
   end
   alias :in :since
 

data/lib/active_support/core_ext/time/compatibility.rb

@@ -15,18 +15,10 @@ class Time
   end
 
   def preserve_timezone # :nodoc:
-    system_local_time? || super
+    active_support_local_zone == zone || super
   end
 
   private
-    def system_local_time?
-      if ::Time.equal?(self.class)
-        zone = self.zone
-        String === zone &&
-          (zone != "UTC" || active_support_local_zone == "UTC")
-      end
-    end
-
     @@active_support_local_tz = nil
 
     def active_support_local_zone

data/lib/active_support/core_ext/time/conversions.rb

@@ -22,6 +22,7 @@ class Time
       offset_format = time.formatted_offset(false)
       time.strftime("%a, %d %b %Y %H:%M:%S #{offset_format}")
     },
+    rfc2822: lambda { |time| time.rfc2822 },
     iso8601: lambda { |time| time.iso8601 }
   }
 
@@ -40,6 +41,7 @@ class Time
   #   time.to_fs(:long)         # => "January 18, 2007 06:10"
   #   time.to_fs(:long_ordinal) # => "January 18th, 2007 06:10"
   #   time.to_fs(:rfc822)       # => "Thu, 18 Jan 2007 06:10:17 -0600"
+  #   time.to_fs(:rfc2822)       # => "Thu, 18 Jan 2007 06:10:17 -0600"
   #   time.to_fs(:iso8601)      # => "2007-01-18T06:10:17-06:00"
   #
   # == Adding your own time formats to +to_fs+

data/lib/active_support/core_ext/time/zones.rb

@@ -20,7 +20,7 @@ class Time
     # This method accepts any of the following:
     #
     # * A \Rails TimeZone object.
-    # * An identifier for a \Rails TimeZone object (e.g., "Eastern \Time (US & Canada)", <tt>-5.hours</tt>).
+    # * An identifier for a \Rails TimeZone object (e.g., "Eastern Time (US & Canada)", <tt>-5.hours</tt>).
     # * A +TZInfo::Timezone+ object.
     # * An identifier for a +TZInfo::Timezone+ object (e.g., "America/New_York").
     #

data/lib/active_support/current_attributes.rb

@@ -108,18 +108,15 @@ module ActiveSupport
       # ==== Options
       #
       # * <tt>:default</tt> - The default value for the attributes. If the value
-      #   is a proc or lambda, it will be called whenever an instance is
-      #   constructed. Otherwise, the value will be duplicated with +#dup+.
-      #   Default values are re-assigned when the attributes are reset.
+      # is a proc or lambda, it will be called whenever an instance is
+      # constructed. Otherwise, the value will be duplicated with +#dup+.
+      # Default values are re-assigned when the attributes are reset.
       def attribute(*names, default: NOT_SET)
         invalid_attribute_names = names.map(&:to_sym) & INVALID_ATTRIBUTE_NAMES
         if invalid_attribute_names.any?
           raise ArgumentError, "Restricted attribute names: #{invalid_attribute_names.join(", ")}"
         end
 
-        Delegation.generate(singleton_class, names, to: :instance, nilable: false, signature: "")
-        Delegation.generate(singleton_class, names.map { |n| "#{n}=" }, to: :instance, nilable: false, signature: "value")
-
         ActiveSupport::CodeGenerator.batch(generated_attribute_methods, __FILE__, __LINE__) do |owner|
           names.each do |name|
             owner.define_cached_method(name, namespace: :current_attributes) do |batch|
@@ -137,6 +134,9 @@ module ActiveSupport
           end
         end
 
+        Delegation.generate(singleton_class, names, to: :instance, nilable: false, signature: "")
+        Delegation.generate(singleton_class, names.map { |n| "#{n}=" }, to: :instance, nilable: false, signature: "value")
+
         self.defaults = defaults.merge(names.index_with { default })
       end
 
@@ -185,16 +185,9 @@ module ActiveSupport
 
         def method_added(name)
           super
-
-          # We try to generate instance delegators early to not rely on method_missing.
           return if name == :initialize
-
-          # If the added method isn't public, we don't delegate it.
           return unless public_method_defined?(name)
-
-          # If we already have a class method by that name, we don't override it.
-          return if singleton_class.method_defined?(name) || singleton_class.private_method_defined?(name)
-
+          return if respond_to?(name, true)
           Delegation.generate(singleton_class, [name], to: :instance, as: self, nilable: false)
         end
     end

data/lib/active_support/deprecation.rb

@@ -68,7 +68,7 @@ module ActiveSupport
     # and the second is a library name.
     #
     #   ActiveSupport::Deprecation.new('2.0', 'MyLibrary')
-    def initialize(deprecation_horizon = "8.0", gem_name = "Rails")
+    def initialize(deprecation_horizon = "8.1", gem_name = "Rails")
       self.gem_name = gem_name
       self.deprecation_horizon = deprecation_horizon
       # By default, warnings are not silenced and debugging is off.

data/lib/active_support/encrypted_configuration.rb

@@ -43,6 +43,12 @@ module ActiveSupport
       end
     end
 
+    class InvalidKeyError < RuntimeError
+      def initialize(content_path, key)
+        super "Key '#{key}' is invalid, it must respond to '#to_sym' from configuration in '#{content_path}'."
+      end
+    end
+
     delegate_missing_to :options
 
     def initialize(config_path:, key_path:, env_key:, raise_if_missing_key:)
@@ -61,7 +67,11 @@ module ActiveSupport
     end
 
     def validate! # :nodoc:
-      deserialize(read)
+      deserialize(read).each_key do |key|
+        key.to_sym
+      rescue NoMethodError
+        raise InvalidKeyError.new(content_path, key)
+      end
     end
 
     # Returns the decrypted content as a Hash with symbolized keys.
@@ -73,7 +83,7 @@ module ActiveSupport
     #   # => { some_secret: 123, some_namespace: { another_secret: 789 } }
     #
     def config
-      @config ||= deserialize(read).deep_symbolize_keys
+      @config ||= deep_symbolize_keys(deserialize(read))
     end
 
     def inspect # :nodoc:
@@ -81,6 +91,14 @@ module ActiveSupport
     end
 
     private
+      def deep_symbolize_keys(hash)
+        hash.deep_transform_keys do |key|
+          key.to_sym
+        rescue NoMethodError
+          raise InvalidKeyError.new(content_path, key)
+        end
+      end
+
       def deep_transform(hash)
         return hash unless hash.is_a?(Hash)
 

data/lib/active_support/error_reporter.rb

@@ -144,9 +144,9 @@ module ActiveSupport
     #
     def unexpected(error, severity: :warning, context: {}, source: DEFAULT_SOURCE)
       error = RuntimeError.new(error) if error.is_a?(String)
-      error.set_backtrace(caller(1)) if error.backtrace.nil?
 
       if @debug_mode
+        ensure_backtrace(error)
         raise UnexpectedError, "#{error.class.name}: #{error.message}", error.backtrace, cause: error
       else
         report(error, handled: true, severity: severity, context: context, source: source)
@@ -209,6 +209,7 @@ module ActiveSupport
     #
     def report(error, handled: true, severity: handled ? :warning : :error, context: {}, source: DEFAULT_SOURCE)
       return if error.instance_variable_defined?(:@__rails_error_reported)
+      ensure_backtrace(error)
 
       unless SEVERITIES.include?(severity)
         raise ArgumentError, "severity must be one of #{SEVERITIES.map(&:inspect).join(", ")}, got: #{severity.inspect}"
@@ -231,14 +232,34 @@ module ActiveSupport
         end
       end
 
-      while error
-        unless error.frozen?
-          error.instance_variable_set(:@__rails_error_reported, true)
-        end
-        error = error.cause
+      unless error.frozen?
+        error.instance_variable_set(:@__rails_error_reported, true)
       end
 
       nil
     end
+
+    private
+      def ensure_backtrace(error)
+        return if error.frozen? # re-raising won't add a backtrace
+        return unless error.backtrace.nil?
+
+        begin
+          # We could use Exception#set_backtrace, but until Ruby 3.4
+          # it only support setting `Exception#backtrace` and not
+          # `Exception#backtrace_locations`. So raising the exception
+          # is a good way to build a real backtrace.
+          raise error
+        rescue error.class => error
+        end
+
+        count = 0
+        while error.backtrace_locations.first&.path == __FILE__
+          count += 1
+          error.backtrace_locations.shift
+        end
+
+        error.backtrace.shift(count)
+      end
   end
 end

data/lib/active_support/execution_wrapper.rb

@@ -89,7 +89,7 @@ module ActiveSupport
       instance = run!
       begin
         yield
-      rescue Exception => error
+      rescue => error
         error_reporter&.report(error, handled: false, source: source)
         raise
       ensure