datadog 2.3.0 → 2.5.0

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

@@ -20,17 +20,41 @@ module Datadog
           tracer:,
           endpoint_collection_enabled:,
           timeline_enabled:,
-          allocation_type_enabled: true
+          waiting_for_gvl_threshold_ns:,
+          otel_context_enabled:
         )
           tracer_context_key = safely_extract_context_key_from(tracer)
           self.class._native_initialize(
-            self,
-            recorder,
-            max_frames,
-            tracer_context_key,
-            endpoint_collection_enabled,
-            timeline_enabled,
-            allocation_type_enabled,
+            self_instance: self,
+            recorder: recorder,
+            max_frames: max_frames,
+            tracer_context_key: tracer_context_key,
+            endpoint_collection_enabled: endpoint_collection_enabled,
+            timeline_enabled: timeline_enabled,
+            waiting_for_gvl_threshold_ns: waiting_for_gvl_threshold_ns,
+            otel_context_enabled: otel_context_enabled,
+          )
+        end
+
+        def self.for_testing(
+          recorder:,
+          max_frames: 400,
+          tracer: nil,
+          endpoint_collection_enabled: false,
+          timeline_enabled: false,
+          waiting_for_gvl_threshold_ns: 10_000_000,
+          otel_context_enabled: false,
+          **options
+        )
+          new(
+            recorder: recorder,
+            max_frames: max_frames,
+            tracer: tracer,
+            endpoint_collection_enabled: endpoint_collection_enabled,
+            timeline_enabled: timeline_enabled,
+            waiting_for_gvl_threshold_ns: waiting_for_gvl_threshold_ns,
+            otel_context_enabled: otel_context_enabled,
+            **options,
           )
         end
 

data/lib/datadog/profiling/component.rb

@@ -53,6 +53,7 @@ module Datadog
           heap_size_enabled: heap_size_profiling_enabled,
           heap_sample_every: heap_sample_every,
           timeline_enabled: timeline_enabled,
+          heap_clean_after_gc_enabled: settings.profiling.advanced.heap_clean_after_gc_enabled,
         )
         thread_context_collector = build_thread_context_collector(settings, recorder, optional_tracer, timeline_enabled)
         worker = Datadog::Profiling::Collectors::CpuAndWallTimeWorker.new(
@@ -62,6 +63,7 @@ module Datadog
           dynamic_sampling_rate_overhead_target_percentage: overhead_target_percentage,
           allocation_profiling_enabled: allocation_profiling_enabled,
           allocation_counting_enabled: settings.profiling.advanced.allocation_counting_enabled,
+          gvl_profiling_enabled: enable_gvl_profiling?(settings),
         )
 
         internal_metadata = {
@@ -89,6 +91,8 @@ module Datadog
           tracer: optional_tracer,
           endpoint_collection_enabled: settings.profiling.advanced.endpoint.collection.enabled,
           timeline_enabled: timeline_enabled,
+          waiting_for_gvl_threshold_ns: settings.profiling.advanced.waiting_for_gvl_threshold_ns,
+          otel_context_enabled: settings.profiling.advanced.preview_otel_context_enabled,
         )
       end
 
@@ -252,6 +256,7 @@ module Datadog
         legacy_ruby_that_should_use_workaround = RUBY_VERSION.start_with?("2.5.")
 
         unless [true, false, :auto].include?(setting_value)
