datadog 2.45.0 → 2.47.0

data/lib/datadog/open_feature/provider.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
 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
   module OpenFeature
-    # OpenFeature feature flagging provider backed by Datadog Remote Configuration.
+    # OpenFeature feature flagging provider backed by Datadog configuration delivery.
     #
     # Requires openfeature-sdk >= 0.5.1 for flag evaluation metrics and EVP hook support.
     #
@@ -24,13 +26,14 @@ module Datadog
     #
     # Example:
     #
-    #   Make sure to enable Remote Configuration and OpenFeature in the Datadog configuration.
+    #   Feature Flags use agentless configuration delivery by default. To use
+    #   Remote Configuration delivery instead, configure the source explicitly.
     #
     #   ```ruby
     #   # FILE: initializers/datadog.rb
     #   Datadog.configure do |config|
     #     config.remote.enabled = true
-    #     config.open_feature.enabled = true
+    #     config.feature_flags.configuration_source = "remote_config"
     #   end
     #   ```
     #
@@ -58,28 +61,129 @@ module Datadog
     #   # => 'Welcome back!'
     #   ```
     class Provider
+      include ::OpenFeature::SDK::Provider::EventEmitter
+
       NAME = "Datadog Feature Flagging Provider"
+      INITIALIZATION_CANCELLED_MESSAGE = "Feature Flags provider initialization was cancelled by shutdown"
 
       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
+        @initialization_thread = nil
+        @awaiting_ready_after_fork = false
+        @initialization_failed = false
+        @provider_error_observed = false
+        @ready_pending = false
+        @ready_dispatch_claimed = false
+        @stale_emitted = false
+        @stale_pending = false
+        @error_handler = nil
+        @initialization_ready_handler = nil
+        @waiting_component = nil
+        @shutdown = false
       end
 
       def init
-        # no-op
+        @initialization_mutex.synchronize do
+          raise INITIALIZATION_CANCELLED_MESSAGE if @shutdown
+
+          @initializing = true
+          @initialization_thread = Thread.current
+          @awaiting_ready_after_fork = false
+          @initialization_failed = false
+          @provider_error_observed = false
+          @ready_pending = false
+          @ready_dispatch_claimed = false
+          @stale_emitted = false
+          @stale_pending = false
+        end
+        ready_handler_installed = install_initialization_ready_handler
+
+        component, failure = OpenFeature.activate_provider(self)
+        cancel_initialization_if_shutdown!
+        fail_initialization(component, failure || "Feature Flags component could not be activated") unless component
+
+        @initialization_mutex.synchronize do
+          raise INITIALIZATION_CANCELLED_MESSAGE if @shutdown
+
+          @waiting_component = component
+        end
+        # Shutdown publishes this flag through the component lock; taking our mutex here would invert lock order.
+        wait_result = component.wait_for_configuration { @shutdown }
+        cancel_initialization_if_shutdown!
+
+        case wait_result
+        when Component::CONFIGURATION_READY
+          @initialization_mutex.synchronize { @initializing = false } unless ready_handler_installed
+        when Component::CONFIGURATION_TIMEOUT
+          message = "Feature Flags provider initialization timed out while waiting for configuration"
+          Datadog.logger.error(message)
+          fail_initialization(component, message)
+        else
+          fail_initialization(component, "Feature Flags provider initialization stopped before configuration arrived")
+        end
+      rescue
+        prepare_initialization_failure(component) if @initialization_mutex.synchronize { @initializing }
+        raise
+      ensure
+        @initialization_mutex.synchronize do
+          @waiting_component = nil
+          # The SDK still owes READY after init returns; the initializing thread owns that dispatch.
+          @initialization_thread = nil unless @initializing
+        end
       end
 
       def shutdown
-        # no-op
+        configuration = @configuration
+        # @type var error_handler: Provider::provider_event_handler?
+        error_handler = nil
+        # @type var initialization_ready_handler: Provider::provider_event_handler?
+        initialization_ready_handler = nil
+        waiting_component = nil #: Component?
+        @initialization_mutex.synchronize do
+          return if @shutdown
+
+          @shutdown = true
+          @initializing = false
+          @initialization_thread = nil
+          error_handler = @error_handler
+          initialization_ready_handler = @initialization_ready_handler
+          waiting_component = @waiting_component
+          @error_handler = nil
+          @initialization_ready_handler = nil
+        end
+
+        waiting_component&.wake_configuration_waiters
+        configuration&.remove_handler(::OpenFeature::SDK::ProviderEvent::PROVIDER_ERROR, error_handler) if error_handler
+        if initialization_ready_handler
+          configuration&.remove_handler(
+            ::OpenFeature::SDK::ProviderEvent::PROVIDER_READY,
+            initialization_ready_handler,
+          )
+        end
+        OpenFeature.deactivate_provider(self)
       end
 
       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)
