ddtrace 1.0.0 → 1.9.0

data/lib/datadog/tracing/client_ip.rb

@@ -0,0 +1,164 @@
+# typed: true
+
+require_relative '../core/configuration'
+require_relative 'metadata/ext'
+require_relative 'span'
+
+require 'ipaddr'
+
+module Datadog
+  module Tracing
+    # Common functions for supporting the `http.client_ip` span attribute.
+    module ClientIp
+      DEFAULT_IP_HEADERS_NAMES = %w[
+        x-forwarded-for
+        x-real-ip
+        x-client-ip
+        x-forwarded
+        x-cluster-client-ip
+        forwarded-for
+        forwarded
+        via
+        true-client-ip
+      ].freeze
+
+      TAG_MULTIPLE_IP_HEADERS = '_dd.multiple-ip-headers'.freeze
+
+      # 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.
+      #
+      # If multiple IP headers are present in the request, this function will instead set
+      #   the `_dd.multiple-ip-headers` tag with the names of the present headers,
+      #   and **NOT** set the `http.client_ip` tag.
+      #
+      # @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 self.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 self.set_client_ip_tag!(span, headers: nil, remote_ip: nil)
+        result = raw_ip_from_request(headers, remote_ip)
+
+        if result.raw_ip
+          ip = strip_decorations(result.raw_ip)
+          return unless valid_ip?(ip)
+
+          span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_CLIENT_IP, ip)
+        elsif result.multiple_ip_headers
+          span.set_tag(TAG_MULTIPLE_IP_HEADERS, result.multiple_ip_headers.keys.join(','))
+        end
+      end
+
+      IpExtractionResult = Struct.new(:raw_ip, :multiple_ip_headers)
+
+      # Returns a result struct that holds the raw client IP associated with the request if it was
+      #   retrieved successfully.
+      #
+      # The client IP is looked up by the following logic:
+      # * If the user has configured a header name, return that header's value.
+      # * If exactly one of the known IP headers is present, return that header's value.
+      # * If none of the known IP headers are present, return the remote IP from the request.
+      #
+      # If more than one of the known IP headers is present, the result will have a `multiple_ip_headers`
+      #   field with the name of the present IP headers.
+      #
+      # @param [Datadog::Core::HeaderCollection, #get, nil] headers The request headers
+      # @param [String] remote_ip The remote IP of the request.
+      # @return [IpExtractionResult] A struct that holds the unprocessed IP value,
+      #   or `nil` if it wasn't found. Additionally, the `multiple_ip_headers` fields will hold the
+      #   name of known IP headers present in the request if more than one of these were found.
+      def self.raw_ip_from_request(headers, remote_ip)
+        return IpExtractionResult.new(headers && headers.get(configuration.header_name), nil) if configuration.header_name
+
+        headers_present = ip_headers(headers)
+
+        case headers_present.size
+        when 0
+          IpExtractionResult.new(remote_ip, nil)
+        when 1
+          IpExtractionResult.new(headers_present.values.first, nil)
+        else
+          IpExtractionResult.new(nil, headers_present)
+        end
+      end
+
+      # Removes any port notations or zone specifiers from the IP address without
+      #   verifying its validity.
+      def self.strip_decorations(address)
+        return strip_ipv4_port(address) if likely_ipv4?(address)
+
+        address = strip_ipv6_port(address)
+
+        strip_zone_specifier(address)
+      end
+
+      def self.strip_zone_specifier(ipv6)
+        ipv6.gsub(/%.*/, '')
+      end
+
+      def self.strip_ipv4_port(ip)
+        ip.gsub(/:\d+\z/, '')
+      end
+
+      def self.strip_ipv6_port(ip)
+        if /\[(.*)\](?::\d+)?/ =~ ip
+          Regexp.last_match(1)
+        else
+          ip
+        end
+      end
+
+      # Returns whether the given value is more likely to be an IPv4 than an IPv6 address.
+      #
+      # This is done by checking if a dot (`'.'`) character appears before a colon (`':'`) in the value.
+      # The rationale is that in valid IPv6 addresses, colons will always preced dots,
+      #   and in valid IPv4 addresses dots will always preced colons.
+      def self.likely_ipv4?(value)
+        dot_index = value.index('.') || value.size
+        colon_index = value.index(':') || value.size
+
+        dot_index < colon_index
+      end
+
+      # Determines whether the given string is a valid IPv4 or IPv6 address.
+      def self.valid_ip?(ip)
+        # Client IPs should not have subnet masks even though IPAddr can parse them.
+        return false if ip.include?('/')
+
+        begin
+          IPAddr.new(ip)
+
+          true
+        rescue IPAddr::Error
+          false
+        end
+      end
+
+      def self.ip_headers(headers)
+        return {} unless headers
+
+        DEFAULT_IP_HEADERS_NAMES.each_with_object({}) do |name, result|
+          value = headers.get(name)
+          result[name] = value unless value.nil?
+        end
+      end
+
+      def self.configuration
+        Datadog.configuration.tracing.client_ip
+      end
+    end
+  end
+end

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

