cw-datadog 2.23.0.2

data/lib/datadog/tracing/buffer.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require_relative '../core/environment/ext'
+require_relative '../core/buffer/thread_safe'
+require_relative '../core/buffer/cruby'
+require_relative '../core/diagnostics/health'
+
+module Datadog
+  module Tracing
+    # Health metrics for trace buffers.
+    module MeasuredBuffer
+      def initialize(*_)
+        super
+
+        @buffer_accepted = 0
+        @buffer_accepted_lengths = 0
+        @buffer_dropped = 0
+        @buffer_spans = 0
+      end
+
+      def add!(trace)
+        super
+
+        # Emit health metrics
+        measure_accept(trace)
+      end
+
+      def add_all!(traces)
+        super
+
+        # Emit health metrics
+        traces.each { |trace| measure_accept(trace) }
+      end
+
+      def replace!(trace)
+        discarded_trace = super
+
+        # Emit health metrics
+        measure_accept(trace)
+        measure_drop(discarded_trace) if discarded_trace
+
+        discarded_trace
+      end
+
+      # Stored traces are returned and the local buffer is reset.
+      def drain!
+        traces = super
+        measure_pop(traces)
+        traces
+      end
+
+      def measure_accept(trace)
+        @buffer_accepted += 1
+        @buffer_accepted_lengths += trace.length
+
+        @buffer_spans += trace.length
+      rescue => e
+        Datadog.logger.debug(
+          "Failed to measure queue accept. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+        )
+      end
+
+      def measure_drop(trace)
+        @buffer_dropped += 1
+
+        @buffer_spans -= trace.length
+      rescue => e
+        Datadog.logger.debug(
+          "Failed to measure queue drop. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+        )
+      end
+
+      def measure_pop(traces)
+        # Accepted, cumulative totals
+        Datadog.health_metrics.queue_accepted(@buffer_accepted)
+        Datadog.health_metrics.queue_accepted_lengths(@buffer_accepted_lengths)
+
+        # Dropped, cumulative totals
+        Datadog.health_metrics.queue_dropped(@buffer_dropped)
+        # TODO: are we missing a +queue_dropped_lengths+ metric?
+
+        # Queue gauges, current values
+        Datadog.health_metrics.queue_max_length(@max_size)
+        Datadog.health_metrics.queue_spans(@buffer_spans)
+        Datadog.health_metrics.queue_length(traces.length)
+
+        # Reset aggregated metrics
+        @buffer_accepted = 0
+        @buffer_accepted_lengths = 0
+        @buffer_dropped = 0
+        @buffer_spans = 0
+      rescue => e
+        Datadog.logger.debug(
+          "Failed to measure queue. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+        )
+      end
+    end
+
+    # Trace buffer that stores application traces, has a maximum size, and
+    # can be safely used concurrently on any environment.
+    #
+    # @see Datadog::Core::Buffer::ThreadSafe
+    class ThreadSafeTraceBuffer < Core::Buffer::ThreadSafe
+      prepend MeasuredBuffer
+    end
+
+    # Trace buffer that stores application traces, has a maximum size, and
+    # can be safely used concurrently with CRuby.
+    #
+    # @see Datadog::Core::Buffer::CRuby
+    class CRubyTraceBuffer < Core::Buffer::CRuby
+      prepend MeasuredBuffer
+    end
+
+    # Trace buffer that stores application traces. The buffer has a maximum size and when
+    # the buffer is full, a random trace is discarded. This class is thread-safe and is used
+    # automatically by the ``Tracer`` instance when a ``Span`` is finished.
+    #
+    # We choose the default TraceBuffer implementation for current platform dynamically here.
+    #
+    # TODO We should restructure this module, so that classes are not declared at top-level ::Datadog.
+    # TODO Making such a change is potentially breaking for users manually configuring the tracer.
+    TraceBuffer = if Core::Environment::Ext::RUBY_ENGINE == 'ruby'
+      CRubyTraceBuffer
+    else
+      ThreadSafeTraceBuffer
+    end
+  end
+end

data/lib/datadog/tracing/client_ip.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative '../core/configuration'
+require_relative '../core/utils/network'
+require_relative 'metadata/ext'
+require_relative 'span'
+
+module Datadog
+  module Tracing
+    # Common functions for supporting the `http.client_ip` span attribute.
+    module ClientIp
+      class << self
+        # Sets the `http.client_ip` tag on the given span.
+        #
+        # This function respects the user's settings: if they disable the client IP tagging,
+        #   or provide a different IP header name.
+        #
+        # @param [Span] span The span that's associated with the request.
+        # @param [HeaderCollection, #get, nil] headers A collection with the request headers.
+        # @param [String, nil] remote_ip The remote IP the request associated with the span is sent to.
+        def set_client_ip_tag(span, headers: nil, remote_ip: nil)
+          return unless configuration.enabled
+
+          set_client_ip_tag!(span, headers: headers, remote_ip: remote_ip)
+        end
+
+        # Forcefully sets the `http.client_ip` tag on the given span.
+        #
+        # This function ignores the user's `enabled` setting.
+        #
+        # @param [Span] span The span that's associated with the request.
+        # @param [HeaderCollection, #get, nil] headers A collection with the request headers.
+        # @param [String, nil] remote_ip The remote IP the request associated with the span is sent to.
+        def set_client_ip_tag!(span, headers: nil, remote_ip: nil)
+          ip = extract_client_ip(headers, remote_ip)
+
+          span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_CLIENT_IP, ip) if ip
+        end
+
+        def extract_client_ip(headers, remote_ip)
+          if headers && configuration.header_name
+            return Datadog::Core::Utils::Network.stripped_ip_from_request_headers(
+              headers,
+              ip_headers_to_check: Array(configuration.header_name)
+            )
+          end
+
+          ip_from_headers = Datadog::Core::Utils::Network.stripped_ip_from_request_headers(headers) if headers
+
+          ip_from_headers || Datadog::Core::Utils::Network.stripped_ip(remote_ip)
+        end
+
+        private
+
+        def configuration
+          Datadog.configuration.tracing.client_ip
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/component.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require_relative 'tracer'
+require_relative 'flush'
+require_relative 'sync_writer'
+require_relative 'sampling/span/rule_parser'
+require_relative 'sampling/span/sampler'
+require_relative 'diagnostics/environment_logger'
+require_relative 'contrib/component'
+
+module Datadog
+  module Tracing
+    # Tracing component
+    module Component
+      module_function
+
+      def build_tracer(settings, agent_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?
+
+        # 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
+
+        # 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,
+          logger: logger,
+          trace_flush: trace_flush,
+          sampler: sampler_delegator,
+          span_sampler: build_span_sampler(settings),
+          writer: writer,
+          tags: build_tracer_tags(settings),
+        )
+      end
+
+      def build_trace_flush(settings)
+        if settings.tracing.partial_flush.enabled
+          Tracing::Flush::Partial.new(
+            min_spans_before_partial_flush: settings.tracing.partial_flush.min_spans_threshold
+          )
+        else
+          Tracing::Flush::Finished.new
+        end
+      end
+
+      def build_sampler(settings)
+        # A custom sampler is provided
+        if (sampler = settings.tracing.sampler)
+          return sampler
+        end
+
+        # APM Disablement means that we don't want to send traces that only contains APM data.
+        # Other products can then put the sampling priority to MANUAL_KEEP if they want to keep traces.
+        # (e.g.: AppSec will MANUAL_KEEP traces with AppSec events) and clients will be billed only for those traces.
+        # But to keep the service alive on the backend side, we need to send one trace per minute.
+        post_sampler = build_rate_limit_post_sampler(seconds: 60) unless settings.apm.tracing.enabled
+
+        # Sampling rules are provided
+        if (rules = settings.tracing.sampling.rules)
+          post_sampler = Tracing::Sampling::RuleSampler.parse(
+            rules,
+            settings.tracing.sampling.rate_limit,
+            settings.tracing.sampling.default_rate
+          )
+        end
+
+        # The default sampler.
+        # Used if no custom sampler is provided, or if sampling rule parsing fails.
+        post_sampler ||= 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
+        )
+      end
+
+      # TODO: Writer should be a top-level component.
+      # It is currently part of the Tracer initialization
+      # 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, options = settings.tracing.writer_options)
+        if (writer = settings.tracing.writer)
+          return writer
+        end
+
+        Tracing::Writer.new(agent_settings: agent_settings, **options)
+      end
+
+      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)
+
+        # DEV: We need to ignore priority sampling updates coming from the agent in test mode
+        # because test mode wants to *unconditionally* sample all traces.
+        #
+        # This can cause trace metrics to be overestimated, but that's a trade-off we take
+        # here to achieve 100% sampling rate.
+        return if test_mode
+
+        writer.events.after_send.subscribe(&writer_update_priority_sampler_rates_callback(sampler_delegator))
+      end
+
+      WRITER_RECORD_ENVIRONMENT_INFORMATION_CALLBACK = lambda do |_, responses|
+        WRITER_RECORD_ENVIRONMENT_INFORMATION_ONLY_ONCE.run do
+          Tracing::Diagnostics::EnvironmentLogger.collect_and_log!(responses: responses)
+        end
+      end
+
+      WRITER_RECORD_ENVIRONMENT_INFORMATION_ONLY_ONCE = Core::Utils::OnlyOnce.new
+
+      # Create new lambda for writer callback,
+      # capture the current sampler in the callback closure.
+      def writer_update_priority_sampler_rates_callback(sampler)
+        lambda do |_, responses|
+          response = responses.last
+
+          next unless response && !response.internal_error? && response.service_rates
+
+          sampler.update(response.service_rates, decision: Tracing::Sampling::Ext::Decision::AGENT_RATE)
+        end
+      end
+
+      def build_span_sampler(settings)
+        rules = Tracing::Sampling::Span::RuleParser.parse_json(settings.tracing.sampling.span_rules)
+        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
+
+      # @api private
+      def build_tracer_tags(settings)
+        settings.tags.dup.tap do |tags|
+          tags[Core::Environment::Ext::TAG_ENV] = settings.env unless settings.env.nil?
+          tags[Core::Environment::Ext::TAG_VERSION] = settings.version unless settings.version.nil?
+        end
+      end
+
+      # Build a post-sampler that limits the rate of traces to one per `seconds`.
+      # E.g.: `build_rate_limit_post_sampler(seconds: 60)` will limit the rate to one trace per minute.
+      # @api private
+      def build_rate_limit_post_sampler(seconds:)
+        Tracing::Sampling::RuleSampler.new(
+          rate_limiter: Datadog::Core::TokenBucket.new(1.0 / seconds, 1.0),
+          default_sample_rate: 1.0
+        )
+      end
+
+      # @api private
+      def build_test_mode_trace_flush(settings)
+        # If context flush behavior is provided, use it instead.
+        settings.tracing.test_mode.trace_flush || build_trace_flush(settings)
+      end
+
+      # @api private
+      def build_test_mode_sampler
+        # Do not sample any spans for tests; all must be preserved.
+        # Set priority sampler to ensure the agent doesn't drop any traces.
+        Tracing::Sampling::PrioritySampler.new(
+          base_sampler: Tracing::Sampling::AllSampler.new,
+          post_sampler: Tracing::Sampling::AllSampler.new
+        )
+      end
+
+      # @api private
+      def build_test_mode_writer(settings, agent_settings)
+        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
+  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,100 @@
+# 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.
+            tracing_header_tags&.map! do |hash|
+              "#{hash["header"]}:#{hash["tag_name"]}"
+            end
+
+            super
+          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_sampler
+          end
+
+          protected
+
+          def configuration_object
+            Datadog.configuration.tracing.sampling
+          end
+        end
+
+        # Dynamic configuration for `DD_TRACE_SAMPLING_RULES`.
+        class TracingSamplingRules < SimpleOption
+          def initialize
+            super('tracing_sampling_rules', 'DD_TRACE_SAMPLING_RULES', :rules)
+          end
+
+          # Ensures sampler is rebuilt and new configuration is applied
+          def call(tracing_sampling_rules)
+            # Modify the remote configuration value that it matches the
+            # local environment variable it configures.
+            if tracing_sampling_rules
+              tracing_sampling_rules.each do |rule|
+                next unless (tags = rule['tags'])
+
+                # Tag maps come in as arrays of 'key' and `value_glob`.
+                # We need to convert them into a hash for local use.
+                tag_array = tags.map! do |tag|
+                  [tag['key'], tag['value_glob']]
+                end
+
+                rule['tags'] = tag_array.to_h
+              end
+
+              # The configuration is stored as JSON, so we need to convert it back
+              tracing_sampling_rules = tracing_sampling_rules.to_json
+            end
+
+            super
+            Datadog.send(:components).reconfigure_sampler
+          end
+
+          protected
+
+          def configuration_object
+            Datadog.configuration.tracing.sampling
+          end
+        end
+
+        # List of all tracing dynamic configuration options supported.
+        OPTIONS = [LogInjectionEnabled, TracingHeaderTags, TracingSamplingRate, TracingSamplingRules].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

