datadog 2.46.0 → 2.47.0

data/lib/datadog/di/component.rb

@@ -122,6 +122,7 @@ module Datadog
         # cannot race a foreground start! with a background stop!.
         @lifecycle_mutex = Mutex.new
         @started = false
+        @rc_enablement_signal_paths = []
       end
 
       attr_reader :settings
@@ -201,6 +202,75 @@ module Datadog
         @started
       end
 
+      # Whether the component is started while the customer left
+      # DD_DYNAMIC_INSTRUMENTATION_ENABLED at its default, the state produced
+      # by remote-configuration enablement.
+      #
+      # An explicit `enabled = false` takes precedence over a prior RC
+      # enablement: once the customer sets the option, this returns false
+      # even while the component is still started.
+      #
+      # @return [Boolean]
+      def implicitly_enabled?
+        started? && settings.dynamic_instrumentation.using_default?(:enabled)
+      end
+
+      # Whether an APM_TRACING merge that omitted dynamic_instrumentation_enabled
+      # withdraws this component's RC enable signal, so the component must stop.
+      #
+      # Returns true when the component is implicitly enabled and no unparseable
+      # content can be the signal carrier. A content at a recorded signal path can be
+      # the carrier. When no paths are recorded, every unparseable content can be the
+      # carrier.
+      #
+      # @param unparseable_contents [Array<Core::Remote::Configuration::Content>] the APM_TRACING contents that failed to parse at this merge
+      # @return [Boolean]
+      def rc_enablement_signal_withdrawn?(unparseable_contents)
+        return false unless implicitly_enabled?
+
+        recorded_signal_paths = rc_enablement_signal_paths
+        signal_source_unparseable =
+          if recorded_signal_paths.empty?
+            unparseable_contents.any?
+          else
+            unparseable_contents.any? { |content| recorded_signal_paths.include?(content.path) }
+          end
+        if signal_source_unparseable
+          if recorded_signal_paths.empty?
+            logger.trace do
+              "APM_TRACING RC: dynamic_instrumentation_enabled absent while an APM_TRACING config " \
+              "failed to parse; the enable signal carrier is unknown (no signal paths recorded), " \
+              "keeping the DI state"
+            end
+          else
+            logger.trace do
+              "APM_TRACING RC: dynamic_instrumentation_enabled absent while the config that carried " \
+              "the enable signal failed to parse; keeping the DI state"
+            end
+          end
+          false
+        else
+          logger.trace { "APM_TRACING RC: dynamic_instrumentation_enabled withdrawn; treating as false" }
+          true
+        end
+      end
+
+      # The repository paths of the APM_TRACING contents that supplied the
+      # dynamic_instrumentation_enabled value at the last merge where the field was
+      # present. The component holds the paths so that they outlive the RC client.
+      #
+      # @return [Array<Core::Remote::Configuration::Path>]
+      attr_reader :rc_enablement_signal_paths
+
+      # Replaces the recorded enable-signal carrier paths.
+      #
+      # @param paths [Array<Core::Remote::Configuration::Path>] the carrier paths, empty when the merged field was absent
+      # @return [void]
+      def record_rc_enablement_signal_paths(paths)
+        @rc_enablement_signal_paths = paths.dup
+        nil
+      end
+
       # Shuts down dynamic instrumentation permanently.
       #
       # Removes all code hooks and stops background threads.

data/lib/datadog/di/remote.rb

@@ -98,6 +98,9 @@ module Datadog
             # and DI.activate_tracking is defined.
             DI.activate_tracking
             was_started = component.started?
+            if repository && !was_started
+              remove_withdrawn_probes(repository, component)
+            end
             component.start!
             # A probe delivered in an earlier poll while the component was stopped
             # was dropped by #receivers (which ignores changes while !started?) and
@@ -145,7 +148,9 @@ module Datadog
             # DEV: Apply this refactor to AppSec as well if implemented.
 
             component = DI.component
-            if component&.started?
+            if changes.empty?
+              remove_withdrawn_probes(repository, component) if component
+            elsif component&.started?
               changes.each do |change|
                 case change.type
                 when :insert