@@ -3,7 +3,11 @@
 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
+
         # @public_api
         module Analytics
           ENV_TRACE_ANALYTICS_ENABLED = 'DD_TRACE_ANALYTICS_ENABLED'.freeze
@@ -16,11 +20,38 @@ module Datadog
 
         # @public_api
         module Distributed
+          # Custom Datadog format
           PROPAGATION_STYLE_DATADOG = 'Datadog'.freeze
+
+          PROPAGATION_STYLE_B3_MULTI_HEADER = 'b3multi'.freeze
+          # @deprecated Use `b3multi` instead.
           PROPAGATION_STYLE_B3 = 'B3'.freeze
-          PROPAGATION_STYLE_B3_SINGLE_HEADER = 'B3 single header'.freeze
-          ENV_PROPAGATION_STYLE_INJECT = 'DD_PROPAGATION_STYLE_INJECT'.freeze
-          ENV_PROPAGATION_STYLE_EXTRACT = 'DD_PROPAGATION_STYLE_EXTRACT'.freeze
+
+          PROPAGATION_STYLE_B3_SINGLE_HEADER = 'b3'.freeze
+          # @deprecated Use `b3` instead.
+          PROPAGATION_STYLE_B3_SINGLE_HEADER_OLD = 'B3 single header'.freeze
+
+          # W3C Trace Context
+          PROPAGATION_STYLE_TRACE_CONTEXT = 'tracecontext'.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'.freeze
+
+          ENV_PROPAGATION_STYLE_INJECT = 'DD_TRACE_PROPAGATION_STYLE_INJECT'.freeze
+          # @deprecated Use `DD_TRACE_PROPAGATION_STYLE_INJECT` instead.
+          ENV_PROPAGATION_STYLE_INJECT_OLD = 'DD_PROPAGATION_STYLE_INJECT'.freeze
+
+          ENV_PROPAGATION_STYLE_EXTRACT = 'DD_TRACE_PROPAGATION_STYLE_EXTRACT'.freeze
+          # @deprecated Use `DD_TRACE_PROPAGATION_STYLE_EXTRACT` instead.
+          ENV_PROPAGATION_STYLE_EXTRACT_OLD = 'DD_PROPAGATION_STYLE_EXTRACT'.freeze
+
+          # 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
+
+          ENV_X_DATADOG_TAGS_MAX_LENGTH = 'DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH'.freeze
         end
 
         # @public_api
@@ -32,6 +63,12 @@ module Datadog
         module Sampling
           ENV_SAMPLE_RATE = 'DD_TRACE_SAMPLE_RATE'.freeze
           ENV_RATE_LIMIT = 'DD_TRACE_RATE_LIMIT'.freeze
+
+          # @public_api
+          module Span
+            ENV_SPAN_SAMPLING_RULES = 'DD_SPAN_SAMPLING_RULES'.freeze
+            ENV_SPAN_SAMPLING_RULES_FILE = 'DD_SPAN_SAMPLING_RULES_FILE'.freeze
+          end
         end
 
         # @public_api
@@ -41,10 +78,16 @@ module Datadog
 
         # @public_api
         module Transport
-          ENV_DEFAULT_HOST = 'DD_AGENT_HOST'.freeze
           ENV_DEFAULT_PORT = 'DD_TRACE_AGENT_PORT'.freeze
           ENV_DEFAULT_URL = 'DD_TRACE_AGENT_URL'.freeze
         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