@@ -108,6 +212,191 @@ module Datadog
 
       private
 
+      def after_fork(component)
+        handler = @initialization_mutex.synchronize do
+          return if @shutdown || !@initializing || @initialization_thread&.alive?
+
+          @initializing = false
+          @initialization_thread = nil
+          @waiting_component = nil
+          @awaiting_ready_after_fork = true
+          @stale_pending = false
+          previous_handler = @initialization_ready_handler
+          @initialization_ready_handler = nil
+          previous_handler
+        end
+        if handler
+          @configuration&.remove_handler(::OpenFeature::SDK::ProviderEvent::PROVIDER_READY, handler)
+        end
+        configuration_changed(Component::CONFIGURATION_READY) if component&.configuration_received?
+      end
+
+      def fail_initialization(component, message)
+        prepare_initialization_failure(component)
+        cancel_initialization_if_shutdown!
+        raise message.to_s
+      end
+
+      def prepare_initialization_failure(component)
+        cancelled, initialization_ready_handler = @initialization_mutex.synchronize do
+          handler = @initialization_ready_handler
+          @initialization_ready_handler = nil
+          @stale_pending = false
+          @initializing = false
+          @initialization_thread = nil
+          if @shutdown
+            [true, handler]
+          else
+            @initialization_failed = true
+            @ready_pending ||= !!component&.configuration_received?
+            [false, handler]
+          end
+        end
+        if initialization_ready_handler
+          @configuration&.remove_handler(
+            ::OpenFeature::SDK::ProviderEvent::PROVIDER_READY,
+            initialization_ready_handler,
+          )
+        end
+        return if cancelled
+
+        install_error_handler
+      end
+
+      def cancel_initialization_if_shutdown!
+        cancelled = @initialization_mutex.synchronize do
+          @initializing = false if @shutdown
+          @shutdown
+        end
+        raise INITIALIZATION_CANCELLED_MESSAGE if cancelled
+      end
+
+      def shutdown?
+        @initialization_mutex.synchronize { @shutdown }
+      end
+
+      def install_initialization_ready_handler
+        configuration = @configuration
+        return false unless configuration
+
+        handler = @initialization_mutex.synchronize do
+          return false if @shutdown
+          return true if @initialization_ready_handler
+
+          @initialization_ready_handler = ->(details) { provider_ready(details) }
+        end
+        configuration.add_handler(::OpenFeature::SDK::ProviderEvent::PROVIDER_READY, handler)
+
+        cancelled = @initialization_mutex.synchronize { @shutdown }
+        configuration.remove_handler(::OpenFeature::SDK::ProviderEvent::PROVIDER_READY, handler) if cancelled
+        return false if cancelled
+
+        true
+      end
+
+      def install_error_handler
+        configuration = @configuration
+        return unless configuration
+
+        handler = @initialization_mutex.synchronize do
+          return if @shutdown
+
+          @error_handler ||= ->(details) { provider_error(details) }
+        end
+        configuration.add_handler(::OpenFeature::SDK::ProviderEvent::PROVIDER_ERROR, handler)
+
+        cancelled = @initialization_mutex.synchronize { @shutdown }
+        configuration.remove_handler(::OpenFeature::SDK::ProviderEvent::PROVIDER_ERROR, handler) if cancelled
+      end
+
+      def provider_error(_details)
+        configuration = @configuration
+        return unless configuration
+        return unless configuration.send(:provider_state, self) == ::OpenFeature::SDK::ProviderState::ERROR
+
+        emit_ready = @initialization_mutex.synchronize do
+          if @shutdown
+            false
+          else
+            @provider_error_observed = true
+            if @ready_pending && !@ready_dispatch_claimed
+              @ready_dispatch_claimed = true
+            else
+              false
+            end
+          end
+        end
+        emit_event(::OpenFeature::SDK::ProviderEvent::PROVIDER_READY) if emit_ready
+      end
+
+      def provider_ready(_details)
+        configuration = @configuration
+        return unless configuration
+        return unless configuration.send(:provider_state, self) == ::OpenFeature::SDK::ProviderState::READY
+
+        handler, emit_stale = @initialization_mutex.synchronize do
+          handler = @initialization_ready_handler
+          @initialization_ready_handler = nil
+          @initializing = false
+          @initialization_thread = nil
+          if @stale_pending && !@shutdown
+            @stale_pending = false
+            @stale_emitted = true
+            [handler, true]
+          else
+            [handler, false]
+          end
+        end
+        configuration.remove_handler(::OpenFeature::SDK::ProviderEvent::PROVIDER_READY, handler) if handler
+        emit_event(::OpenFeature::SDK::ProviderEvent::PROVIDER_STALE) if emit_stale
+      end
+
+      def configuration_changed(event)
+        event_type = @initialization_mutex.synchronize do
+          if @shutdown
+            nil
+          elsif event == Component::CONFIGURATION_READY
+            if @initializing
+              @ready_pending = true
+              @stale_pending = false
+              nil
+            elsif @awaiting_ready_after_fork
+              @awaiting_ready_after_fork = false
+              @stale_emitted = false
+              ::OpenFeature::SDK::ProviderEvent::PROVIDER_READY
+            elsif @initialization_failed && !@provider_error_observed
+              @stale_emitted = false
+              @ready_pending = true
+              nil
+            elsif @stale_emitted
+              @stale_emitted = false
+              ::OpenFeature::SDK::ProviderEvent::PROVIDER_READY
+            elsif @initialization_failed
+              if @provider_error_observed && !@ready_dispatch_claimed
+                @ready_dispatch_claimed = true
+                ::OpenFeature::SDK::ProviderEvent::PROVIDER_READY
+              else
+                @ready_pending = true
+                nil
+              end
+            end
+          elsif event == Component::CONFIGURATION_CHANGED && !@initializing
+            ::OpenFeature::SDK::ProviderEvent::PROVIDER_CONFIGURATION_CHANGED
+          elsif event == Component::CONFIGURATION_LOST
+            @ready_pending = false
+            if @initializing
+              @stale_pending = true
+              nil
+            else
+              @stale_emitted = true
+              ::OpenFeature::SDK::ProviderEvent::PROVIDER_STALE
+            end
+          end
+        end
+
+        emit_event(event_type) if event_type
+      end
+
       def evaluate(flag_key, default_value:, expected_type:, evaluation_context:)
         # Stamp evaluation entry time once, here on the eval thread. The EVP path uses this for
         # accurate first/last_evaluation bounds instead of a later hook-fire clock read.
