datadog 2.30.0 → 2.31.0

data/lib/datadog/di/probe_notification_builder.rb

@@ -79,7 +79,7 @@ module Datadog
               },
               return: {
                 arguments: return_arguments,
-                throwable: nil,
+                throwable: context.exception ? serialize_throwable(context.exception) : nil,
               },
             }
           elsif probe.line?
@@ -153,6 +153,114 @@ module Datadog
 
       private
 
+      # Serializes an exception for the throwable field in snapshot captures.
+      #
+      # Uses the C extension's exception_message to get the original message
+      # without invoking any Ruby-level message method override, which
+      # could be customer code.
+      #
+      # Caveats:
+      #
+      # 1. The value returned by exception_message is not guaranteed to be
+      #    a string — it is whatever was passed to the Exception constructor.
+      #    Calling .to_s on an arbitrary object would invoke customer code,
+      #    violating DI's constraint of never executing customer methods
+      #    during instrumentation. We only use the value directly when it
+      #    is a String; for non-string values we return a redacted
+      #    placeholder (reporting the class name would duplicate the
+      #    exception type already present in the :type field).
+      #
+      # 2. Custom exception classes may not store a meaningful message via
+      #    the constructor (e.g. they may compute it in an overridden
+      #    +message+ method). In such cases exception_message may return
+      #    nil or an unrelated constructor argument. This is acceptable:
+      #    we still report the exception type, and a missing/wrong message
+      #    is better than invoking customer code or reporting nothing.
+      #
+      # @param exception [Exception] the exception to serialize
+      # @return [Hash{Symbol => String?}] hash with :type and :message keys
+      def serialize_throwable(exception)
+        msg = DI.exception_message(exception)
+        message = if msg.nil? || String === msg
+          msg
+        else
+          # Non-string constructor argument — return a redacted placeholder
+          # rather than calling .to_s which could be customer code.
+          # The exception class is already reported via the :type field.
+          '<REDACTED: not a string value>'
+        end
+        # Prefer backtrace_locations (structured Location objects) over
+        # backtrace (formatted strings that need regex parsing).
+        #
+        # However, backtrace_locations returns nil when someone has called
+        # Exception#set_backtrace with Array<String> — the VM cannot
+        # reconstruct Location objects from formatted strings. This happens
+        # in exception wrapping patterns (catch, create new exception, copy
+        # original's string backtrace via set_backtrace, re-raise).
+        # In that case, fall back to backtrace strings.
+        #
+        # Both accessors use the UnboundMethod trick to bypass subclass
+        # overrides, consistent with the rest of this method.
+        #
+        # If a subclass overrides #backtrace, MRI's raise never stores
+        # the real backtrace — both backtrace_locations and backtrace
+        # return nil, and stacktrace is [].
+        # This is unrecoverable without calling customer code.
+        # See DI::EXCEPTION_BACKTRACE comment for details.
+        locations = DI::EXCEPTION_BACKTRACE_LOCATIONS.bind(exception).call
+        stacktrace = if locations
+          format_backtrace_locations(locations)
+        else
+          format_backtrace_strings(DI::EXCEPTION_BACKTRACE.bind(exception).call)
+        end
+        {
+          type: exception.class.name,
+          message: message,
+          stacktrace: stacktrace,
+        }
+      end
+
+      # Matches Ruby backtrace frame format: "/path/file.rb:42:in `method_name'"
+      # Captures: $1 = file path, $2 = line number, $3 = method name
+      BACKTRACE_FRAME_PATTERN = /\A(.+):(\d+):in\s+[`'](.+)'\z/
+
+      # Converts backtrace locations into the stack frame format
+      # expected by the Datadog UI.
+      #
+      # Uses Thread::Backtrace::Location objects which provide structured
+      # path/lineno/label directly, avoiding the round-trip of formatting
+      # to strings and regex-parsing back.
+      #
+      # @param locations [Array<Thread::Backtrace::Location>]
+      # @return [Array<Hash>]
+      def format_backtrace_locations(locations)
+        locations.map do |loc|
+          {fileName: loc.path, function: loc.label, lineNumber: loc.lineno}
+        end
+      end
+
+      # Parses Ruby backtrace strings into the stack frame format
+      # expected by the Datadog UI.
+      #
+      # Fallback for when backtrace_locations returns nil (see
+      # serialize_throwable for details on when this happens).
+      #
+      # Ruby backtrace format: "/path/file.rb:42:in `method_name'"
+      #
+      # @param backtrace [Array<String>, nil] from Exception#backtrace
+      # @return [Array<Hash>]
+      def format_backtrace_strings(backtrace)
+        return [] if backtrace.nil?
+
+        backtrace.map do |frame|
+          if frame =~ BACKTRACE_FRAME_PATTERN
+            {fileName: $1, function: $3, lineNumber: $2.to_i}
+          else
+            {fileName: frame, function: '', lineNumber: 0}
+          end
+        end
+      end
+
       def build_snapshot_base(context, evaluation_errors: [], captures: nil, message: nil)
         probe = context.probe
 

data/lib/datadog/di/serializer.rb

@@ -186,7 +186,7 @@ module Datadog
                 # surface errors so they can fix their serializers) or they may be defined
                 # internally by dd-trace-rb (in which case we need to fix them). We use
                 # WARN level to surface these errors in either case.
-                Datadog.logger.warn("DI: Custom serializer condition failed: #{e.class}: #{e.message}")
+                Datadog.logger.warn("DI: Custom serializer condition failed: #{e.class}: #{e}")
                 telemetry&.report(e, description: "Custom serializer condition failed")
                 next
               end

data/lib/datadog/di.rb

@@ -11,11 +11,92 @@ module Datadog
   module DI
     INSTRUMENTED_COUNTERS_LOCK = Mutex.new
 
+    # Captured at load time from Exception itself (not a subclass).
+    # Used to bypass subclass overrides of backtrace_locations.
+    #
+    # This does NOT protect against monkeypatching Exception#backtrace_locations
+    # before dd-trace-rb loads — in that case we'd capture the monkeypatch.
+    # The practical threat model is customer subclasses overriding the method:
+    #
+    #   class MyError < StandardError
+    #     def backtrace_locations; []; end
+    #   end
+    #
+    # The UnboundMethod bypasses subclass overrides: bind(exception).call
+    # always dispatches to the original Exception implementation.
+    #
+    # Note: if the subclass overrides #backtrace (not #backtrace_locations),
+    # MRI's setup_exception skips storing the VM backtrace entirely — both
+    # @bt and @bt_locations stay nil. In that case this UnboundMethod also
+    # returns nil. See EXCEPTION_BACKTRACE comment for details.
+    EXCEPTION_BACKTRACE_LOCATIONS = Exception.instance_method(:backtrace_locations)
+
+    # Same UnboundMethod trick for Exception#backtrace (Array<String>).
+    # Used as a fallback when backtrace_locations returns nil — which happens
+    # when someone calls Exception#set_backtrace with an Array<String>.
+    #
+    # set_backtrace accepts Array<String> or nil. When called with strings,
+    # it replaces the VM-level backtrace: backtrace returns the new strings,
+    # but backtrace_locations returns nil because the VM cannot reconstruct
+    # Location objects from formatted strings. This occurs in exception
+    # wrapping patterns where a library catches an exception, creates a new
+    # one, and copies the original's string backtrace onto it via
+    # set_backtrace before re-raising.
+    #
+    # Ruby 3.4+ also allows set_backtrace(Array<Location>), which preserves
+    # backtrace_locations — but older Rubies and most existing code use
+    # the string form.
+    #
+    # Like EXCEPTION_BACKTRACE_LOCATIONS, this UnboundMethod bypasses
+    # subclass overrides of #backtrace: bind(exception).call dispatches
+    # to Exception#backtrace regardless of what the subclass defines.
+    #
+    # However, when a subclass overrides #backtrace, MRI's setup_exception
+    # (eval.c) calls the override via rb_get_backtrace during raise. If it
+    # gets a non-nil result, it skips storing the VM backtrace in @bt and
+    # @bt_locations entirely. So the UnboundMethod bypasses the override
+    # at dispatch but reads nil from @bt because the data was never stored.
+    #
+    # This constant is used as a fallback when backtrace_locations returns
+    # nil. In the common set_backtrace-with-strings case, no subclass
+    # override is involved and the fallback works. The only unrecoverable
+    # case: a subclass overrides #backtrace, the exception is raised
+    # normally, and set_backtrace is never called. Both @bt and
+    # @bt_locations are nil — DI reports an empty stacktrace (type and
+    # message are still reported).
+    EXCEPTION_BACKTRACE = Exception.instance_method(:backtrace)
+
     class << self
       def enabled?
         Datadog.configuration.dynamic_instrumentation.enabled
       end
 
+      # Returns iseqs that correspond to loaded files (filtering out eval'd code).
+      #
+      # There are several types of iseqs returned by +all_iseqs+:
+      #
+      # 1. Eval'd code — these have a nil +absolute_path+ and are filtered out here.
+      # 2. Whole-file iseqs — have +absolute_path+ set and +first_lineno+ of 0.
+      #    Only available for a subset of loaded files (the full-file iseq may be
+      #    garbage collected after loading completes). Easiest to work with since
+      #    we just match the file path to the probe specification.
+      # 3. Per-method iseqs — have +absolute_path+ set and +first_lineno+ > 0.
+      #    Often the only iseqs available for third-party code. Require identifying
+      #    the correct iseq containing the target line, which may involve examining
+      #    the iseq's +trace_points+ since +define_method+ can create nested,
+      #    non-contiguous line ranges.
+      #
+      # Note: the same line of code can appear in multiple iseqs (e.g. when
+      # +define_method+ is used inside a method). DI treats this as an error
+      # since a probe must resolve to exactly one code location.
+      #
+      # @return [Array<RubyVM::InstructionSequence>] iseqs with non-nil +absolute_path+
+      def file_iseqs
+        all_iseqs.select do |iseq|
+          iseq.absolute_path
+        end
+      end
+
       # This method is called from DI Remote handler to issue DI operations
       # to the probe manager (add or remove probes).
       #

data/lib/datadog/kit/enable_core_dumps.rb

@@ -30,7 +30,7 @@ module Datadog
           Process.setrlimit(:CORE, maximum_size)
         rescue => e
           Kernel.warn(
-            "[datadog] Failed to enable core dumps. Cause: #{e.class.name} #{e.message} " \
+            "[datadog] Failed to enable core dumps. Cause: #{e.class}: #{e} " \
             "Location: #{Array(e.backtrace).first}"
           )
           return

data/lib/datadog/open_feature/evaluation_engine.rb

@@ -60,7 +60,7 @@ module Datadog
       rescue => e
         message = 'OpenFeature: Failed to reconfigure, reverting to the previous configuration'
 
-        @logger.error("#{message}, #{e.class}: #{e.message}")
+        @logger.error("#{message}, #{e.class}: #{e}")
         @telemetry.report(e, description: "#{message} (#{e.class})")
 
         raise ReconfigurationError, e.message

data/lib/datadog/open_feature/exposures/reporter.rb

@@ -29,7 +29,7 @@ module Datadog
           event = Event.build(result, flag_key: flag_key, context: context)
           @worker.enqueue(event)
         rescue => e
-          @logger.debug { "OpenFeature: Failed to report resolution details: #{e.class}: #{e.message}" }
+          @logger.debug { "OpenFeature: Failed to report resolution details: #{e.class}: #{e}" }
           @telemetry.report(e, description: 'OpenFeature: Failed to report resolution details')
 
           false

data/lib/datadog/open_feature/exposures/worker.rb

@@ -105,7 +105,7 @@ module Datadog
 
           response
         rescue => e
-          @logger.debug { "OpenFeature: Failed to flush resolution details events: #{e.class}: #{e.message}" }
+          @logger.debug { "OpenFeature: Failed to flush resolution details events: #{e.class}: #{e}" }
           @telemetry.report(e, description: 'OpenFeature: Failed to flush resolution details events')
 
           nil

data/lib/datadog/open_feature/remote.rb

@@ -41,7 +41,7 @@ module Datadog
                   engine.reconfigure!(read_content(content))
                   content.applied
                 rescue EvaluationEngine::ReconfigurationError => e
-                  content.errored("Error applying OpenFeature configuration: #{e.message}")
+                  content.errored("Error applying OpenFeature configuration: #{e.class}: #{e}")
                 end
               when :delete
                 # NOTE: For now, we treat deletion as clearing the configuration

data/lib/datadog/open_feature/transport.rb

@@ -55,7 +55,7 @@ module Datadog
             @api.call(env)
           end
         rescue => e
-          message = "Internal error during request. Cause: #{e.class.name} #{e.message} " \
+          message = "Internal error during request. Cause: #{e.class}: #{e} " \
                     "Location: #{Array(e.backtrace).first}"
           @logger.debug(message)
 

data/lib/datadog/opentelemetry/configuration/settings.rb

@@ -76,6 +76,7 @@ module Datadog
                 end
 
                 option :headers do |o|
+                  o.skip_telemetry true
                   o.type :hash
                   o.env 'OTEL_EXPORTER_OTLP_HEADERS'
                   o.default { {} }
@@ -131,6 +132,7 @@ module Datadog
                 end
 
                 option :headers do |o|
+                  o.skip_telemetry true
                   o.type :hash, nilable: true
                   o.env 'OTEL_EXPORTER_OTLP_METRICS_HEADERS'
                   o.default nil

data/lib/datadog/profiling/collectors/code_provenance.rb

@@ -135,7 +135,7 @@ module Datadog
         rescue Exception => e # rubocop:disable Lint/RescueException
           Datadog.logger.debug(
             "CodeProvenance#bundler_bin_path failed. " \
-            "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+            "Cause: #{e.class}: #{e} Location: #{Array(e.backtrace).first}"
           )
           nil
         end
@@ -161,8 +161,7 @@ module Datadog
           end
 
           def to_json(arg = nil)
-            # Steep: https://github.com/ruby/rbs/pull/2691 (remove after RBS 4.0 release)
-            {kind: @kind, name: @name, version: @version, paths: @paths}.to_json(arg) # steep:ignore ArgumentTypeMismatch
+            {kind: @kind, name: @name, version: @version, paths: @paths}.to_json(arg)
           end
 
           def path

data/lib/datadog/profiling/collectors/cpu_and_wall_time_worker.rb

@@ -93,7 +93,7 @@ module Datadog
               operation_name = self.class._native_failure_exception_during_operation(self).inspect
               Datadog.logger.warn(
                 "CpuAndWallTimeWorker thread error. " \
-                "Operation: #{operation_name} Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+                "Operation: #{operation_name} Cause: #{e.class}: #{e} Location: #{Array(e.backtrace).first}"
               )
               on_failure_proc&.call
               Datadog::Core::Telemetry::Logger.report(e, description: "CpuAndWallTimeWorker thread error: #{operation_name}")

data/lib/datadog/profiling/collectors/idle_sampling_helper.rb

@@ -39,7 +39,7 @@ module Datadog
               @failure_exception = e
               Datadog.logger.warn(
                 "IdleSamplingHelper thread error. " \
-                "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+                "Cause: #{e.class}: #{e} Location: #{Array(e.backtrace).first}"
               )
               Datadog::Core::Telemetry::Logger.report(e, description: "IdleSamplingHelper thread error")
             end

data/lib/datadog/profiling/component.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../core/telemetry/logger"
+
 module Datadog
   module Profiling
     # Responsible for wiring up the Profiler for execution
@@ -90,6 +92,14 @@ module Datadog
         end
 
         [profiler, {profiling_enabled: true}]
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        logger.warn do
+          "Failed to initialize profiling: #{e.class}: #{e} " \
+          "Location: #{Array(e.backtrace).first}"
+        end
+        Datadog::Core::Telemetry::Logger.report(e, description: "Failed to initialize profiling")
+
+        [nil, {profiling_enabled: false}]
       end
 
       private_class_method def self.build_thread_context_collector(settings, recorder, optional_tracer, timeline_enabled)
@@ -368,7 +378,7 @@ module Datadog
         rescue StandardError, LoadError => e
           logger.warn(
             "Failed to probe `mysql2` gem information. " \
-            "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+            "Cause: #{e.class}: #{e} Location: #{Array(e.backtrace).first}"
           )
 
           true

data/lib/datadog/profiling/load_native_extension.rb

@@ -4,6 +4,6 @@ begin
   require "datadog_profiling_native_extension.#{RUBY_VERSION}_#{RUBY_PLATFORM}"
 rescue LoadError => e
   raise LoadError,
-    "Failed to load the profiling loader extension. To fix this, please remove and then reinstall datadog " \
+    "Failed to load the profiling native extension. To fix this, please remove and then reinstall datadog " \
     "(Details: #{e.message})"
 end

data/lib/datadog/profiling/profiler.rb

@@ -17,10 +17,6 @@ module Datadog
         @scheduler = scheduler
       end
 
-      def enabled?
-        scheduler.running?
-      end
-
       def start
         after_fork! do
           worker.reset_after_fork

data/lib/datadog/profiling/scheduler.rb

@@ -65,7 +65,7 @@ module Datadog
       rescue Exception => e # rubocop:disable Lint/RescueException
         Datadog.logger.warn(
           "Profiling::Scheduler thread error. " \
-          "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+          "Cause: #{e.class}: #{e} Location: #{Array(e.backtrace).first}"
         )
         on_failure_proc&.call
         Datadog::Core::Telemetry::Logger.report(e, description: "Profiling::Scheduler thread error")
@@ -136,7 +136,7 @@ module Datadog
           transport.export(flush)
         rescue => e
           Datadog.logger.warn(
-            "Unable to report profile. Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+            "Unable to report profile. Cause: #{e.class}: #{e} Location: #{Array(e.backtrace).first}"
           )
           Datadog::Core::Telemetry::Logger.report(e, description: "Unable to report profile")
         end

data/lib/datadog/profiling/tasks/exec.rb

@@ -38,10 +38,10 @@ module Datadog
         def exec_with_error_handling(args)
           Kernel.exec(*args)
         rescue Errno::ENOENT => e
-          Kernel.warn "ddprofrb exec failed: #{e.class.name} #{e.message} (command was '#{args.join(" ")}')"
+          Kernel.warn "ddprofrb exec failed: #{e.class}: #{e} (command was '#{args.join(" ")}')"
           Kernel.exit 127
         rescue Errno::EACCES, Errno::ENOEXEC => e
-          Kernel.warn "ddprofrb exec failed: #{e.class.name} #{e.message} (command was '#{args.join(" ")}')"
+          Kernel.warn "ddprofrb exec failed: #{e.class}: #{e} (command was '#{args.join(" ")}')"
           Kernel.exit 126
         end
       end

data/lib/datadog/profiling/tasks/setup.rb

@@ -16,7 +16,7 @@ module Datadog
             setup_at_fork_hooks
           rescue StandardError, ScriptError => e
             Datadog.logger.warn do
-              "Profiler extensions unavailable. Cause: #{e.class.name} #{e.message} " \
+              "Profiler extensions unavailable. Cause: #{e.class}: #{e} " \
               "Location: #{Array(e.backtrace).first}"
             end
             Datadog::Core::Telemetry::Logger.report(e, description: "Profiler extensions unavailable")
@@ -31,7 +31,7 @@ module Datadog
             Profiling.start_if_enabled
           rescue => e
             Datadog.logger.warn do
-              "Error during post-fork hooks. Cause: #{e.class.name} #{e.message} " \
+              "Error during post-fork hooks. Cause: #{e.class}: #{e} " \
               "Location: #{Array(e.backtrace).first}"
             end
             Datadog::Core::Telemetry::Logger.report(e, description: "Error during post-fork hooks")

data/lib/datadog/profiling.rb

@@ -61,8 +61,7 @@ module Datadog
     end
 
     def self.enabled?
-      profiler = Datadog.send(:components).profiler
-      !!profiler&.enabled?
+      !!Datadog.send(:components).profiler
     end
 
     def self.wait_until_running(timeout_seconds: 5)

data/lib/datadog/single_step_instrument.rb

@@ -17,5 +17,5 @@ begin
   require_relative 'auto_instrument'
   Datadog::SingleStepInstrument.const_set(:LOADED, true)
 rescue StandardError, LoadError => e
-  warn "Single step instrumentation failed: #{e.class}:#{e.message}\n\tSource:\n\t#{Array(e.backtrace).join("\n\t")}"
+  warn "Single step instrumentation failed: #{e.class}: #{e}\n\tSource:\n\t#{Array(e.backtrace).join("\n\t")}"
 end

data/lib/datadog/tracing/buffer.rb

@@ -56,7 +56,7 @@ module Datadog
         @buffer_spans += trace.length
       rescue => e
         Datadog.logger.debug(
-          "Failed to measure queue accept. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+          "Failed to measure queue accept. Cause: #{e.class}: #{e} Source: #{Array(e.backtrace).first}"
         )
       end
 
@@ -66,7 +66,7 @@ module Datadog
         @buffer_spans -= trace.length
       rescue => e
         Datadog.logger.debug(
-          "Failed to measure queue drop. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+          "Failed to measure queue drop. Cause: #{e.class}: #{e} Source: #{Array(e.backtrace).first}"
         )
       end
 
@@ -91,7 +91,7 @@ module Datadog
         @buffer_spans = 0
       rescue => e
         Datadog.logger.debug(
-          "Failed to measure queue. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+          "Failed to measure queue. Cause: #{e.class}: #{e} Source: #{Array(e.backtrace).first}"
         )
       end
     end

data/lib/datadog/tracing/component.rb

@@ -161,6 +161,17 @@ module Datadog
           @sampler.sample!(trace)
         end
 
+        def reconsider_sample_resource!(trace)
+          return unless @sampler.respond_to?(:reconsider_sample_resource!)
+
+          @sampler.reconsider_sample_resource!(trace)
+        end
+
+        def resource_sampling?
+          @sampler.respond_to?(:resource_sampling?) &&
+            @sampler.resource_sampling?
+        end
+
         def update(*args, **kwargs)
           return unless @sampler.respond_to?(:update)
 

data/lib/datadog/tracing/configuration/settings.rb

@@ -430,7 +430,7 @@ module Datadog
                       rescue => e
                         # `File#read` errors have clear and actionable messages, no need to add extra exception info.
                         Datadog.logger.warn(
-                          "Cannot read span sampling rules file `#{rules_file}`: #{e.message}." \
+                          "Cannot read span sampling rules file `#{rules_file}`: #{e.class}: #{e}." \
                           'No span sampling rules will be applied.'
                         )
                         nil
@@ -481,6 +481,7 @@ module Datadog
               # @default `{}`
               # @return [Hash]
               option :writer_options do |o|
+                o.skip_telemetry true
                 o.type :hash
                 o.default({})
               end

data/lib/datadog/tracing/contrib/action_pack/action_controller/instrumentation.rb

@@ -43,7 +43,7 @@ module Datadog
               span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_CONTROLLER)
             rescue => e
