ddtrace 1.12.1 → 1.13.1

data/lib/datadog/profiling/component.rb

@@ -7,7 +7,7 @@ module Datadog
       # Passing in a `nil` tracer is supported and will disable the following profiling features:
       # * Code Hotspots panel in the trace viewer, as well as scoping a profile down to a span
       # * Endpoint aggregation in the profiler UX, including normalization (resource per endpoint call)
-      def self.build_profiler_component(settings:, agent_settings:, optional_tracer:)
+      def self.build_profiler_component(settings:, agent_settings:, optional_tracer:) # rubocop:disable Metrics/MethodLength
         return unless settings.profiling.enabled
 
         # Workaround for weird dependency direction: the Core::Configuration::Components class currently has a
@@ -64,7 +64,11 @@ module Datadog
 
         # NOTE: Please update the Initialization section of ProfilingDevelopment.md with any changes to this method
 
+        no_signals_workaround_enabled = false
+
         if enable_new_profiler?(settings)
+          no_signals_workaround_enabled = no_signals_workaround_enabled?(settings)
+
           recorder = Datadog::Profiling::StackRecorder.new(
             cpu_time_enabled: RUBY_PLATFORM.include?('linux'), # Only supported on Linux currently
             alloc_samples_enabled: false, # Always disabled for now -- work in progress
@@ -76,7 +80,8 @@ module Datadog
             endpoint_collection_enabled: settings.profiling.advanced.endpoint.collection.enabled,
             gc_profiling_enabled: enable_gc_profiling?(settings),
             allocation_counting_enabled: settings.profiling.advanced.allocation_counting_enabled,
-            no_signals_workaround_enabled: no_signals_workaround_enabled?(settings),
+            no_signals_workaround_enabled: no_signals_workaround_enabled,
+            timeline_enabled: settings.profiling.advanced.experimental_timeline_enabled,
           )
         else
           load_pprof_support
@@ -85,7 +90,7 @@ module Datadog
           collector = build_profiler_oldstack_collector(settings, recorder, optional_tracer)
         end
 
-        exporter = build_profiler_exporter(settings, recorder)
+        exporter = build_profiler_exporter(settings, recorder, no_signals_workaround_enabled: no_signals_workaround_enabled)
         transport = build_profiler_transport(settings, agent_settings)
         scheduler = Profiling::Scheduler.new(exporter: exporter, transport: transport)
 
@@ -96,11 +101,15 @@ module Datadog
         Profiling::OldRecorder.new([Profiling::Events::StackSample], settings.profiling.advanced.max_events)
       end
 
-      private_class_method def self.build_profiler_exporter(settings, recorder)
+      private_class_method def self.build_profiler_exporter(settings, recorder, no_signals_workaround_enabled:)
         code_provenance_collector =
           (Profiling::Collectors::CodeProvenance.new if settings.profiling.advanced.code_provenance_enabled)
 
-        Profiling::Exporter.new(pprof_recorder: recorder, code_provenance_collector: code_provenance_collector)
+        Profiling::Exporter.new(
+          pprof_recorder: recorder,
+          code_provenance_collector: code_provenance_collector,
+          no_signals_workaround_enabled: no_signals_workaround_enabled,
+        )
       end
 
       private_class_method def self.build_profiler_oldstack_collector(settings, old_recorder, tracer)
@@ -198,7 +207,7 @@ module Datadog
         if Gem.loaded_specs['mysql2'] && incompatible_libmysqlclient_version?(settings)
           Datadog.logger.warn(
             'Enabling the profiling "no signals" workaround because an incompatible version of the mysql2 gem is ' \
-            'installed. Profiling data will have lower quality.' \
+            'installed. Profiling data will have lower quality. ' \
             'To fix this, upgrade the libmysqlclient in your OS image to version 8.0.0 or above.'
           )
           return true
@@ -214,6 +223,16 @@ module Datadog
           return true
         end
 
+        if defined?(::PhusionPassenger)
+          Datadog.logger.warn(
+            'Enabling the profiling "no signals" workaround because the passenger web server is in use. ' \
+            'This is needed because passenger is currently incompatible with the normal working mode ' \
+            'of the profiler, as detailed in <https://github.com/DataDog/dd-trace-rb/issues/2976>. ' \
+            'Profiling data will have lower quality.'
+          )
+          return true
+        end
+
         false
       end
 