+          # TODO: Replace with a warning instead.
           Datadog.logger.error(
             "Ignoring invalid value for profiling no_signals_workaround_enabled setting: #{setting_value.inspect}. " \
             "Valid options are `true`, `false` or (default) `:auto`."
@@ -394,6 +399,7 @@ module Datadog
         if overhead_target_percentage > 0 && overhead_target_percentage <= 20
           overhead_target_percentage
         else
+          # TODO: Replace with a warning instead.
           Datadog.logger.error(
             "Ignoring invalid value for profiling overhead_target_percentage setting: " \
             "#{overhead_target_percentage.inspect}. Falling back to default value."
@@ -433,13 +439,24 @@ module Datadog
       end
 
       private_class_method def self.dir_interruption_workaround_enabled?(settings, no_signals_workaround_enabled)
-        return false if no_signals_workaround_enabled
-
-        # NOTE: In the future this method will evolve to check for Ruby versions affected and not apply the workaround
-        # when it's not needed but currently all known Ruby versions are affected.
+        return false if no_signals_workaround_enabled || RUBY_VERSION >= "3.4"
 
         settings.profiling.advanced.dir_interruption_workaround_enabled
       end
+
+      private_class_method def self.enable_gvl_profiling?(settings)
+        if RUBY_VERSION < "3.2"
+          if settings.profiling.advanced.preview_gvl_enabled
+            Datadog.logger.warn("GVL profiling is currently not supported in Ruby < 3.2 and will not be enabled.")
+          end
+
+          return false
+        end
+
+        # GVL profiling only makes sense in the context of timeline. We could emit a warning here, but not sure how
+        # useful it is -- if a customer disables timeline, there's nowhere to look for GVL profiling anyway!
+        settings.profiling.advanced.timeline_enabled && settings.profiling.advanced.preview_gvl_enabled
+      end
     end
   end
 end

data/lib/datadog/profiling/http_transport.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../core/transport/ext"
+require_relative "../core/telemetry/logger"
 
 module Datadog
   module Profiling
@@ -60,10 +61,14 @@ module Datadog
               "Failed to report profiling data (#{config_without_api_key}): " \
               "server returned unexpected HTTP #{result} status code"
             )
+            Datadog::Core::Telemetry::Logger.error(
+              "Failed to report profiling data: unexpected HTTP #{result} status code"
+            )
             false
           end
         else
           Datadog.logger.error("Failed to report profiling data (#{config_without_api_key}): #{result}")
+          Datadog::Core::Telemetry::Logger.error("Failed to report profiling data")
           false
         end
       end
@@ -134,7 +139,7 @@ module Datadog
       end
 
       def config_without_api_key
-        [exporter_configuration[0..1]].to_h
+        "#{exporter_configuration[0]}: #{exporter_configuration[1]}"
       end
     end
   end

data/lib/datadog/profiling/scheduler.rb

@@ -4,6 +4,7 @@ require_relative "../core/utils/time"
 
 require_relative "../core/worker"
 require_relative "../core/workers/polling"
+require_relative "../core/telemetry/logger"
 
 module Datadog
   module Profiling
@@ -134,6 +135,7 @@ module Datadog
           Datadog.logger.error(
             "Unable to report profile. Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
           )
+          Datadog::Core::Telemetry::Logger.report(e, description: "Unable to report profile")
         end
 
         true

data/lib/datadog/profiling/stack_recorder.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../core/telemetry/logger"
+
 module Datadog
   module Profiling
     # Stores stack samples in a native libdatadog data structure and expose Ruby-level serialization APIs
@@ -7,8 +9,13 @@ module Datadog
     # Methods prefixed with _native_ are implemented in `stack_recorder.c`
     class StackRecorder
       def initialize(
-        cpu_time_enabled:, alloc_samples_enabled:, heap_samples_enabled:, heap_size_enabled:,
-        heap_sample_every:, timeline_enabled:
+        cpu_time_enabled:,
+        alloc_samples_enabled:,
+        heap_samples_enabled:,
+        heap_size_enabled:,
+        heap_sample_every:,
+        timeline_enabled:,
+        heap_clean_after_gc_enabled:
       )
         # This mutex works in addition to the fancy C-level mutexes we have in the native side (see the docs there).
         # It prevents multiple Ruby threads calling serialize at the same time -- something like
@@ -19,13 +26,36 @@ module Datadog
         @no_concurrent_synchronize_mutex = Mutex.new
 
         self.class._native_initialize(
-          self,
-          cpu_time_enabled,
-          alloc_samples_enabled,
-          heap_samples_enabled,
-          heap_size_enabled,
-          heap_sample_every,
-          timeline_enabled,
+          self_instance: self,
+          cpu_time_enabled: cpu_time_enabled,
+          alloc_samples_enabled: alloc_samples_enabled,
+          heap_samples_enabled: heap_samples_enabled,
+          heap_size_enabled: heap_size_enabled,
+          heap_sample_every: heap_sample_every,
+          timeline_enabled: timeline_enabled,
+          heap_clean_after_gc_enabled: heap_clean_after_gc_enabled,
+        )
+      end
+
+      def self.for_testing(
+        cpu_time_enabled: true,
+        alloc_samples_enabled: false,
+        heap_samples_enabled: false,
+        heap_size_enabled: false,
+        heap_sample_every: 1,
+        timeline_enabled: false,
+        heap_clean_after_gc_enabled: true,
+        **options
+      )
+        new(
+          cpu_time_enabled: cpu_time_enabled,
+          alloc_samples_enabled: alloc_samples_enabled,
+          heap_samples_enabled: heap_samples_enabled,
+          heap_size_enabled: heap_size_enabled,
+          heap_sample_every: heap_sample_every,
+          timeline_enabled: timeline_enabled,
+          heap_clean_after_gc_enabled: heap_clean_after_gc_enabled,
+          **options,
         )
       end
 
@@ -42,6 +72,7 @@ module Datadog
           error_message = result
 
           Datadog.logger.error("Failed to serialize profiling data: #{error_message}")
+          Datadog::Core::Telemetry::Logger.error("Failed to serialize profiling data")
 
           nil
         end

data/lib/datadog/single_step_instrument.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+#
+# Entrypoint file for single step instrumentation.
+#
+# This file's path is private. Do not reference this file.
+#
+begin
+  require_relative 'auto_instrument'
+rescue StandardError, LoadError => e
+  warn "Single step instrumentation failed: #{e.class}:#{e.message}\n\tSource:\n\t#{Array(e.backtrace).join("\n\t")}"
+end

data/lib/datadog/tracing/component.rb

@@ -73,6 +73,19 @@ module Datadog
           return sampler
         end
 
+        # AppSec events are sent to the backend using traces.
+        # Standalone ASM billing means that we don't want to charge clients for APM traces,
+        # so we want to send the minimum amount of traces possible (idealy only traces that contains security events),
+        # but for features such as API Security, we need to send at least one trace per minute,
+        # to keep the service alive on the backend side.
+        if settings.appsec.standalone.enabled
+          post_sampler = Tracing::Sampling::RuleSampler.new(
+            [Tracing::Sampling::SimpleRule.new(sample_rate: 1.0)],
+            rate_limiter: Datadog::Core::TokenBucket.new(1.0 / 60, 1.0),
+            default_sample_rate: 1.0 / 60
+          )
+        end
+
         # Sampling rules are provided
         if (rules = settings.tracing.sampling.rules)
           post_sampler = Tracing::Sampling::RuleSampler.parse(

data/lib/datadog/tracing/contrib/action_cable/instrumentation.rb

@@ -14,21 +14,17 @@ module Datadog
           module ActionCableConnection
             def on_open
               Tracing.trace(Ext::SPAN_ON_OPEN) do |span, trace|
-                begin
-                  span.resource = "#{self.class}#on_open"
-                  span.type = Tracing::Metadata::Ext::AppTypes::TYPE_WEB
+                span.resource = "#{self.class}#on_open"
+                span.type = Tracing::Metadata::Ext::AppTypes::TYPE_WEB
 
-                  span.set_tag(Ext::TAG_ACTION, 'on_open')
-                  span.set_tag(Ext::TAG_CONNECTION, self.class.to_s)
+                span.set_tag(Ext::TAG_ACTION, 'on_open')
+                span.set_tag(Ext::TAG_CONNECTION, self.class.to_s)
 
-                  span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
-                  span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_ON_OPEN)
+                span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+                span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_ON_OPEN)
 
