ddtrace 0.54.2 → 1.10.1

data/lib/datadog/tracing/buffer.rb

@@ -0,0 +1,128 @@
+require_relative '../core'
+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 StandardError => 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 StandardError => 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 StandardError => 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,176 @@
+# 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'
+
+module Datadog
+  module Tracing
+    # Tracing component
+    module Component
+      def build_tracer(settings, agent_settings)
+        # 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
+
+        subscribe_to_writer_events!(writer, sampler, settings.tracing.test_mode.enabled)
+
+        Tracing::Tracer.new(
+          default_service: settings.service,
+          enabled: settings.tracing.enabled,
+          trace_flush: trace_flush,
+          sampler: sampler,
+          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 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)
+        if (writer = settings.tracing.writer)
+          return writer
+        end
+
+        Tracing::Writer.new(agent_settings: agent_settings, **settings.tracing.writer_options)
+      end
+
+      def subscribe_to_writer_events!(writer, sampler, 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.
+        #
+        # 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))
+      end
+
+      WRITER_RECORD_ENVIRONMENT_INFORMATION_CALLBACK = lambda do |_, responses|
+        Core::Diagnostics::EnvironmentLogger.log!(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
+
+      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)
+        # Flush traces synchronously, to guarantee they are written.
+        writer_options = settings.tracing.test_mode.writer_options || {}
+        Tracing::SyncWriter.new(agent_settings: agent_settings, **writer_options)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+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
+
+        # @public_api
+        module Analytics
+          ENV_TRACE_ANALYTICS_ENABLED = 'DD_TRACE_ANALYTICS_ENABLED'.freeze
+        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
+        end
+
+        # @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'.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
+        module NET
+          ENV_REPORT_HOSTNAME = 'DD_TRACE_REPORT_HOSTNAME'.freeze
+        end
+
+        # @public_api
+        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
+        module Test
+          ENV_MODE_ENABLED = 'DD_TRACE_TEST_MODE_ENABLED'.freeze
+        end
+
+        # @public_api
+        module Transport
+          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
+end