@@ -236,9 +255,22 @@ module Datadog
         begin
           require 'mysql2'
 
-          return true unless defined?(Mysql2::Client) && Mysql2::Client.respond_to?(:info)
-
-          libmysqlclient_version = Gem::Version.new(Mysql2::Client.info[:version])
+          # The mysql2-aurora gem likes to monkey patch itself in replacement of Mysql2::Client, and uses
+          # `method_missing` to delegate to the original BUT unfortunately does not implement `respond_to_missing?` and
+          # thus our `respond_to?(:info)` below was failing.
+          #
+          # But on the bright side, the gem does stash a reference to the original Mysql2::Client class in a constant,
+          # so if that constant exists, we use that for our probing.
+          mysql2_client_class =
+            if defined?(Mysql2::Aurora::ORIGINAL_CLIENT_CLASS)
+              Mysql2::Aurora::ORIGINAL_CLIENT_CLASS
+            elsif defined?(Mysql2::Client)
+              Mysql2::Client
+            end
+
+          return true unless mysql2_client_class && mysql2_client_class.respond_to?(:info)
+
+          libmysqlclient_version = Gem::Version.new(mysql2_client_class.info[:version])
 
           compatible = libmysqlclient_version >= Gem::Version.new('8.0.0')
 

data/lib/datadog/profiling/exporter.rb

@@ -22,13 +22,15 @@ module Datadog
         :minimum_duration_seconds,
         :time_provider,
         :last_flush_finish_at,
-        :created_at
+        :created_at,
+        :no_signals_workaround_enabled
 
       public
 
       def initialize(
         pprof_recorder:,
         code_provenance_collector:,
+        no_signals_workaround_enabled:,
         minimum_duration_seconds: PROFILE_DURATION_THRESHOLD_SECONDS,
         time_provider: Time
       )
@@ -38,6 +40,7 @@ module Datadog
         @time_provider = time_provider
         @last_flush_finish_at = nil
         @created_at = time_provider.now.utc
+        @no_signals_workaround_enabled = no_signals_workaround_enabled
       end
 
       def flush
@@ -61,6 +64,7 @@ module Datadog
           code_provenance_file_name: Datadog::Profiling::Ext::Transport::HTTP::CODE_PROVENANCE_FILENAME,
           code_provenance_data: uncompressed_code_provenance,
           tags_as_array: Datadog::Profiling::TagBuilder.call(settings: Datadog.configuration).to_a,
+          no_signals_workaround_enabled: no_signals_workaround_enabled,
         )
       end
 

data/lib/datadog/profiling/flush.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'json'
+
 module Datadog
   module Profiling
     # Represents a collection of events of a specific type being flushed.
@@ -14,7 +16,8 @@ module Datadog
         :pprof_data, # gzipped pprof bytes
         :code_provenance_file_name,
         :code_provenance_data, # gzipped json bytes
-        :tags_as_array
+        :tags_as_array,
+        :internal_metadata_json
 
       def initialize(
         start:,
@@ -23,7 +26,8 @@ module Datadog
         pprof_data:,
         code_provenance_file_name:,
         code_provenance_data:,
-        tags_as_array:
+        tags_as_array:,
+        no_signals_workaround_enabled:
       )
         @start = start
         @finish = finish
@@ -32,6 +36,9 @@ module Datadog
         @code_provenance_file_name = code_provenance_file_name
         @code_provenance_data = code_provenance_data
         @tags_as_array = tags_as_array
+        @internal_metadata_json = JSON.fast_generate(
+          no_signals_workaround_enabled: (!!no_signals_workaround_enabled).to_s,
+        )
       end
     end
   end

data/lib/datadog/profiling/http_transport.rb

@@ -40,6 +40,7 @@ module Datadog
           code_provenance_data: flush.code_provenance_data,
 
           tags_as_array: flush.tags_as_array,
+          internal_metadata_json: flush.internal_metadata_json,
         )
 
         if status == :ok
@@ -47,11 +48,14 @@ module Datadog
             Datadog.logger.debug('Successfully reported profiling data')
             true
           else