@@ -0,0 +1,118 @@
+# 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'
+        ENV_HEADER_TAGS = 'DD_TRACE_HEADER_TAGS'
+        ENV_BAGGAGE_TAG_KEYS = 'DD_TRACE_BAGGAGE_TAG_KEYS'
+        ENV_TRACE_ID_128_BIT_GENERATION_ENABLED = 'DD_TRACE_128_BIT_TRACEID_GENERATION_ENABLED'
+        ENV_NATIVE_SPAN_EVENTS = 'DD_TRACE_NATIVE_SPAN_EVENTS'
+        ENV_RESOURCE_RENAMING_ENABLED = 'DD_TRACE_RESOURCE_RENAMING_ENABLED'
+        ENV_RESOURCE_RENAMING_ALWAYS_SIMPLIFIED_ENDPOINT = 'DD_TRACE_RESOURCE_RENAMING_ALWAYS_SIMPLIFIED_ENDPOINT'
+
+        # @public_api
+        module SpanAttributeSchema
+          ENV_GLOBAL_DEFAULT_SERVICE_NAME_ENABLED = 'DD_TRACE_REMOVE_INTEGRATION_SERVICE_NAMES_ENABLED'
+          ENV_PEER_SERVICE_DEFAULTS_ENABLED = 'DD_TRACE_PEER_SERVICE_DEFAULTS_ENABLED'
+          ENV_PEER_SERVICE_MAPPING = 'DD_TRACE_PEER_SERVICE_MAPPING'
+        end
+
+        module Analytics
+          ENV_TRACE_ANALYTICS_ENABLED = 'DD_TRACE_ANALYTICS_ENABLED'
+        end
+
+        # @public_api
+        module Correlation
+          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'
+
+          PROPAGATION_STYLE_B3_MULTI_HEADER = 'b3multi'
+          PROPAGATION_STYLE_B3_SINGLE_HEADER = 'b3'
+
+          # W3C Trace Context
+          PROPAGATION_STYLE_TRACE_CONTEXT = 'tracecontext'
+
+          # W3C Baggage
+          # @see https://www.w3.org/TR/baggage/
+          PROPAGATION_STYLE_BAGGAGE = 'baggage'
+
+          PROPAGATION_STYLE_SUPPORTED = [PROPAGATION_STYLE_DATADOG, PROPAGATION_STYLE_B3_MULTI_HEADER,
+            PROPAGATION_STYLE_B3_SINGLE_HEADER, PROPAGATION_STYLE_TRACE_CONTEXT,
+            PROPAGATION_STYLE_BAGGAGE].freeze
+
+          # 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'
+
+          ENV_PROPAGATION_STYLE_INJECT = 'DD_TRACE_PROPAGATION_STYLE_INJECT'
+
+          ENV_PROPAGATION_STYLE_EXTRACT = 'DD_TRACE_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'
+
+          # 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'
+        end
+
+        # @public_api
+        module NET
+          ENV_REPORT_HOSTNAME = 'DD_TRACE_REPORT_HOSTNAME'
+        end
+
+        # @public_api
+        module Sampling
+          ENV_SAMPLE_RATE = 'DD_TRACE_SAMPLE_RATE'
+          ENV_RATE_LIMIT = 'DD_TRACE_RATE_LIMIT'
+          ENV_RULES = 'DD_TRACE_SAMPLING_RULES'
+          OTEL_TRACES_SAMPLER_ARG = 'OTEL_TRACES_SAMPLER_ARG'
+
+          # @public_api
+          module Span
+            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'
+        end
+
+        # @public_api
+        module Transport
+          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'
+          ENV_HEADER_NAME = 'DD_TRACE_CLIENT_IP_HEADER'
+        end
+
+        # @public_api
+        module HTTPErrorStatuses
+          ENV_SERVER_ERROR_STATUSES = 'DD_TRACE_HTTP_SERVER_ERROR_STATUSES'
+          ENV_CLIENT_ERROR_STATUSES = 'DD_TRACE_HTTP_CLIENT_ERROR_STATUSES'
+        end
+      end
+    end
+  end
+end