+        end
       end
     end
   end

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

@@ -0,0 +1,433 @@
+# typed: false
+
+require_relative '../../tracing/configuration/ext'
+
+module Datadog
+  module Tracing
+    module Configuration
+      # Configuration settings for tracing.
+      # @public_api
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/BlockLength
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Layout/LineLength
+      module Settings
+        def self.extended(base)
+          base.class_eval do
+            # Tracer specific configurations.
+            # @public_api
+            settings :tracing do
+              # Legacy [App Analytics](https://docs.datadoghq.com/tracing/legacy_app_analytics/) configuration.
+              #
+              # @configure_with {Datadog::Tracing}
+              # @deprecated Use [Trace Retention and Ingestion](https://docs.datadoghq.com/tracing/trace_retention_and_ingestion/)
+              #   controls.
+              # @public_api
+              settings :analytics do
+                # @default `DD_TRACE_ANALYTICS_ENABLED` environment variable, otherwise `nil`
+                # @return [Boolean,nil]
+                option :enabled do |o|
+                  o.default { env_to_bool(Tracing::Configuration::Ext::Analytics::ENV_TRACE_ANALYTICS_ENABLED, nil) }
+                  o.lazy
+                end
+              end
+
+              # [Distributed Tracing](https://docs.datadoghq.com/tracing/setup_overview/setup/ruby/#distributed-tracing) propagation
+              # style configuration.
+              #
+              # The supported formats are:
+              # * `Datadog`: Datadog propagation format, described by [Distributed Tracing](https://docs.datadoghq.com/tracing/setup_overview/setup/ruby/#distributed-tracing).
+              # * `b3multi`: B3 Propagation using multiple headers, described by [openzipkin/b3-propagation](https://github.com/openzipkin/b3-propagation#multiple-headers).
+              # * `b3`: B3 Propagation using a single header, described by [openzipkin/b3-propagation](https://github.com/openzipkin/b3-propagation#single-header).
+              #
+              # @public_api
+              settings :distributed_tracing do
+                # An ordered list of what data propagation styles the tracer will use to extract distributed tracing propagation
+                # data from incoming requests and messages.
+                #
+                # The tracer will try to find distributed headers in the order they are present in the list provided to this option.
+                # The first format to have valid data present will be used.
+                #
+                # @default `DD_TRACE_PROPAGATION_STYLE_EXTRACT` environment variable (comma-separated list),
+                #   otherwise `['Datadog','b3multi','b3']`.
+                # @return [Array<String>]
+                option :propagation_extract_style do |o|
+                  o.default do
+                    # DEV-2.0: Change default value to `tracecontext, Datadog`.
+                    # Look for all headers by default
+                    env_to_list(
+                      [
+                        Tracing::Configuration::Ext::Distributed::ENV_PROPAGATION_STYLE_EXTRACT,
+                        Tracing::Configuration::Ext::Distributed::ENV_PROPAGATION_STYLE_EXTRACT_OLD
+                      ],
+                      [
+                        Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG,
+                        Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_MULTI_HEADER,
+                        Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_SINGLE_HEADER
+                      ],
+                      comma_separated_only: true
+                    )
+                  end
+
+                  o.on_set do |styles|
+                    # Modernize B3 options
+                    # DEV-2.0: Can be removed with the removal of deprecated B3 constants.
+                    styles.map! do |style|
+                      case style
+                      when Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3
+                        Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_MULTI_HEADER
+                      when Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_SINGLE_HEADER_OLD
+                        Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_SINGLE_HEADER
+                      else
+                        style
+                      end
+                    end
+                  end
+
+                  o.lazy
+                end
+
+                # The data propagation styles the tracer will use to inject distributed tracing propagation
+                # data into outgoing requests and messages.
+                #
+                # The tracer will inject data from all styles specified in this option.
+                #
+                # @default `DD_TRACE_PROPAGATION_STYLE_INJECT` environment variable (comma-separated list), otherwise `['Datadog']`.
+                # @return [Array<String>]
+                option :propagation_inject_style do |o|
+                  o.default do
+                    # DEV-2.0: Change default value to `tracecontext, Datadog`.
+                    env_to_list(
+                      [
+                        Tracing::Configuration::Ext::Distributed::ENV_PROPAGATION_STYLE_INJECT,
+                        Tracing::Configuration::Ext::Distributed::ENV_PROPAGATION_STYLE_INJECT_OLD
+                      ],
+                      [Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG],
+                      comma_separated_only: true # Only inject Datadog headers by default
+                    )
+                  end
+
+                  o.on_set do |styles|
+                    # Modernize B3 options
+                    # DEV-2.0: Can be removed with the removal of deprecated B3 constants.
+                    styles.map! do |style|
+                      case style
+                      when Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3
+                        Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_MULTI_HEADER
+                      when Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_SINGLE_HEADER_OLD
+                        Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_SINGLE_HEADER
+                      else
+                        style
+                      end
+                    end
+                  end
+
+                  o.lazy
+                end
+
+                # An ordered list of what data propagation styles the tracer will use to extract distributed tracing propagation
+                # data from incoming requests and inject into outgoing requests.
+                #
+                # This configuration is the equivalent of configuring both {propagation_extract_style}
+                # {propagation_inject_style} to value set to {propagation_style}.
+                #
+                # @default `DD_TRACE_PROPAGATION_STYLE` environment variable (comma-separated list).
+                # @return [Array<String>]
+                option :propagation_style do |o|
+                  o.default do
+                    env_to_list(Configuration::Ext::Distributed::ENV_PROPAGATION_STYLE, nil, comma_separated_only: true)
+                  end
+
+                  o.on_set do |styles|
+                    next unless styles
+
+                    # Modernize B3 options
+                    # DEV-2.0: Can be removed with the removal of deprecated B3 constants.
+                    styles.map! do |style|
+                      case style
+                      when Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3
+                        Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_MULTI_HEADER
+                      when Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_SINGLE_HEADER_OLD
+                        Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_SINGLE_HEADER
+                      else
+                        style
+                      end
+                    end
+
+                    set_option(:propagation_extract_style, styles)
+                    set_option(:propagation_inject_style, styles)
+                  end
+
+                  o.lazy
+                end
+              end
+
+              # Enable trace collection and span generation.
+              #
+              # You can use this option to disable tracing without having to
+              # remove the library as a whole.
+              #
+              # @default `DD_TRACE_ENABLED` environment variable, otherwise `true`
+              # @return [Boolean]
+              option :enabled do |o|
+                o.default { env_to_bool(Tracing::Configuration::Ext::ENV_ENABLED, true) }
+                o.lazy
+              end
+
+              # A custom tracer instance.
+              #
+              # It must respect the contract of {Datadog::Tracing::Tracer}.
+              # It's recommended to delegate methods to {Datadog::Tracing::Tracer} to ease the implementation
+              # of a custom tracer.
+              #
+              # This option will not return the live tracer instance: it only holds a custom tracing instance, if any.
+              #
+              # For internal use only.
+              #
+              # @default `nil`
+              # @return [Object,nil]
+              option :instance
+
+              # Automatic correlation between tracing and logging.
+              # @see https://docs.datadoghq.com/tracing/setup_overview/setup/ruby/#trace-correlation
+              # @return [Boolean]
+              option :log_injection do |o|
+                o.default { env_to_bool(Tracing::Configuration::Ext::Correlation::ENV_LOGS_INJECTION_ENABLED, true) }
+                o.lazy
+              end
+
+              # Configures an alternative trace transport behavior, where
+              # traces can be sent to the agent and backend before all spans
+              # have finished.
+              #
+              # This is useful for long-running jobs or very large traces.
+              #
+              # The trace flame graph will display the partial trace as it is received and constantly
+              # update with new spans as they are flushed.
+              # @public_api
+              settings :partial_flush do
+                # Enable partial trace flushing.
+                #
+                # @default `false`
+                # @return [Boolean]
+                option :enabled, default: false
+
+                # Minimum number of finished spans required in a single unfinished trace before
+                # the tracer will consider that trace for partial flushing.
+                #
+                # This option helps preserve a minimum amount of batching in the
+                # flushing process, reducing network overhead.
+                #
+                # This threshold only applies to unfinished traces. Traces that have finished
+                # are always flushed immediately.
+                #
+                # @default 500
+                # @return [Integer]
+                option :min_spans_threshold, default: 500
+              end
+
+              # Enables {https://docs.datadoghq.com/tracing/trace_retention_and_ingestion/#datadog-intelligent-retention-filter
+              # Datadog intelligent retention filter}.
+              # @default `true`
+              # @return [Boolean,nil]
+              option :priority_sampling
+
+              option :report_hostname do |o|
+                o.default { env_to_bool(Tracing::Configuration::Ext::NET::ENV_REPORT_HOSTNAME, false) }
+                o.lazy
+              end
+
+              # A custom sampler instance.
+              # The object must respect the {Datadog::Tracing::Sampling::Sampler} interface.
+              # @default `nil`
+              # @return [Object,nil]
+              option :sampler
+
+              # Client-side sampling configuration.
+              # @see https://docs.datadoghq.com/tracing/trace_ingestion/mechanisms/
+              # @public_api
+              settings :sampling do
+                # Default sampling rate for the tracer.
+                #
+                # If `nil`, the trace uses an automatic sampling strategy that tries to ensure
+                # the collection of traces that are considered important (e.g. traces with an error, traces
+                # for resources not seen recently).
+                #
+                # @default `DD_TRACE_SAMPLE_RATE` environment variable, otherwise `nil`.
+                # @return [Float,nil]
+                option :default_rate do |o|
+                  o.default { env_to_float(Tracing::Configuration::Ext::Sampling::ENV_SAMPLE_RATE, nil) }
+                  o.lazy
+                end
+
+                # Rate limit for number of spans per second.
+                #
+                # Spans created above the limit will contribute to service metrics, but won't
+                # have their payload stored.
+                #
+                # @default `DD_TRACE_RATE_LIMIT` environment variable, otherwise 100.
+                # @return [Numeric,nil]
+                option :rate_limit do |o|
+                  o.default { env_to_float(Tracing::Configuration::Ext::Sampling::ENV_RATE_LIMIT, 100) }
+                  o.lazy
+                end
+
+                # Single span sampling rules.
+                # These rules allow a span to be kept when its encompassing trace is dropped.
+                #
+                # The syntax for single span sampling rules can be found here:
+                # TODO: <Single Span Sampling documentation URL here>
+                #
+                # @default `DD_SPAN_SAMPLING_RULES` environment variable.
+                #   Otherwise, `ENV_SPAN_SAMPLING_RULES_FILE` environment variable.
+                #   Otherwise `nil`.
+                # @return [String,nil]
+                # @public_api
+                option :span_rules do |o|
+                  o.default do
+                    rules = ENV[Tracing::Configuration::Ext::Sampling::Span::ENV_SPAN_SAMPLING_RULES]
+                    rules_file = ENV[Tracing::Configuration::Ext::Sampling::Span::ENV_SPAN_SAMPLING_RULES_FILE]
+
+                    if rules
+                      if rules_file
+                        Datadog.logger.warn(
+                          'Both DD_SPAN_SAMPLING_RULES and DD_SPAN_SAMPLING_RULES_FILE were provided: only ' \
+                            'DD_SPAN_SAMPLING_RULES will be used. Please do not provide DD_SPAN_SAMPLING_RULES_FILE when ' \
+                            'also providing DD_SPAN_SAMPLING_RULES as their configuration conflicts. ' \
+                            "DD_SPAN_SAMPLING_RULES_FILE=#{rules_file} DD_SPAN_SAMPLING_RULES=#{rules}"
+                        )
+                      end
+                      rules
+                    elsif rules_file
+                      begin
+                        File.read(rules_file)
+                      rescue => e
+                        # `File#read` errors have clear and actionable messages, no need to add extra exception info.
+                        Datadog.logger.warn(
+                          "Cannot read span sampling rules file `#{rules_file}`: #{e.message}." \
+                          'No span sampling rules will be applied.'
+                        )
+                        nil
+                      end
+                    end
+                  end
+                  o.lazy
+                end
+              end
+
+              # [Continuous Integration Visibility](https://docs.datadoghq.com/continuous_integration/) configuration.
+              # @public_api
+              settings :test_mode do
+                # Enable test mode. This allows the tracer to collect spans from test runs.
+                #
+                # It also prevents the tracer from collecting spans in a production environment. Only use in a test environment.
+                #
+                # @default `DD_TRACE_TEST_MODE_ENABLED` environment variable, otherwise `false`
+                # @return [Boolean]
+                option :enabled do |o|
+                  o.default { env_to_bool(Tracing::Configuration::Ext::Test::ENV_MODE_ENABLED, false) }
+                  o.lazy
+                end
+
+                option :trace_flush do |o|
+                  o.default { nil }
+                  o.lazy
+                end
+
+                option :writer_options do |o|
+                  o.default { {} }
+                  o.lazy
+                end
+              end
+
+              # @see file:docs/GettingStarted.md#configuring-the-transport-layer Configuring the transport layer
+              #
+              # A {Proc} that configures a custom tracer transport.
+              # @yield Receives a {Datadog::Transport::HTTP} that can be modified with custom adapters and settings.
+              # @yieldparam [Datadog::Transport::HTTP] t transport to be configured.
+              # @default `nil`
+              # @return [Proc,nil]
+              option :transport_options, default: nil
+
+              # A custom writer instance.
+              # The object must respect the {Datadog::Tracing::Writer} interface.
+              #
+              # This option is recommended for internal use only.
+              #
+              # @default `nil`
+              # @return [Object,nil]
+              option :writer
+
+              # A custom {Hash} with keyword options to be passed to {Datadog::Tracing::Writer#initialize}.
+              #
+              # This option is recommended for internal use only.
+              #
+              # @default `{}`
+              # @return [Hash,nil]
+              option :writer_options, default: ->(_i) { {} }, lazy: true
+
+              # Client IP configuration
+              # @public_api
+              settings :client_ip do
+                # Whether client IP collection is enabled. When enabled client IPs from HTTP requests will
+                #   be reported in traces.
+                #
+                # Usage of the DD_TRACE_CLIENT_IP_HEADER_DISABLED environment variable is deprecated.
+                #
+                # @see https://docs.datadoghq.com/tracing/configure_data_security#configuring-a-client-ip-header
+                #
+                # @default `DD_TRACE_CLIENT_IP_ENABLED` environment variable, otherwise `false`.
+                # @return [Boolean]
+                option :enabled do |o|
+                  o.default do
+                    disabled = env_to_bool(Tracing::Configuration::Ext::ClientIp::ENV_DISABLED)
+
+                    enabled = if disabled.nil?
+                                false
+                              else
+                                Datadog.logger.warn { "#{Tracing::Configuration::Ext::ClientIp::ENV_DISABLED} environment variable is deprecated, found set to #{disabled}, use #{Tracing::Configuration::Ext::ClientIp::ENV_ENABLED}=#{!disabled}" }
+
+                                !disabled
+                              end
+
+                    # ENABLED env var takes precedence over deprecated DISABLED
+                    env_to_bool(Tracing::Configuration::Ext::ClientIp::ENV_ENABLED, enabled)
+                  end
+                  o.lazy
+                end
+
+                # An optional name of a custom header to resolve the client IP from.
+                #
+                # @default `DD_TRACE_CLIENT_IP_HEADER` environment variable, otherwise `nil`.
+                # @return [String,nil]
+                option :header_name do |o|
+                  o.default { ENV.fetch(Tracing::Configuration::Ext::ClientIp::ENV_HEADER_NAME, nil) }
+                  o.lazy
+                end
+              end
+
+              # Maximum size for the `x-datadog-tags` distributed trace tags header.
+              #
+              # If the serialized size of distributed trace tags is larger than this value, it will
+              # not be parsed if incoming, nor exported if outgoing. An error message will be logged
+              # in this case.
+              #
+              # @default `DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH` environment variable, otherwise `512`
+              # @return [Integer]
+              option :x_datadog_tags_max_length do |o|
+                o.default { env_to_int(Tracing::Configuration::Ext::Distributed::ENV_X_DATADOG_TAGS_MAX_LENGTH, 512) }
+                o.lazy
+              end
+            end
+          end
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/BlockLength
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Layout/LineLength
+    end
+  end
+end

data/lib/datadog/tracing/context.rb

@@ -1,6 +1,6 @@
 # typed: true
 
-require 'datadog/core/utils/forking'
+require_relative '../core/utils/forking'
 
 module Datadog
   module Tracing