-                  # Set the resource name of the trace
-                  trace.resource = span.resource
-                rescue StandardError => e
-                  Datadog.logger.error("Error preparing span for ActionCable::Connection: #{e}")
-                end
+                # Set the resource name of the trace
+                trace.resource = span.resource
 
                 super
               end

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

@@ -7,6 +7,7 @@ require_relative '../ext'
 require_relative '../utils'
 require_relative '../../rack/middlewares'
 require_relative '../../analytics'
+require_relative '../../../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -43,6 +44,7 @@ module Datadog
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_CONTROLLER)
             rescue StandardError => e
               Datadog.logger.error(e.message)
+              Datadog::Core::Telemetry::Logger.report(e)
             end
 
             def finish_processing(payload)
@@ -81,10 +83,13 @@ module Datadog
               end
             rescue StandardError => e
               Datadog.logger.error(e.message)
+              Datadog::Core::Telemetry::Logger.report(e)
             end
 
             # Instrumentation for ActionController::Metal
             module Metal
+              # TODO: Refactor this method to avoid using async API that splits the logic
+              # into two different methods (`start_processing` and `finish_processing`)
               def process_action(*args)
                 # mutable payload with a tracing context that is used in two different
                 # signals; it propagates the request span so that it can be finished

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative '../../../metadata/ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActionPack
+        module ActionDispatch
+          # Instrumentation for ActionDispatch components
+          module Instrumentation
+            module_function
+
+            def set_http_route_tags(route_spec, script_name)
+              return unless Tracing.enabled?
+
+              return unless route_spec
+
+              request_trace = Tracing.active_trace
+              return unless request_trace
+
+              request_trace.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE, route_spec.to_s.gsub(/\(.:format\)\z/, ''))
+
+              if script_name && !script_name.empty?
+                request_trace.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE_PATH, script_name)
+              end
+            end
+
+            def dispatcher_route?(route)
+              return true if route.dispatcher?
+
+              # in Rails 4 there is no #rack_app method on the app
+              return true if route.app.respond_to?(:rack_app) && !route.app.rack_app.nil?
+
+              false
+            end
+
+            # Instrumentation for ActionDispatch::Journey components
+            module Journey
+              # Instrumentation for ActionDispatch::Journey::Router for Rails versions older than 7.1
+              module Router
+                def find_routes(req)
+                  result = super
+
+                  # result is an array of [match, parameters, route] tuples
+                  routes = result.map(&:last)
+
+                  routes.each do |route|
+                    if Instrumentation.dispatcher_route?(route)
+                      Instrumentation.set_http_route_tags(route.path.spec, req.env['SCRIPT_NAME'])
+                      break
+                    end
+                  end
+
+                  result
+                end
+              end
+
+              # Since Rails 7.1 `Router#find_routes` makes the route computation lazy
+              # https://github.com/rails/rails/commit/35b280fcc2d5d474f9f2be3aca3ae7aa6bba66eb
+              module LazyRouter
+                def find_routes(req)
+                  super do |match, parameters, route|
+                    if Instrumentation.dispatcher_route?(route)
+                      Instrumentation.set_http_route_tags(route.path.spec, req.env['SCRIPT_NAME'])
+                    end
+
+                    yield [match, parameters, route]
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative '../../patcher'
+require_relative 'instrumentation'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActionPack
+        module ActionDispatch
+          # Patcher for ActionController components
+          module Patcher
+            include Contrib::Patcher
+
+            module_function
+
+            def target_version
+              Integration.version
+            end
+
+            def patch
+              if ::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)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -2,6 +2,7 @@
 
 require_relative '../patcher'
 require_relative 'action_controller/patcher'