-              Datadog.logger.error(e.message)
+              Datadog.logger.error("#{e.class}: #{e}")
               Datadog::Core::Telemetry::Logger.report(e)
             end
 
@@ -88,7 +88,7 @@ module Datadog
                 span.finish
               end
             rescue => e
-              Datadog.logger.error(e.message)
+              Datadog.logger.error("#{e.class}: #{e}")
               Datadog::Core::Telemetry::Logger.report(e)
             end
 

data/lib/datadog/tracing/contrib/action_pack/action_dispatch/instrumentation.rb

@@ -76,6 +76,26 @@ module Datadog
                   end
                 end
               end
+
+              # Since Rails 8.1, `Router#find_routes` was removed by inlining its body into `recognize`.
+              # https://github.com/rails/rails/commit/e533a32ddf06668dfa3dfbe9b665607e235b06ac
+              module RecognizeRouter
+                def recognize(req)
+                  # recognize modifies SCRIPT_NAME before yielding; capture it before super.
+                  original_script_name = req.env[SCRIPT_NAME_KEY]
+
+                  super do |route, parameters|
+                    if Instrumentation.dispatcher_route?(route)
+                      http_route = route.path.spec.to_s
+                      http_route = http_route.delete_suffix(FORMAT_SUFFIX)
+
+                      Instrumentation.set_http_route_tags(http_route, original_script_name)
+                    end
+
+                    yield route, parameters
+                  end
+                end
+              end
             end
           end
         end