@@ -129,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
@@ -218,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/open_feature.rb

@@ -2,6 +2,7 @@
 
 require_relative "core/configuration"
 require_relative "open_feature/configuration"
+require_relative "open_feature/configuration/source"
 
 module Datadog
   # A namespace for the OpenFeature component.
@@ -9,11 +10,40 @@ module Datadog
     Core::Configuration::Settings.extend(Configuration::Settings)
 
     def self.enabled?
-      Datadog.configuration.open_feature.enabled
+      Configuration::Source.resolve(Datadog.configuration).enabled?
     end
 
     def self.engine
       Datadog.send(:components).open_feature&.engine
     end
+
+    def self.activate_provider(provider)
+      # Initialize the component tree before taking its reconfiguration lock.
+      Datadog.send(:components)
+      Datadog.send(:safely_synchronize) do
+        return [nil, nil] if provider.send(:shutdown?)
+
+        components = Datadog.send(:components, allow_initialization: false)
+        activation = components&.send(:open_feature_activation)
+        providers = @adopted_providers ||= {}.compare_by_identity
+        providers[provider] = true
+        [activation&.activate(provider), activation&.failure]
+      end
+    end
+
+    def self.deactivate_provider(provider)
+      Datadog.send(:safely_synchronize) do
+        @adopted_providers&.delete(provider)
+        components = Datadog.send(:components, allow_initialization: false)
+        components&.send(:open_feature_activation)&.deactivate(provider)
+      end
+    end
+
+    # Components startup already holds the non-reentrant reconfiguration lock.
+    def self.reattach(activation)
+      providers = @adopted_providers&.keys || []
+      providers.each { |provider| activation.activate(provider) }
+      nil
+    end
   end
 end

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
 
@@ -62,7 +62,26 @@ module Datadog
         end
       end
 
+      def bind_transport_telemetry(tracer, telemetry)
+        return unless tracer.is_a?(Tracing::Tracer)
+
+        writer = tracer.writer
+        return unless writer.respond_to?(:transport)
+
+        transport = writer.transport
+        if transport.is_a?(Transport::Traces::Transport) ||
+            (defined?(Transport::Native::Transport) && transport.is_a?(Transport::Native::Transport))
+          transport.telemetry = telemetry
+        end
+        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

@@ -258,7 +258,9 @@ module Datadog
 
               option :otel_thread_context_enabled do |o|
                 o.env Tracing::Configuration::Ext::ENV_OTEL_CONTEXT_ENABLED
-                o.default true
+                o.default do
+                  RUBY_ENGINE == "ruby" && RUBY_PLATFORM.include?("linux")
+                end
                 o.type :bool
               end
 
@@ -566,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