@@ -176,7 +181,7 @@ module Datadog
 
         def receiver(products = [PRODUCT], &block)
           matcher = Core::Remote::Dispatcher::Matcher::Product.new(products)
-          [Core::Remote::Dispatcher::Receiver.new(matcher, &block)]
+          [Core::Remote::Dispatcher::Receiver.new(matcher, initial_reconcile: true, &block)]
         end
 
         private
@@ -266,6 +271,45 @@ module Datadog
           end
         end
 
+        # Removes every probe the component tracks whose id is absent from all
+        # LIVE_DEBUGGING contents in the repository. Reconciles backend deletions that
+        # produced no delete change for {.receivers}. Skips removal while a
+        # LIVE_DEBUGGING content fails to parse, because that content can hold any
+        # tracked probe.
+        def remove_withdrawn_probes(repository, component)
+          # @type var present_probe_ids: Array[String]
+          present_probe_ids = []
+          content_failed_to_parse = false
+          repository.contents.each do |content|
+            next unless content.path.product == PRODUCT
+
+            begin
+              present_probe_ids << parse_content(content)["id"]
+            rescue => exc
+              component.logger.debug do
+                "di: skipping withdrawn-probe reconcile, a LIVE_DEBUGGING content failed to parse: " \
+                "#{exc.class}: #{exc.message}"
+              end
+              content_failed_to_parse = true
+              break
+            end
+          end
+          return if content_failed_to_parse
+
+          probe_repository = component.probe_manager.probe_repository
+          tracked_probe_ids = probe_repository.installed_probes.keys | probe_repository.pending_probes.keys
+          (tracked_probe_ids - present_probe_ids).each do |probe_id|
+            component.logger.trace { "di: removing probe #{probe_id} withdrawn from remote configuration" }
+            component.probe_manager.remove_probe(probe_id)
+          rescue Exception => exc # standard:disable Lint/RescueException
+            Datadog::DI.reraise_if_fatal(exc)
+            raise if component.settings.dynamic_instrumentation.internal.propagate_all_exceptions
+
+            component.logger.debug { "di: error removing withdrawn probe #{probe_id}: #{exc.class}: #{exc.message}" }
+            component.telemetry&.report(exc, description: "Error removing withdrawn probe")
+          end
+        end
+
         def probe_known?(probe_id, component)
           repo = component.probe_manager.probe_repository
           !!(repo.find_installed(probe_id) ||

data/lib/datadog/di/serializer.rb

@@ -96,8 +96,25 @@ module Datadog
       # hex string, or UTF-8 with replacement characters) before returning
       # it from the custom serializer.
       @@flat_registry = []
-      def self.register(condition: nil, &block)
+      # Registers a custom serializer. The block serializes each value
+      # for which +condition+ returns a truthy value.
+      #
+      # @param condition [Proc] receives the value being serialized and
+      #   returns whether this serializer applies to it
+      # @param block [Proc] serializer for the values +condition+ accepts
+      # @raise [ArgumentError] if +condition+ is not a Proc or +block+ is absent
+      # @return [void]
+      def self.register(condition:, &block)
+        unless condition.is_a?(Proc)
+          raise ArgumentError, "Serializer.register condition must be a Proc, got #{condition.class}"
+        end
+
+        unless block
+          raise ArgumentError, "Serializer.register requires a serializer block"
+        end
+
         @@flat_registry << {condition: condition, proc: block}
+        nil
       end
 
       # Initializes the serializer.
@@ -159,7 +176,7 @@ module Datadog
       # @param args [Array] positional arguments passed to the probed method
       # @param kwargs [Hash{Symbol => Object}] keyword arguments passed to the probed method
       # @param target_self [any] receiver of the probed method invocation
-      # @param deadline [Float] absolute capture deadline in monotonic clock seconds
+      # @param deadline [Float] absolute capture deadline in thread CPU clock seconds
       # @return [Hash{Symbol => Hash}] serialized arguments keyed by argument name
       def serialize_args(args, kwargs, target_self,
         deadline:,
@@ -178,7 +195,7 @@ module Datadog
       # of executed code.
       #
       # @param vars [Hash{Symbol => Object}] variables to serialize, keyed by variable name
-      # @param deadline [Float] absolute capture deadline in monotonic clock seconds
+      # @param deadline [Float] absolute capture deadline in thread CPU clock seconds
       # @return [Hash{Symbol => Hash}] serialized variables keyed by variable name
       def serialize_vars(vars,
         deadline:,
@@ -207,7 +224,7 @@ module Datadog
       #
       # @param value [any] value to serialize
       # @param name [Symbol, String, nil] name the value is bound to, used for redaction
-      # @param deadline [Float] absolute capture deadline in monotonic clock seconds
+      # @param deadline [Float] absolute capture deadline in thread CPU clock seconds
       # @return [Hash{Symbol => Object}] serialized value; the {type:, notCapturedReason: "timeout"} stub when the deadline is exceeded
       def serialize_value(value, deadline:,
         name: nil,
@@ -541,21 +558,20 @@ module Datadog
         "#<#{class_name(value.class)}: serialization error>"
       end
 
-      # Computes the absolute monotonic deadline (in seconds) for a capture
-      # point from max_time_to_serialize_ms. Resolve once per capture point and
-      # share across all values serialized on the built-in paths so the
-      # budget is not exceeded.
+      # Computes the absolute thread CPU time deadline (in seconds) for a
+      # capture point from max_time_to_serialize_ms.
       #
-      # @return [Float] absolute monotonic clock reading, in seconds, at
+      # @return [Float] absolute thread CPU clock reading, in seconds, at
       #   which the capture budget is exhausted
       def serialization_deadline
-        Core::Utils::Time.get_time + settings.dynamic_instrumentation.max_time_to_serialize_ms / 1000.0
+        Process.clock_gettime(Process::CLOCK_THREAD_CPUTIME_ID, :float_second) +
+          settings.dynamic_instrumentation.max_time_to_serialize_ms / 1000.0
       end
 
       private
 
       def deadline_exceeded?(deadline)
-        Core::Utils::Time.get_time >= deadline
+        Process.clock_gettime(Process::CLOCK_THREAD_CPUTIME_ID, :float_second) >= deadline
       end
 
       MAX_MESSAGE_COLLECTION_SIZE = 3

data/lib/datadog/open_feature/configuration.rb

@@ -78,6 +78,12 @@ module Datadog
                 o.default true
               end
 
+              option :evaluation_telemetry_per_subject_opt_out_enabled do |o|
+                o.type :bool
+                o.env "DD_FEATURE_FLAGS_EVALUATION_TELEMETRY_PER_SUBJECT_OPT_OUT_ENABLED"
+                o.default false
+              end
+
               option :configuration_source do |o|
                 o.type :string
                 o.env "DD_FEATURE_FLAGS_CONFIGURATION_SOURCE"

data/lib/datadog/open_feature/hooks/evaluation_telemetry_opt_out_hook.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Datadog
+  module OpenFeature
+    module Hooks
+      class EvaluationTelemetryOptOutHook
+        PARAMETER = "dd_evaluation_telemetry_opt_out"
+
+        def self.opted_out?(evaluation_context)
+          evaluation_context&.fields&.[](PARAMETER).equal?(true)
+        end
+
+        def initialize(hook)
+          @hook = hook
+        end
+
+        def finally(hook_context:, evaluation_details:, **options)
+          return if self.class.opted_out?(hook_context.evaluation_context)
+
+          @hook.finally(hook_context: hook_context, evaluation_details: evaluation_details, **options)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/open_feature/provider.rb

@@ -3,6 +3,7 @@
 require_relative "ext"
 require_relative "../open_feature"
 require_relative "../core/utils/time"
+require_relative "hooks/evaluation_telemetry_opt_out_hook"
 require "open_feature/sdk"
 
 module Datadog
@@ -67,7 +68,15 @@ module Datadog
 
       attr_reader :metadata
 
-      def initialize
+      def initialize(enable_evaluation_telemetry_opt_out_parameter: nil)
+        @enable_evaluation_telemetry_opt_out_parameter = case enable_evaluation_telemetry_opt_out_parameter
+        when nil
+          Datadog.configuration.feature_flags.evaluation_telemetry_per_subject_opt_out_enabled
+        when true, false
+          enable_evaluation_telemetry_opt_out_parameter
+        else
+          raise ArgumentError, "enable_evaluation_telemetry_opt_out_parameter expects true, false, or nil"
+        end
         @metadata = ::OpenFeature::SDK::Provider::ProviderMetadata.new(name: NAME).freeze
         @initialization_mutex = Mutex.new
         @initializing = false
@@ -168,10 +177,13 @@ module Datadog
 
       def hooks
         component = Datadog.send(:components).open_feature
-        [
+        hooks = [
           component&.flag_eval_metrics_hook,
           component&.flag_eval_evp_hook,
         ].compact
+        return hooks unless @enable_evaluation_telemetry_opt_out_parameter
+
+        hooks.map { |hook| Hooks::EvaluationTelemetryOptOutHook.new(hook) }
       end
 
       def fetch_boolean_value(flag_key:, default_value:, evaluation_context: nil)
@@ -406,7 +418,9 @@ module Datadog
         # Drive APM span enrichment directly from the evaluation path. This is the only reliable
         # way to attach `ffe_*` tags across all supported OpenFeature SDK versions, since older
         # SDKs do not dispatch provider hooks. Guarded so enrichment can never break evaluation.
-        enrich_span(flag_key, result, evaluation_context)
+        unless evaluation_telemetry_opted_out?(evaluation_context)
+          enrich_span(flag_key, result, evaluation_context)
+        end
 
         sdk_success_details(result, flag_meta)
       rescue => e
@@ -495,6 +509,11 @@ module Datadog
         Datadog.send(:components).open_feature&.span_enrichment_hook
       end
 
+      def evaluation_telemetry_opted_out?(evaluation_context)
+        @enable_evaluation_telemetry_opt_out_parameter &&
+          Hooks::EvaluationTelemetryOptOutHook.opted_out?(evaluation_context)
+      end
+
       def component_not_configured_default(value, eval_time_ms)
         ::OpenFeature::SDK::Provider::ResolutionDetails.new(
           value: value,

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "json"
 require "libdatadog"
 require_relative "../../core/utils/time"
 
@@ -9,11 +10,11 @@ module Datadog
       # Collects information of relevance for profiler. This will get sent alongside
       # the profile and show up in the UI or potentially influence processing in some way.
       #
-      # Information is currently collected and frozen at construction time. A full collector
-      # could be seen as overkill for this case but it allows us to centralize information
-      # gathering and easily support more flexible/dynamic info collection in the future.
+      # Most information is static: collected and frozen at construction time. The exception is
+      # what `collect_dynamic_info` collects, which can change during the process lifetime.
       class Info
-        # @rbs @info: ::Hash[::Symbol, ::Hash[::Symbol, untyped]]
+        # @rbs @static_info: ::Hash[::Symbol, ::Hash[::Symbol, untyped]]
+        # @rbs @info_json_cache: [::Hash[::Symbol, bool], ::String]?
         # @rbs @platform_info: ::Hash[::Symbol, untyped]
         # @rbs @runtime_info: ::Hash[::Symbol, untyped]
         # @rbs @application_info: ::Hash[::Symbol, untyped]
@@ -24,18 +25,48 @@ module Datadog
         def initialize(settings)
           @profiler_info = nil
 
-          @info = {
+          @static_info = {
             platform: collect_platform_info,
             runtime: collect_runtime_info,
             application: collect_application_info(settings),
             profiler: collect_profiler_info(settings),
           }.freeze
+          @info_json_cache = nil
         end
 
-        attr_reader :info #: ::Hash[::Symbol, ::Hash[::Symbol, untyped]]
+        #: () -> ::Hash[::Symbol, ::Hash[::Symbol, untyped]]
+        def info
+          build_info(collect_dynamic_info)
+        end
+
+        # Serializing the same info on every flush would be wasteful, so the latest result is
+        # cached and reused for as long as the dynamic info is unchanged.
+        #: () -> ::String
+        def info_json
+          dynamic_info = collect_dynamic_info
+          cached_dynamic_info, cached_json = @info_json_cache
+          return cached_json if cached_json && cached_dynamic_info == dynamic_info
+
+          json = JSON.generate(build_info(dynamic_info)).freeze
+          @info_json_cache = [dynamic_info, json].freeze #: [::Hash[::Symbol, bool], ::String]
+          json
+        end
 
         private
 
+        #: (::Hash[::Symbol, bool]) -> ::Hash[::Symbol, ::Hash[::Symbol, untyped]]
+        def build_info(dynamic_info)
+          @static_info.merge(runtime: @static_info.fetch(:runtime).merge(dynamic_info))
+        end
+
+        #: () -> ::Hash[::Symbol, bool]
+        def collect_dynamic_info
+          {
+            yjit_enabled: defined?(::RubyVM::YJIT) ? ::RubyVM::YJIT.enabled? : false,
+            zjit_enabled: defined?(::RubyVM::ZJIT) ? ::RubyVM::ZJIT.enabled? : false,
+          }
+        end
+
         # Ruby GC tuning environment variables
         RUBY_GC_TUNING_ENV_VARS = [
           "RUBY_GC_HEAP_FREE_SLOTS",

data/lib/datadog/profiling/component.rb

@@ -427,33 +427,35 @@ module Datadog
         end
       end
 
-      # To add just a bit more complexity to our detection code, in https://github.com/DataDog/dd-trace-rb/issues/3334
-      # a user reported that our code was incorrectly flagging the mariadb variant of libmysqlclient as being
-      # incompatible. In fact we have no reports of the mariadb variant needing the "no signals" workaround,
-      # so we flag it as compatible when it's in use.
+      # MariaDB's client has diverged from Oracle's and has no reported need for the "no signals" workaround, as
+      # reported in https://github.com/DataDog/dd-trace-rb/issues/3334, so we flag it as compatible when it's in use.
       #
-      # A problem is that there doesn't seem to be an obvious way to query the mysql2 gem on which kind of
-      # libmysqlclient it's using, so we detect it by looking at the version.
+      # There's no way to ask the mysql2 gem which client it was built against, so we infer it from the two versions
+      # that `Mysql2::Client.info` exposes:
       #
-      # The info method for mysql2 with mariadb looks something like this:
-      # `{:id=>30308, :version=>"3.3.8", :header_version=>"11.2.2"}`
+      # * `version` is `mysql_get_client_info()`. For MariaDB that's the version of
+      #   https://github.com/mariadb-corporation/mariadb-connector-c, which is still 3.x.
+      # * `header_version` is a constant baked in when mysql2 was compiled. Up to mysql2 0.5.6 it was the MariaDB
+      #   server version, which is what people usually call "the mariadb version"; 0.5.7 switched it to the
+      #   Connector/C version (https://github.com/brianmario/mysql2/pull/1406) and that broke our detection, as
+      #   reported in https://github.com/DataDog/dd-trace-rb/issues/6536.
       #
-      # * The version seems to come from https://github.com/mariadb-corporation/mariadb-connector-c and the latest
-      # one is 3.x.
-      # * The header_version is what people usually see as the "mariadb version"
+      # So MariaDB shows up as `{version: "3.3.8", header_version: "11.2.2"}` with mysql2 < 0.5.7 and as
+      # `{version: "3.4.9", header_version: "3.4.9"}` from 0.5.7 on. We accept both shapes: a header that is a server
+      # version (10 or newer, a sane range for modern releases per https://endoflife.date/mariadb) or one that is a
+      # Connector/C version (3.x, matching the client version).
       #
-      # As a comparison, for libmysql the info looks like:
-      # * `{:id=>80035, :version=>"8.0.35", :header_version=>"8.0.35"}`
-      #
-      # Thus our detection is version 4 or older, because libmysqlclient 4 is almost 20 years old so it's most probably
-      # not that one + header_version being 10 or newer, since according to https://endoflife.date/mariadb that's a
-      # sane range for modern mariadb releases.
+      # Oracle's client repeats one version in both fields (`{version: "8.0.35", header_version: "8.0.35"}`), and our
+      # caller already considers 8.0.0 and above compatible, so only a client older than 5.0.0 gets this far -- and
+      # no Oracle release has been one since libmysqlclient 4.1, which is from 2004.
       private_class_method def self.looks_like_mariadb?(info, libmysqlclient_version)
         header_version = Gem::Version.new(info[:header_version]) if info[:header_version]
 
-        !!(header_version &&
-          libmysqlclient_version < Gem::Version.new("5.0.0") &&
-          header_version >= Gem::Version.new("10.0.0"))
+        return false unless header_version && libmysqlclient_version < Gem::Version.new("5.0.0")
+        return true if header_version >= Gem::Version.new("10.0.0")
+
+        connector_c_versions = Gem::Requirement.new(">= 3.0.0", "< 4.0.0")
+        connector_c_versions.satisfied_by?(libmysqlclient_version) && connector_c_versions.satisfied_by?(header_version)
       end
 
       private_class_method def self.dir_interruption_workaround_enabled?(settings, no_signals_workaround_enabled)

data/lib/datadog/profiling/exporter.rb

@@ -27,7 +27,7 @@ module Datadog
       attr_reader :last_flush_finish_at #: ::Time?
       attr_reader :created_at #: ::Time
       attr_reader :internal_metadata #: ::Hash[::Symbol, untyped]
-      attr_reader :info_json #: ::String
+      attr_reader :info_collector #: Datadog::Profiling::Collectors::Info
       attr_reader :sequence_tracker #: singleton(Datadog::Profiling::SequenceTracker)
 
       public
@@ -56,9 +56,7 @@ module Datadog
         @last_flush_finish_at = nil
         @created_at = time_provider.now.utc
         @internal_metadata = internal_metadata
-        # NOTE: At the time of this comment collected info does not change over time so we'll hardcode
-        #       it on startup to prevent serializing the same info on every flush.
-        @info_json = JSON.generate(info_collector.info).freeze
+        @info_collector = info_collector
         @sequence_tracker = sequence_tracker
       end
 
@@ -111,7 +109,7 @@ module Datadog
               gc: gc_stats,
             }
           ),
-          info_json: info_json,
+          info_json: info_collector.info_json,
         )
       end
 

data/lib/datadog/tracing/component.rb

@@ -21,14 +21,14 @@ module Datadog
         tracer = settings.tracing.instance
         return tracer unless tracer.nil?
 
+        sampler = build_sampler(settings)
+
         # Apply test mode settings if test mode is activated
         if settings.tracing.test_mode.enabled
           trace_flush = build_test_mode_trace_flush(settings)
-          sampler = build_test_mode_sampler
           writer = build_test_mode_writer(settings, agent_settings)
         else
           trace_flush = build_trace_flush(settings)
-          sampler = build_sampler(settings)
           writer = build_writer(settings, agent_settings)
         end
 
@@ -76,7 +76,12 @@ module Datadog
         nil
       end
 
+      # Builds the sampler for the given settings: the sampler that keeps
+      # every trace when test mode is enabled, otherwise the sampler built
+      # from the custom sampler, sampling rules and rates.
       def build_sampler(settings)
+        return build_test_mode_sampler if settings.tracing.test_mode.enabled
+
         # A custom sampler is provided
         if (sampler = settings.tracing.sampler)
           return sampler

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

@@ -128,6 +128,8 @@ module Datadog
           ENV_SERVER_ERROR_STATUSES = "DD_TRACE_HTTP_SERVER_ERROR_STATUSES"
           ENV_CLIENT_ERROR_STATUSES = "DD_TRACE_HTTP_CLIENT_ERROR_STATUSES"
         end
+
+        ENV_HTTP_CLIENT_RESOURCE_NAME_QUANTIZE = "DD_TRACE_HTTP_CLIENT_RESOURCE_NAME_QUANTIZE"
       end
     end
   end

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

@@ -568,6 +568,17 @@ module Datadog
                 o.default 512
               end
 
+              # Whether outbound HTTP client resource names include a quantized request path.
+              # URL tags and outgoing requests are unchanged.
+              #
+              # @default `DD_TRACE_HTTP_CLIENT_RESOURCE_NAME_QUANTIZE` environment variable, otherwise `false`.
+              # @return [Boolean]
+              option :http_client_resource_name_quantize do |o|
+                o.env Tracing::Configuration::Ext::ENV_HTTP_CLIENT_RESOURCE_NAME_QUANTIZE
+                o.default false
+                o.type :bool
+              end
+
               # HTTP error statuses configuration
               # @public_api
               settings :http_error_statuses do

data/lib/datadog/tracing/context_provider.rb

@@ -21,6 +21,14 @@ module Datadog
       def context=(ctx)
         ctx.otel_thread_context = @otel_thread_context if ctx.respond_to?(:otel_thread_context=)
 
+        if (otel_thread_context = @otel_thread_context)
+          if (trace = ctx&.active_trace)
+            otel_thread_context.update_from_trace_op(trace)
+          else
+            otel_thread_context.clear
+          end
+        end
+
         @context.local = ctx
       end
 

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

@@ -7,6 +7,7 @@ require_relative "../../metadata/ext"
 require_relative "../http"
 require_relative "ext"
 require_relative "../http_annotation_helper"
+require_relative "../utils/quantization/http"
 
 module Datadog
   module Tracing
@@ -111,7 +112,7 @@ module Datadog
               )
               datadog_trace = Tracing.active_trace
 
-              datadog_tag_request
+              datadog_tag_request(uri)
 
               if Tracing::Distributed::PropagationPolicy.enabled?(
                 global_config: datadog_configuration,
@@ -131,12 +132,17 @@ module Datadog
 
             attr_reader :datadog_configuration
 
-            def datadog_tag_request
+            def datadog_tag_request(uri)
               span = @datadog_span
               span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
               method = Ext::NOT_APPLICABLE_METHOD
               method = @datadog_method.to_s if instance_variable_defined?(:@datadog_method) && !@datadog_method.nil?
-              span.resource = method
+              path = uri&.path
+              span.resource = Contrib::Utils::Quantization::HTTP.client_resource(
+                method,
+                path,
+                enabled: Datadog.configuration.tracing.http_client_resource_name_quantize
+              )
 
               if datadog_configuration[:peer_service]
                 span.set_tag(
@@ -153,10 +159,9 @@ module Datadog
 
               span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CLIENT)
 
-              uri = try_parse_uri
               return unless uri
 
-              span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, uri.path)
+              span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, path)
               span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD, method)
               span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, uri.host)
               span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, uri.port)

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

@@ -8,6 +8,7 @@ require_relative "../http"
 require_relative "../analytics"
 require_relative "ext"
 require_relative "../http_annotation_helper"
+require_relative "../utils/quantization/http"
 
 module Datadog
   module Tracing
@@ -117,7 +118,13 @@ module Datadog
           end
 
           def annotate!(span, datum)
-            span.resource = datum[:method].to_s.upcase
+            http_method = datum[:method].to_s.upcase
+            path = datum[:path]
+            span.resource = Contrib::Utils::Quantization::HTTP.client_resource(
+              http_method,
+              path,
+              enabled: Datadog.configuration.tracing.http_client_resource_name_quantize
+            )
             span.service = service_name(datum[:host], @options)
             span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
             span.type = Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
@@ -139,8 +146,8 @@ module Datadog
             # Set analytics sample rate
             Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
 
-            span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, datum[:path])
-            span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD, datum[:method].to_s.upcase)
+            span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, path)
+            span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD, http_method)
             span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, datum[:host])
             span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, datum[:port])
             span.set_tags(