ddtrace 1.12.1 → 1.18.0

data/lib/datadog/profiling.rb

@@ -5,22 +5,15 @@ require_relative 'core/utils/only_once'
 module Datadog
   # Datadog Continuous Profiler implementation: https://docs.datadoghq.com/profiler/
   module Profiling
-    GOOGLE_PROTOBUF_MINIMUM_VERSION = Gem::Version.new('3.0')
-    private_constant :GOOGLE_PROTOBUF_MINIMUM_VERSION
-
     def self.supported?
       unsupported_reason.nil?
     end
 
     def self.unsupported_reason
       # NOTE: Only the first matching reason is returned, so try to keep a nice order on reasons -- e.g. tell users
-      # first that they can't use this on JRuby before telling them that they are missing protobuf
+      # first that they can't use this on JRuby before telling them that something else failed
 
-      native_library_compilation_skipped? ||
-        native_library_failed_to_load? ||
-        protobuf_gem_unavailable? ||
-        protobuf_version_unsupported? ||
-        protobuf_failed_to_load?
+      native_library_compilation_skipped? || native_library_failed_to_load?
     end
 
     # Starts the profiler, if the profiler is supported by in
@@ -53,9 +46,7 @@ module Datadog
     #
     # Note 2: All fibers in the same thread will share the same counter values.
     #
-    # Only available when the profiler is running, the new CPU Profiling 2.0 profiler is in use, and allocation-related
-    # features are not disabled via configuration.
-    # For instructions on enabling CPU Profiling 2.0 see the ddtrace release notes.
+    # Only available when the profiler is running, and allocation-related features are not disabled via configuration.
     #
     # @return [Integer] number of allocations observed in the current thread.
     # @return [nil] when not available.
@@ -66,8 +57,14 @@ module Datadog
       nil
     end
 