+require_relative 'action_dispatch/patcher'
 
 module Datadog
   module Tracing
@@ -19,6 +20,7 @@ module Datadog
 
           def patch
             ActionController::Patcher.patch
+            ActionDispatch::Patcher.patch
           end
         end
       end

data/lib/datadog/tracing/contrib/active_record/configuration/resolver.rb

@@ -2,6 +2,7 @@
 
 require_relative '../../configuration/resolver'
 require_relative 'makara_resolver'
+require_relative '../../../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -72,10 +73,12 @@ module Datadog
               #
               # `db_config` input may contain sensitive information such as passwords,
               # hence provide a succinct summary for the error logging.
+              #
               Datadog.logger.error(
                 'Failed to resolve ActiveRecord database configuration. '\
                 "Cause: #{e.class.name} Source: #{Array(e.backtrace).first}"
               )
+              Core::Telemetry::Logger.report(e, description: 'Failed to resolve ActiveRecord database configuration')
 
               nil
             end
@@ -95,6 +98,7 @@ module Datadog
                 "Failed to resolve key #{matcher.inspect}. " \
                 "Cause: #{e.class.name} Source: #{Array(e.backtrace).first}"
               )
+              Core::Telemetry::Logger.report(e, description: 'Failed to resolve key')
 
               nil
             end

