ddtrace 1.12.1 → 1.23.2

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,106 @@
+# 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