+    def self.enabled?
+      profiler = Datadog.send(:components).profiler
+      # Use .send(...) to avoid exposing the attr_reader as an API to the outside
+      !!(profiler.send(: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!)
+      def self.allocation_count # rubocop:disable Lint/NestedMethodDefinition (On purpose!)
         Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_allocation_count
       end
     end
@@ -92,66 +89,6 @@ module Datadog
       end
     end
 
-    private_class_method def self.protobuf_gem_unavailable?
-      # NOTE: On environments where protobuf is already loaded, we skip the check. This allows us to support environments
-      # where no Gem.loaded_version is NOT available but customers are able to load protobuf; see for instance
-      # https://github.com/teamcapybara/capybara/commit/caf3bcd7664f4f2691d0ca9ef3be9a2a954fecfb
-      if !protobuf_already_loaded? && Gem.loaded_specs['google-protobuf'].nil?
-        "Missing google-protobuf dependency; please add `gem 'google-protobuf', '~> 3.0'` to your Gemfile or gems.rb file"
-      end
-    end
-
-    private_class_method def self.protobuf_version_unsupported?
-      # See above for why we skip the check when protobuf is already loaded; note that when protobuf was already loaded
-      # we skip the version check to avoid the call to Gem.loaded_specs. Unfortunately, protobuf does not seem to
-      # expose the gem version constant elsewhere, so in that setup we are not able to check the version.
-      if !protobuf_already_loaded? && Gem.loaded_specs['google-protobuf'].version < GOOGLE_PROTOBUF_MINIMUM_VERSION
-        'Your google-protobuf is too old; ensure that you have google-protobuf >= 3.0 by ' \
-        "adding `gem 'google-protobuf', '~> 3.0'` to your Gemfile or gems.rb file"
-      end
-    end
-
-    private_class_method def self.protobuf_already_loaded?
-      defined?(::Google::Protobuf) && !defined?(::Protobuf)
-      !!(defined?(::Google::Protobuf) && !defined?(::Protobuf))
-    end
-
-    private_class_method def self.protobuf_failed_to_load?
-      unless protobuf_loaded_successfully?
-        'There was an error loading the google-protobuf library; see previous warning message for details'
-      end
-    end
-
-    # The `google-protobuf` gem depends on a native component, and its creators helpfully tried to provide precompiled
-    # versions of this extension on rubygems.org.
-    #
-    # Unfortunately, for a long time, the supported Ruby versions metadata on these precompiled versions of the extension
-    # was not correctly set. (This is fixed in newer versions -- but not all Ruby versions we want to support can use
-    # these.)
-    #
-    # Thus, the gem can still be installed, but can be in a broken state. To avoid breaking customer applications, we
-    # use this helper to load it and gracefully handle failures.
-    private_class_method def self.protobuf_loaded_successfully?
-      return @protobuf_loaded if defined?(@protobuf_loaded)
-
-      begin
-        require 'google/protobuf'
-        @protobuf_loaded = true
-      rescue LoadError => e
-        # NOTE: We use Kernel#warn here because this code gets run BEFORE Datadog.logger is actually set up.
-        # In the future it'd be nice to shuffle the logger startup to happen first to avoid this special case.
-        Kernel.warn(
-          '[ddtrace] Error while loading google-protobuf gem. ' \
-          "Cause: '#{e.class.name} #{e.message}' Location: '#{Array(e.backtrace).first}'. " \
-          'This can happen when google-protobuf is missing its native components. ' \
-          'To fix this, try removing and reinstalling the gem, forcing it to recompile the components: ' \
-          '`gem uninstall google-protobuf -a; BUNDLE_FORCE_RUBY_PLATFORM=true bundle install`. ' \
-          'If the error persists, please contact Datadog support at <https://docs.datadoghq.com/help/>.'
-        )
-        @protobuf_loaded = false
-      end
-    end
-
     private_class_method def self.native_library_failed_to_load?
       success, exception = try_loading_native_library
 
@@ -178,6 +115,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 leftovers that need to be cleaned up, 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?
 
@@ -186,19 +127,16 @@ module Datadog
       require_relative 'profiling/collectors/cpu_and_wall_time_worker'
       require_relative 'profiling/collectors/dynamic_sampling_rate'
       require_relative 'profiling/collectors/idle_sampling_helper'
-      require_relative 'profiling/collectors/old_stack'
       require_relative 'profiling/collectors/stack'
       require_relative 'profiling/collectors/thread_context'
+      require_relative 'profiling/diagnostics/environment_logger'
       require_relative 'profiling/stack_recorder'
-      require_relative 'profiling/old_recorder'
       require_relative 'profiling/exporter'
+      require_relative 'profiling/flush'
       require_relative 'profiling/scheduler'
       require_relative 'profiling/tasks/setup'
       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
-      # require_relative 'profiling/pprof/pprof_pb'
       require_relative 'profiling/tag_builder'
       require_relative 'profiling/http_transport'
 

data/lib/datadog/tracing/component.rb

@@ -1,21 +1,36 @@
 # frozen_string_literal: true
 
 require_relative 'tracer'
+require_relative 'configuration/agent_settings_resolver'
 require_relative 'flush'
 require_relative 'sync_writer'
 require_relative 'sampling/span/rule_parser'
 require_relative 'sampling/span/sampler'
+require_relative 'diagnostics/environment_logger'
 
 module Datadog
   module Tracing
     # Tracing component
     module Component
-      def build_tracer(settings, agent_settings)
+      # 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, logger:)
         # If a custom tracer has been provided, use it instead.
         # Ignore all other options (they should already be configured.)
         tracer = settings.tracing.instance
         return tracer unless tracer.nil?
 
+        agent_settings = Configuration::AgentSettingsResolver.call(settings, logger: logger)
+
         # Apply test mode settings if test mode is activated
         if settings.tracing.test_mode.enabled
           trace_flush = build_test_mode_trace_flush(settings)
@@ -27,13 +42,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 +82,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,
@@ -97,21 +134,19 @@ module Datadog
       # process, but can take a variety of options (including
       # a fully custom instance) that makes the Tracer
       # initialization process complex.
-      def build_writer(settings, agent_settings)
+      def build_writer(settings, agent_settings, options = settings.tracing.writer_options)
         if (writer = settings.tracing.writer)
           return writer
         end
 
-        Tracing::Writer.new(agent_settings: agent_settings, **settings.tracing.writer_options)
+        Tracing::Writer.new(agent_settings: agent_settings, **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,11 +154,11 @@ 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|
-        Core::Diagnostics::EnvironmentLogger.log!(responses)
+        Tracing::Diagnostics::EnvironmentLogger.collect_and_log!(responses: responses)
       end
 
       # Create new lambda for writer callback,
@@ -143,6 +178,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)
@@ -167,8 +223,11 @@ module Datadog
       end
 
       def build_test_mode_writer(settings, agent_settings)
-        # Flush traces synchronously, to guarantee they are written.
         writer_options = settings.tracing.test_mode.writer_options || {}
+
+        return build_writer(settings, agent_settings, writer_options) if settings.tracing.test_mode.async
+
+        # Flush traces synchronously, to guarantee they are written.
         Tracing::SyncWriter.new(agent_settings: agent_settings, **writer_options)
       end
     end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative '../../core/configuration/agent_settings_resolver'
+
+module Datadog
+  module Tracing
+    module Configuration
+      # This class encapsulates any tracing specific agent settings
+      class AgentSettingsResolver < Datadog::Core::Configuration::AgentSettingsResolver
+      end
+    end
+  end
+end

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,107 @@
+# frozen_string_literal: true
+
+require_relative '../../core/configuration/ext'
+
 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'
+
+          # Strictly stop at the first successfully serialized style.
+          EXTRACT_FIRST = 'DD_TRACE_PROPAGATION_EXTRACT_FIRST'
 
-          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 = Datadog::Core::Configuration::Ext::Agent::ENV_DEFAULT_PORT
+          ENV_DEFAULT_URL = Datadog::Core::Configuration::Ext::Agent::ENV_DEFAULT_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

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Configuration
+      module HTTP
+        # Datadog tracing supports capturing HTTP request and response headers as span tags.
+        #
+        # The provided configuration String for this feature has to be pre-processed to
+        # allow for ease of utilization by each HTTP integration.
+        #
+        # This class process configuration, stores the result, and provides methods to
+        # utilize this configuration.
+        class HeaderTags
+          # @param header_tags [Array<String>] The list of strings from DD_TRACE_HEADER_TAGS.
+          def initialize(header_tags)
+            @request_headers = {}
+            @response_headers = {}
+            @header_tags = header_tags
+
+            @header_tags.each do |header_tag|
+              header, tag = header_tag.split(':', 2)
+
+              next unless header # Empty string guard
+
+              if tag && !tag.empty?
+                # When a custom tag name is provided, use that name for both
+                # request and response tags.
+                normalized_tag = Tracing::Metadata::Ext::HTTP::Headers.to_tag(tag, allow_nested: true)
+                request = response = normalized_tag
+              else
+                # Otherwise, use our internal pattern of
+                # "http.{request|response}.headers.{header}" as tag name.
+                request = Tracing::Metadata::Ext::HTTP::RequestHeaders.to_tag(header)
+                response = Tracing::Metadata::Ext::HTTP::ResponseHeaders.to_tag(header)
+              end
+
+              @request_headers[header] = request
+              @response_headers[header] = response
+            end
+          end
+
+          # Receives a case insensitive hash with the request headers and returns
+          # a list of tag names and values that can be set in a span.
+          def request_tags(headers)
+            @request_headers.map do |header_name, span_tag|
+              # Case-insensitive search
+              header_value = headers[header_name]
+
+              [span_tag, header_value] if header_value
+            end.compact
+          end
+
+          # Receives a case insensitive hash with the response headers and returns
+          # a list of tag names and values that can be set in a span.
+          def response_tags(headers)
+            @response_headers.map do |header_name, span_tag|
+              # Case-insensitive search
+              header_value = headers[header_name]
+
+              [span_tag, header_value] if header_value
+            end.compact
+          end
+
+          # For easy configuration inspection,
+          # print the original configuration setting.
+          def to_s
+            @header_tags.join(',').to_s
+          end
+        end
+      end
+    end
+  end
+end