data/lib/datadog/tracing/contrib/action_pack/action_dispatch/patcher.rb

@@ -19,7 +19,9 @@ module Datadog
             end
 
             def patch
-              if ::ActionPack.gem_version >= Gem::Version.new('7.1')
+              if ::ActionPack.gem_version >= Gem::Version.new('8.1')
+                ::ActionDispatch::Journey::Router.prepend(ActionDispatch::Instrumentation::Journey::RecognizeRouter)
+              elsif ::ActionPack.gem_version >= Gem::Version.new('7.1')
                 ::ActionDispatch::Journey::Router.prepend(ActionDispatch::Instrumentation::Journey::LazyRouter)
               else
                 ::ActionDispatch::Journey::Router.prepend(ActionDispatch::Instrumentation::Journey::Router)

data/lib/datadog/tracing/contrib/action_view/events/render_template.rb

@@ -47,7 +47,7 @@ module Datadog
 
               record_exception(span, payload)
             rescue => e
-              Datadog.logger.debug(e.message)
+              Datadog.logger.debug { "#{e.class}: #{e}" }
             end
           end
         end

data/lib/datadog/tracing/contrib/active_job/events/discard.rb

@@ -40,7 +40,7 @@ module Datadog
               set_common_tags(span, payload)
               span.set_tag(Ext::TAG_JOB_ERROR, payload[:error])
             rescue => e
