ddtrace 0.34.1 → 1.23.1

data/lib/datadog/tracing/component.rb

@@ -0,0 +1,235 @@
+# 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
+      # 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)
+          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,
+          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
+
+      # TODO: Sampler 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_sampler(settings)
+        if (sampler = settings.tracing.sampler)
+          if settings.tracing.priority_sampling == false
+            sampler
+          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,
+            default_sample_rate: settings.tracing.sampling.default_rate
+          )
+        else
+          Tracing::Sampling::PrioritySampler.new(
+            base_sampler: Tracing::Sampling::AllSampler.new,
+            post_sampler: Tracing::Sampling::RuleSampler.new(
+              rate_limit: settings.tracing.sampling.rate_limit,
+              default_sample_rate: settings.tracing.sampling.default_rate
+            )
+          )
+        end
+      end
+
+      def ensure_priority_sampling(sampler, settings)
+        if sampler.is_a?(Tracing::Sampling::PrioritySampler)
+          sampler
+        else
+          Tracing::Sampling::PrioritySampler.new(
+            base_sampler: sampler,
+            post_sampler: Tracing::Sampling::RuleSampler.new(
+              rate_limit: settings.tracing.sampling.rate_limit,
+              default_sample_rate: settings.tracing.sampling.default_rate
+            )
+          )
+        end
+      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|
+        Tracing::Diagnostics::EnvironmentLogger.collect_and_log!(responses: responses)
+      end
+
+      # 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
+
+      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
+
+      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
+
+      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
+
+      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/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

@@ -0,0 +1,108 @@
+# 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_TRACE_ID_128_BIT_GENERATION_ENABLED = 'DD_TRACE_128_BIT_TRACEID_GENERATION_ENABLED'
+
+        # @public_api
+        module SpanAttributeSchema
+          ENV_GLOBAL_DEFAULT_SERVICE_NAME_ENABLED = 'DD_TRACE_REMOVE_INTEGRATION_SERVICE_NAMES_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'
+          # @deprecated Use `b3multi` instead.
+          PROPAGATION_STYLE_B3 = 'B3'
+
+          PROPAGATION_STYLE_B3_SINGLE_HEADER = 'b3'
+          # @deprecated Use `b3` instead.
+          PROPAGATION_STYLE_B3_SINGLE_HEADER_OLD = 'B3 single header'
+
+          # W3C Trace Context
+          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'
+
+          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'
+
+          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'
+
+          # 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'
+
+          # @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_DISABLED = 'DD_TRACE_CLIENT_IP_HEADER_DISABLED' # TODO: deprecated, remove later
+          ENV_HEADER_NAME = 'DD_TRACE_CLIENT_IP_HEADER'
+        end
+      end
+    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