data/lib/datadog/tracing/contrib/active_record/events/instantiation.rb

@@ -4,6 +4,7 @@ require_relative '../../../metadata/ext'
 require_relative '../../analytics'
 require_relative '../ext'
 require_relative '../event'
+require_relative '../../../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -48,7 +49,8 @@ module Datadog
               span.set_tag(Ext::TAG_INSTANTIATION_CLASS_NAME, payload.fetch(:class_name))
               span.set_tag(Ext::TAG_INSTANTIATION_RECORD_COUNT, payload.fetch(:record_count))
             rescue StandardError => e
-              Datadog.logger.debug(e.message)
+              Datadog.logger.error(e.message)
+              Datadog::Core::Telemetry::Logger.report(e)
             end
           end
         end

data/lib/datadog/tracing/contrib/active_record/events/sql.rb

@@ -6,6 +6,7 @@ require_relative '../event'
 require_relative '../ext'
 require_relative '../../analytics'
 require_relative '../../utils/database'
+require_relative '../../../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -68,7 +69,8 @@ module Datadog
               span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, config[:host]) if config[:host]
               span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, config[:port]) if config[:port]
             rescue StandardError => e
-              Datadog.logger.debug(e.message)
+              Datadog.logger.error(e.message)
+              Datadog::Core::Telemetry::Logger.report(e)
             end
           end
         end

data/lib/datadog/tracing/contrib/active_support/cache/events/cache.rb

@@ -2,6 +2,7 @@
 
 require_relative '../../ext'
 require_relative '../event'
+require_relative '../../../../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -64,7 +65,7 @@ module Datadog
                 key = payload[:key]
                 store = payload[:store]
 
-                mapping = MAPPING[event]
+                mapping = MAPPING.fetch(event)
 
                 span.service = configuration[:cache_service]
                 span.resource = mapping[:resource]
@@ -81,6 +82,9 @@ module Datadog
                 span.set_tag('EVENT', event)
 
                 set_cache_key(span, key, mapping[:multi_key])
+              rescue StandardError => e
+                Datadog.logger.error(e.message)
+                Datadog::Core::Telemetry::Logger.report(e)
               end
 
               def set_cache_key(span, key, multi_key)

data/lib/datadog/tracing/contrib/aws/instrumentation.rb

@@ -29,6 +29,7 @@ module Datadog
           private
 
           # rubocop:disable Metrics/AbcSize
+          # rubocop:disable Metrics/MethodLength
           def annotate!(span, context)
             span.service = configuration[:service_name]
             span.type = Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
@@ -76,7 +77,11 @@ module Datadog
             span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, context.safely(:status_code))
 
             Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