-              Datadog.logger.debug(e.message)
+              Datadog.logger.debug { "#{e.class}: #{e}" }
             end
           end
         end

data/lib/datadog/tracing/contrib/active_job/events/enqueue.rb

@@ -39,7 +39,7 @@ module Datadog
 
               set_common_tags(span, payload)
             rescue => e
-              Datadog.logger.debug(e.message)
+              Datadog.logger.debug { "#{e.class}: #{e}" }
             end
           end
         end

data/lib/datadog/tracing/contrib/active_job/events/enqueue_at.rb

@@ -39,7 +39,7 @@ module Datadog
 
               set_common_tags(span, payload)
             rescue => e
-              Datadog.logger.debug(e.message)
+              Datadog.logger.debug { "#{e.class}: #{e}" }
             end
           end
         end

data/lib/datadog/tracing/contrib/active_job/events/enqueue_retry.rb

@@ -41,7 +41,7 @@ module Datadog
               span.set_tag(Ext::TAG_JOB_ERROR, payload[:error])
               span.set_tag(Ext::TAG_JOB_RETRY_WAIT, payload[:wait])
             rescue => e
-              Datadog.logger.debug(e.message)
+              Datadog.logger.debug { "#{e.class}: #{e}" }
             end
           end
         end

data/lib/datadog/tracing/contrib/active_job/events/perform.rb

@@ -39,7 +39,7 @@ module Datadog
 
               set_common_tags(span, payload)
             rescue => e
-              Datadog.logger.debug(e.message)
+              Datadog.logger.debug { "#{e.class}: #{e}" }
             end
           end
         end