-            Datadog.logger.error("Failed to report profiling data: server returned unexpected HTTP #{result} status code")
+            Datadog.logger.error(
+              "Failed to report profiling data (#{config_without_api_key}): " \
+              "server returned unexpected HTTP #{result} status code"
+            )
             false
           end
         else
-          Datadog.logger.error("Failed to report profiling data: #{result}")
+          Datadog.logger.error("Failed to report profiling data (#{config_without_api_key}): #{result}")
           false
         end
       end
@@ -109,7 +113,8 @@ module Datadog
         pprof_data:,
         code_provenance_file_name:,
         code_provenance_data:,
-        tags_as_array:
+        tags_as_array:,
+        internal_metadata_json:
       )
         self.class._native_do_export(
           exporter_configuration,
@@ -123,8 +128,13 @@ module Datadog
           code_provenance_file_name,
           code_provenance_data,
           tags_as_array,
+          internal_metadata_json,
         )
       end
+
+      def config_without_api_key
+        [@exporter_configuration[0..1]].to_h
+      end
     end
   end
 end

data/lib/datadog/profiling/load_native_extension.rb

@@ -9,7 +9,13 @@
 # All code on this file is on-purpose at the top-level; this makes it so this file is executed only once,
 # the first time it gets required, to avoid any issues with the native extension being initialized more than once.
 
-require "ddtrace_profiling_loader.#{RUBY_VERSION}_#{RUBY_PLATFORM}"
+begin
+  require "ddtrace_profiling_loader.#{RUBY_VERSION}_#{RUBY_PLATFORM}"
+rescue LoadError => e
+  raise LoadError,
+    'Failed to load the profiling loader extension. To fix this, please remove and then reinstall ddtrace ' \
+    "(Details: #{e.message})"
+end
 
 extension_name = "ddtrace_profiling_native_extension.#{RUBY_VERSION}_#{RUBY_PLATFORM}"
 full_file_path = "#{__dir__}/../../#{extension_name}.#{RbConfig::CONFIG['DLEXT']}"

data/lib/datadog/profiling.rb

@@ -66,6 +66,11 @@ module Datadog
       nil
     end
 
+    def self.enabled?
+      profiler = Datadog.send(:components).profiler
+      !!(profiler.scheduler.running? if profiler)
+    end
+
     private_class_method def self.replace_noop_allocation_count
       def self.allocation_count # rubocop:disable Lint/DuplicateMethods, Lint/NestedMethodDefinition (On purpose!)
         Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_allocation_count
@@ -178,6 +183,10 @@ module Datadog
       end
     end
 
+    # All requires for the profiler should be directly added here; and everything should be loaded eagerly.
+    # (Currently there's a few exceptions for the old profiler, but we should avoid other exceptions.)
+    #
+    # All of the profiler should be loaded and ready to go when this method returns `true`.
     private_class_method def self.load_profiling
       return false unless supported?
 
@@ -197,7 +206,8 @@ module Datadog
       require_relative 'profiling/profiler'
       require_relative 'profiling/native_extension'
       require_relative 'profiling/trace_identifiers/helper'
-      # This file is loaded in Profiling::Component#load_pprof_support; see notes there for why
+      # This file is no longer eagerly loaded as a workaround for an issue. It only gets loaded dynamically if the old
+      # profiler is in use. See Profiling::Component#load_pprof_support for more details.
       # require_relative 'profiling/pprof/pprof_pb'
       require_relative 'profiling/tag_builder'
       require_relative 'profiling/http_transport'

data/lib/datadog/tracing/component.rb

@@ -10,6 +10,17 @@ module Datadog
   module Tracing
     # Tracing component
     module Component
+      # Methods that interact with component instance fields.
+      module InstanceMethods
+        # Hot-swaps with a new sampler.
+        # This operation acquires the Components lock to ensure
+        # there is no concurrent modification of the sampler.
+        def reconfigure_live_sampler
+          sampler = self.class.build_sampler(Datadog.configuration)
+          Datadog.send(:safely_synchronize) { tracer.sampler.sampler = sampler }
+        end
+      end
+
       def build_tracer(settings, agent_settings)
         # If a custom tracer has been provided, use it instead.
         # Ignore all other options (they should already be configured.)