+          rescue StandardError => e
+            Datadog.logger.error(e.message)
+            Datadog::Core::Telemetry::Logger.report(e)
           end
+          # rubocop:enable Metrics/MethodLength
           # rubocop:enable Metrics/AbcSize
 
           def configuration

data/lib/datadog/tracing/contrib/elasticsearch/patcher.rb

@@ -93,11 +93,16 @@ module Datadog
                   span.resource = "#{method} #{quantized_url}"
                   Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
                 rescue StandardError => e
+                  # TODO: Refactor the code to streamline the execution without ensure
                   Datadog.logger.error(e.message)
+                  Datadog::Core::Telemetry::Logger.report(e)
                 ensure
                   # the call is still executed
                   response = super
-                  span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, response.status)
+
+                  if response && response.respond_to?(:status)
+                    span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, response.status)
+                  end
                 end
               end
               response

data/lib/datadog/tracing/contrib/ethon/easy_patch.rb

@@ -110,6 +110,10 @@ module Datadog
 
               datadog_tag_request
 
+              if Datadog::AppSec::Utils::TraceOperation.appsec_standalone_reject?(datadog_trace)
+                datadog_trace.sampling_priority = Tracing::Sampling::Ext::Priority::AUTO_REJECT
+              end
+
               if datadog_configuration[:distributed_tracing]
                 @datadog_original_headers ||= {}
                 Contrib::HTTP.inject(datadog_trace, @datadog_original_headers)

data/lib/datadog/tracing/contrib/excon/middleware.rb

@@ -30,6 +30,9 @@ module Datadog
                 trace = Tracing.active_trace
                 datum[:datadog_span] = span
                 annotate!(span, datum)
+                if Datadog::AppSec::Utils::TraceOperation.appsec_standalone_reject?(trace)
+                  trace.sampling_priority = Tracing::Sampling::Ext::Priority::AUTO_REJECT
+                end
                 propagate!(trace, span, datum) if distributed_tracing?
 
                 span

data/lib/datadog/tracing/contrib/faraday/middleware.rb

@@ -7,6 +7,7 @@ require_relative '../http'
 require_relative '../analytics'
 require_relative 'ext'
 require_relative '../http_annotation_helper'
+require_relative '../../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -28,6 +29,9 @@ module Datadog
 
             Tracing.trace(Ext::SPAN_REQUEST, on_error: request_options[:on_error]) do |span, trace|
               annotate!(span, env, request_options)
+              if Datadog::AppSec::Utils::TraceOperation.appsec_standalone_reject?(trace)
+                trace.sampling_priority = Tracing::Sampling::Ext::Priority::AUTO_REJECT
+              end
               propagate!(trace, span, env) if request_options[:distributed_tracing] && Tracing.enabled?
               app.call(env).on_complete { |resp| handle_response(span, resp, request_options) }
             end
@@ -37,6 +41,7 @@ module Datadog
 
           attr_reader :app
 
+          # rubocop:disable Metrics/AbcSize
           def annotate!(span, env, options)
             span.resource = resource_name(env)
             span.service = service_name(env[:url].host, options)
@@ -75,7 +80,11 @@ module Datadog
             )
 
             Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
+          rescue StandardError => e
+            Datadog.logger.error(e.message)
+            Datadog::Core::Telemetry::Logger.report(e)
           end
+          # rubocop:enable Metrics/AbcSize
 
           def handle_response(span, env, options)
             span.set_error(["Error #{env[:status]}", env[:body]]) if options[:error_status_codes].include? env[:status]
@@ -85,6 +94,9 @@ module Datadog
             span.set_tags(
               Datadog.configuration.tracing.header_tags.response_tags(env[:response_headers])
             )
+          rescue StandardError => e
+            Datadog.logger.error(e.message)
+            Datadog::Core::Telemetry::Logger.report(e)
           end
 
           def propagate!(trace, span, env)