@@ -27,13 +38,18 @@ module Datadog
           writer = build_writer(settings, agent_settings)
         end
 
-        subscribe_to_writer_events!(writer, sampler, settings.tracing.test_mode.enabled)
+        # The sampler instance is wrapped in a delegator,
+        # so dynamic instrumentation can hot-swap it.
+        # This prevents full tracer reinitialization on sampling changes.
+        sampler_delegator = SamplerDelegatorComponent.new(sampler)
+
+        subscribe_to_writer_events!(writer, sampler_delegator, settings.tracing.test_mode.enabled)
 
         Tracing::Tracer.new(
           default_service: settings.service,
           enabled: settings.tracing.enabled,
           trace_flush: trace_flush,
-          sampler: sampler,
+          sampler: sampler_delegator,
           span_sampler: build_span_sampler(settings),
           writer: writer,
           tags: build_tracer_tags(settings),
@@ -62,6 +78,23 @@ module Datadog
           else
             ensure_priority_sampling(sampler, settings)
           end
+        elsif (rules = settings.tracing.sampling.rules)
+          post_sampler = Tracing::Sampling::RuleSampler.parse(
+            rules,
+            settings.tracing.sampling.rate_limit,
+            settings.tracing.sampling.default_rate
+          )
+
+          post_sampler ||= # Fallback RuleSampler in case `rules` parsing fails
+            Tracing::Sampling::RuleSampler.new(
+              rate_limit: settings.tracing.sampling.rate_limit,
+              default_sample_rate: settings.tracing.sampling.default_rate
+            )
+
+          Tracing::Sampling::PrioritySampler.new(
+            base_sampler: Tracing::Sampling::AllSampler.new,
+            post_sampler: post_sampler
+          )
         elsif settings.tracing.priority_sampling == false
           Tracing::Sampling::RuleSampler.new(
             rate_limit: settings.tracing.sampling.rate_limit,
@@ -105,13 +138,11 @@ module Datadog
         Tracing::Writer.new(agent_settings: agent_settings, **settings.tracing.writer_options)
       end
 
-      def subscribe_to_writer_events!(writer, sampler, test_mode)
+      def subscribe_to_writer_events!(writer, sampler_delegator, test_mode)
         return unless writer.respond_to?(:events) # Check if it's a custom, external writer
 
         writer.events.after_send.subscribe(&WRITER_RECORD_ENVIRONMENT_INFORMATION_CALLBACK)
 
-        return unless sampler.is_a?(Tracing::Sampling::PrioritySampler)
-
         # DEV: We need to ignore priority sampling updates coming from the agent in test mode
         # because test mode wants to *unconditionally* sample all traces.
         #
@@ -119,7 +150,7 @@ module Datadog
         # here to achieve 100% sampling rate.
         return if test_mode
 
-        writer.events.after_send.subscribe(&writer_update_priority_sampler_rates_callback(sampler))
+        writer.events.after_send.subscribe(&writer_update_priority_sampler_rates_callback(sampler_delegator))
       end
 
       WRITER_RECORD_ENVIRONMENT_INFORMATION_CALLBACK = lambda do |_, responses|
@@ -143,6 +174,27 @@ module Datadog
         Tracing::Sampling::Span::Sampler.new(rules || [])
       end
 
+      # Sampler wrapper component, to allow for hot-swapping
+      # the sampler instance used by the tracer.
+      # Swapping samplers happens during Dynamic Configuration.
+      class SamplerDelegatorComponent
+        attr_accessor :sampler
+
+        def initialize(sampler)
+          @sampler = sampler
+        end
+
+        def sample!(trace)
+          @sampler.sample!(trace)
+        end
+
+        def update(*args, **kwargs)
+          return unless @sampler.respond_to?(:update)
+
+          @sampler.update(*args, **kwargs)
+        end
+      end
+
       private
 
       def build_tracer_tags(settings)

data/lib/datadog/tracing/configuration/dynamic/option.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Configuration
+      module Dynamic
+        # Maps a remote dynamic configuration to a location configuration option.
+        class Option
+          attr_reader :name, :env_var
+
+          # @param name [String] dynamic configuration option name. This must match the remote configuration payload.
+          def initialize(name, env_var)
+            @name = name
+            @env_var = env_var
+          end
+
+          # Reconfigures the provided option, setting its value to `value`.
+          #
+          # @param value [Object,nil] the new value for this option
+          def call(value)
+            raise NotImplementedError
+          end
+        end
+
+        # A dynamic configuration option that can directly mapped to a `Datadog.configuration`
+        # option and changing such option is the only requirement to apply the configuration locally.
+        class SimpleOption < Option
+          # @param name [String] dynamic configuration option name. This must match the remote configuration payload.
+          # @param env_var [String] the canonical environment variable that represents this option.
+          #   This is used for telemetry reporting.
+          # @param setting_key [Symbol] option from `Datadog.configuration.tracing` that will be modified
+          #
+          # DEV: `Datadog.configuration` cannot be an argument default value because
+          # DEV: it is dynamic. Also, it is not yet declared when this method is parsed by Ruby.
+          def initialize(name, env_var, setting_key)
+            super(name, env_var)
+            @setting_key = setting_key
+          end
+
+          # Reconfigures the provided option, setting its value to `value`.
+          #
+          # @param value [Object,nil] the new value for this option
+          def call(value)
+            Datadog.logger.debug { "Reconfigured tracer option `#{@setting_key}` with value `#{value}`" }
+
+            if value.nil?
+              # Restore the local configuration value
+              configuration_object.unset_option(
+                @setting_key,
+                precedence: Core::Configuration::Option::Precedence::REMOTE_CONFIGURATION
+              )
+            else
+              configuration_object.set_option(
+                @setting_key,
+                value,
+                precedence: Core::Configuration::Option::Precedence::REMOTE_CONFIGURATION
+              )
+            end
+          end
+
+          protected
+
+          # The base where `setting_key` will apply
+          def configuration_object
+            Datadog.configuration.tracing
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative 'dynamic/option'
+
+module Datadog
+  module Tracing
+    module Configuration
+      # Tracing Dynamic Configuration,
+      # powered by the Remote Configuration platform.
+      module Dynamic
+        # Dynamic configuration for `DD_LOGS_INJECTION`.
+        class LogInjectionEnabled < SimpleOption
+          def initialize
+            super('log_injection_enabled', 'DD_LOGS_INJECTION', :log_injection)
+          end
+        end
+
+        # Dynamic configuration for `DD_TRACE_HEADER_TAGS`.
+        class TracingHeaderTags < SimpleOption
+          def initialize
+            super('tracing_header_tags', 'DD_TRACE_HEADER_TAGS', :header_tags)
+          end
+
+          def call(tracing_header_tags)
+            # Modify the remote configuration value that it matches the
+            # environment variable it configures.
+            if tracing_header_tags
+              tracing_header_tags.map! do |hash|
+                "#{hash['header']}:#{hash['tag_name']}"
+              end
+            end
+
+            super(tracing_header_tags)
+          end
+        end
+
+        # Dynamic configuration for `DD_TRACE_SAMPLE_RATE`.
+        class TracingSamplingRate < SimpleOption
+          def initialize
+            super('tracing_sampling_rate', 'DD_TRACE_SAMPLE_RATE', :default_rate)
+          end
+
+          # Ensures sampler is rebuilt and new configuration is applied
+          def call(tracing_sampling_rate)
+            super
+            Datadog.send(:components).reconfigure_live_sampler
+          end
+
+          protected
+
+          def configuration_object
+            Datadog.configuration.tracing.sampling
+          end
+        end
+
+        # List of all tracing dynamic configuration options supported.
+        OPTIONS = [LogInjectionEnabled, TracingHeaderTags, TracingSamplingRate].map do |option_class|
+          option = option_class.new
+          [option.name, option.env_var, option]
+        end
+      end
+    end
+  end
+end

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

@@ -1,99 +1,102 @@
+# frozen_string_literal: true
+
 module Datadog
   module Tracing
     module Configuration
       # Constants for configuration settings
       # e.g. Env vars, default values, enums, etc...
       module Ext
-        ENV_ENABLED = 'DD_TRACE_ENABLED'.freeze
-        ENV_TRACE_ID_128_BIT_GENERATION_ENABLED = 'DD_TRACE_128_BIT_TRACEID_GENERATION_ENABLED'.freeze
+        ENV_ENABLED = 'DD_TRACE_ENABLED'
+        ENV_HEADER_TAGS = 'DD_TRACE_HEADER_TAGS'
+        ENV_TRACE_ID_128_BIT_GENERATION_ENABLED = 'DD_TRACE_128_BIT_TRACEID_GENERATION_ENABLED'
 
         # @public_api
         module SpanAttributeSchema
-          ENV_SPAN_ATTRIBUTE_SCHEMA = 'DD_TRACE_SPAN_ATTRIBUTE_SCHEMA'.freeze
-          DEFAULT_VERSION = 'v0'.freeze
-          VERSION_ONE = 'v1'.freeze
+          ENV_GLOBAL_DEFAULT_SERVICE_NAME_ENABLED = 'DD_TRACE_REMOVE_INTEGRATION_SERVICE_NAMES_ENABLED'
+          ENV_PEER_SERVICE_MAPPING = 'DD_TRACE_PEER_SERVICE_MAPPING'
         end
 
         # @public_api
         module Analytics
-          ENV_TRACE_ANALYTICS_ENABLED = 'DD_TRACE_ANALYTICS_ENABLED'.freeze
+          ENV_TRACE_ANALYTICS_ENABLED = 'DD_TRACE_ANALYTICS_ENABLED'
         end
 
         # @public_api
         module Correlation
-          ENV_LOGS_INJECTION_ENABLED = 'DD_LOGS_INJECTION'.freeze
-          ENV_TRACE_ID_128_BIT_LOGGING_ENABLED = 'DD_TRACE_128_BIT_TRACEID_LOGGING_ENABLED'.freeze
+          ENV_LOGS_INJECTION_ENABLED = 'DD_LOGS_INJECTION'
+          ENV_TRACE_ID_128_BIT_LOGGING_ENABLED = 'DD_TRACE_128_BIT_TRACEID_LOGGING_ENABLED'
         end
 
         # @public_api
         module Distributed
           # Custom Datadog format
-          PROPAGATION_STYLE_DATADOG = 'Datadog'.freeze
+          PROPAGATION_STYLE_DATADOG = 'Datadog'
 
-          PROPAGATION_STYLE_B3_MULTI_HEADER = 'b3multi'.freeze
+          PROPAGATION_STYLE_B3_MULTI_HEADER = 'b3multi'
           # @deprecated Use `b3multi` instead.
-          PROPAGATION_STYLE_B3 = 'B3'.freeze
+          PROPAGATION_STYLE_B3 = 'B3'
 
-          PROPAGATION_STYLE_B3_SINGLE_HEADER = 'b3'.freeze
+          PROPAGATION_STYLE_B3_SINGLE_HEADER = 'b3'
           # @deprecated Use `b3` instead.
-          PROPAGATION_STYLE_B3_SINGLE_HEADER_OLD = 'B3 single header'.freeze
+          PROPAGATION_STYLE_B3_SINGLE_HEADER_OLD = 'B3 single header'
 
           # W3C Trace Context
-          PROPAGATION_STYLE_TRACE_CONTEXT = 'tracecontext'.freeze
+          PROPAGATION_STYLE_TRACE_CONTEXT = 'tracecontext'
 
           # Sets both extract and inject propagation style tho the provided value.
           # Has lower precedence than `DD_TRACE_PROPAGATION_STYLE_INJECT` or
           # `DD_TRACE_PROPAGATION_STYLE_EXTRACT`.
-          ENV_PROPAGATION_STYLE = 'DD_TRACE_PROPAGATION_STYLE'.freeze
+          ENV_PROPAGATION_STYLE = 'DD_TRACE_PROPAGATION_STYLE'
 
-          ENV_PROPAGATION_STYLE_INJECT = 'DD_TRACE_PROPAGATION_STYLE_INJECT'.freeze
+          ENV_PROPAGATION_STYLE_INJECT = 'DD_TRACE_PROPAGATION_STYLE_INJECT'
           # @deprecated Use `DD_TRACE_PROPAGATION_STYLE_INJECT` instead.
-          ENV_PROPAGATION_STYLE_INJECT_OLD = 'DD_PROPAGATION_STYLE_INJECT'.freeze
+          ENV_PROPAGATION_STYLE_INJECT_OLD = 'DD_PROPAGATION_STYLE_INJECT'
 
-          ENV_PROPAGATION_STYLE_EXTRACT = 'DD_TRACE_PROPAGATION_STYLE_EXTRACT'.freeze
+          ENV_PROPAGATION_STYLE_EXTRACT = 'DD_TRACE_PROPAGATION_STYLE_EXTRACT'
           # @deprecated Use `DD_TRACE_PROPAGATION_STYLE_EXTRACT` instead.
-          ENV_PROPAGATION_STYLE_EXTRACT_OLD = 'DD_PROPAGATION_STYLE_EXTRACT'.freeze
+          ENV_PROPAGATION_STYLE_EXTRACT_OLD = 'DD_PROPAGATION_STYLE_EXTRACT'
 
           # A no-op propagator. Compatible with OpenTelemetry's `none` propagator.
           # @see https://opentelemetry.io/docs/concepts/sdk-configuration/general-sdk-configuration/#get_otel__propagators
-          PROPAGATION_STYLE_NONE = 'none'.freeze
+          PROPAGATION_STYLE_NONE = 'none'
 
-          ENV_X_DATADOG_TAGS_MAX_LENGTH = 'DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH'.freeze
+          ENV_X_DATADOG_TAGS_MAX_LENGTH = 'DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH'
         end
 
         # @public_api
         module NET
-          ENV_REPORT_HOSTNAME = 'DD_TRACE_REPORT_HOSTNAME'.freeze
+          ENV_REPORT_HOSTNAME = 'DD_TRACE_REPORT_HOSTNAME'
         end
 
         # @public_api
         module Sampling
-          ENV_SAMPLE_RATE = 'DD_TRACE_SAMPLE_RATE'.freeze
-          ENV_RATE_LIMIT = 'DD_TRACE_RATE_LIMIT'.freeze
+          ENV_SAMPLE_RATE = 'DD_TRACE_SAMPLE_RATE'
+          ENV_RATE_LIMIT = 'DD_TRACE_RATE_LIMIT'
+          ENV_RULES = 'DD_TRACE_SAMPLING_RULES'
 
           # @public_api
           module Span
-            ENV_SPAN_SAMPLING_RULES = 'DD_SPAN_SAMPLING_RULES'.freeze
-            ENV_SPAN_SAMPLING_RULES_FILE = 'DD_SPAN_SAMPLING_RULES_FILE'.freeze
+            ENV_SPAN_SAMPLING_RULES = 'DD_SPAN_SAMPLING_RULES'
+            ENV_SPAN_SAMPLING_RULES_FILE = 'DD_SPAN_SAMPLING_RULES_FILE'
           end
         end
 
         # @public_api
         module Test
-          ENV_MODE_ENABLED = 'DD_TRACE_TEST_MODE_ENABLED'.freeze
+          ENV_MODE_ENABLED = 'DD_TRACE_TEST_MODE_ENABLED'
         end
 
         # @public_api
         module Transport
-          ENV_DEFAULT_PORT = 'DD_TRACE_AGENT_PORT'.freeze
-          ENV_DEFAULT_URL = 'DD_TRACE_AGENT_URL'.freeze
+          ENV_DEFAULT_PORT = 'DD_TRACE_AGENT_PORT'
+          ENV_DEFAULT_URL = 'DD_TRACE_AGENT_URL'
         end
 
         # @public_api
         module ClientIp
-          ENV_ENABLED = 'DD_TRACE_CLIENT_IP_ENABLED'.freeze
-          ENV_DISABLED = 'DD_TRACE_CLIENT_IP_HEADER_DISABLED'.freeze # TODO: deprecated, remove later
-          ENV_HEADER_NAME = 'DD_TRACE_CLIENT_IP_HEADER'.freeze
+          ENV_ENABLED = 'DD_TRACE_CLIENT_IP_ENABLED'
+          ENV_DISABLED = 'DD_TRACE_CLIENT_IP_HEADER_DISABLED' # TODO: deprecated, remove later
+          ENV_HEADER_NAME = 'DD_TRACE_CLIENT_IP_HEADER'
         end
       end
     end