ddtrace 0.53.0 → 1.9.0

data/lib/datadog/tracing/correlation.rb

@@ -0,0 +1,100 @@
+# typed: true
+
+require_relative '../core'
+
+module Datadog
+  module Tracing
+    # Contains behavior for managing correlations with tracing
+    # e.g. Retrieve a correlation to the current trace for logging, etc.
+    module Correlation
+      # Represents current trace state with key identifiers
+      # @public_api
+      class Identifier
+        LOG_ATTR_ENV = 'dd.env'.freeze
+        LOG_ATTR_SERVICE = 'dd.service'.freeze
+        LOG_ATTR_SPAN_ID = 'dd.span_id'.freeze
+        LOG_ATTR_TRACE_ID = 'dd.trace_id'.freeze
+        LOG_ATTR_VERSION = 'dd.version'.freeze
+
+        attr_reader \
+          :env,
+          :service,
+          :span_id,
+          :span_name,
+          :span_resource,
+          :span_service,
+          :span_type,
+          :trace_id,
+          :trace_name,
+          :trace_resource,
+          :trace_service,
+          :version
+
+        # @!visibility private
+        def initialize(
+          env: nil,
+          service: nil,
+          span_id: nil,
+          span_name: nil,
+          span_resource: nil,
+          span_service: nil,
+          span_type: nil,
+          trace_id: nil,
+          trace_name: nil,
+          trace_resource: nil,
+          trace_service: nil,
+          version: nil
+        )
+          # Dup and freeze strings so they aren't modified by reference.
+          @env = Core::Utils::SafeDup.frozen_or_dup(env || Datadog.configuration.env).freeze
+          @service = Core::Utils::SafeDup.frozen_or_dup(service || Datadog.configuration.service).freeze
+          @span_id = span_id || 0
+          @span_name = Core::Utils::SafeDup.frozen_or_dup(span_name).freeze
+          @span_resource = Core::Utils::SafeDup.frozen_or_dup(span_resource).freeze
+          @span_service = Core::Utils::SafeDup.frozen_or_dup(span_service).freeze
+          @span_type = Core::Utils::SafeDup.frozen_or_dup(span_type).freeze
+          @trace_id = trace_id || 0
+          @trace_name = Core::Utils::SafeDup.frozen_or_dup(trace_name).freeze
+          @trace_resource = Core::Utils::SafeDup.frozen_or_dup(trace_resource).freeze
+          @trace_service = Core::Utils::SafeDup.frozen_or_dup(trace_service).freeze
+          @version = Core::Utils::SafeDup.frozen_or_dup(version || Datadog.configuration.version).freeze
+        end
+
+        def to_log_format
+          @log_format ||= begin
+            attributes = []
+            attributes << "#{LOG_ATTR_ENV}=#{env}" unless env.nil?
+            attributes << "#{LOG_ATTR_SERVICE}=#{service}"
+            attributes << "#{LOG_ATTR_VERSION}=#{version}" unless version.nil?
+            attributes << "#{LOG_ATTR_TRACE_ID}=#{trace_id}"
+            attributes << "#{LOG_ATTR_SPAN_ID}=#{span_id}"
+            attributes.join(' ')
+          end
+        end
+      end
+
+      module_function
+
+      # Produces a CorrelationIdentifier from the TraceDigest provided
+      #
+      # DEV: can we memoize this object, give it can be common to
+      # use a correlation multiple times, specially in the context of logging?
+      # @!visibility private
+      def identifier_from_digest(digest)
+        return Identifier.new unless digest
+
+        Identifier.new(
+          span_id: digest.span_id,
+          span_name: digest.span_name,
+          span_resource: digest.span_resource,
+          span_service: digest.span_service,
+          span_type: digest.span_type,
+          trace_id: digest.trace_id,
+          trace_name: digest.trace_name,
+          trace_resource: digest.trace_resource,
+          trace_service: digest.trace_service
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# typed: true
+
+module Datadog
+  module Tracing
+    module Diagnostics
+      # @public_api
+      module Ext
+        # Health
+        module Health
+          # Metrics
+          module Metrics
+            METRIC_API_ERRORS = 'datadog.tracer.api.errors'.freeze
+            METRIC_API_REQUESTS = 'datadog.tracer.api.requests'.freeze
+            METRIC_API_RESPONSES = 'datadog.tracer.api.responses'.freeze
+            METRIC_ERROR_CONTEXT_OVERFLOW = 'datadog.tracer.error.context_overflow'.freeze
+            METRIC_ERROR_INSTRUMENTATION_PATCH = 'datadog.tracer.error.instrumentation_patch'.freeze
+            METRIC_ERROR_SPAN_FINISH = 'datadog.tracer.error.span_finish'.freeze
+            METRIC_ERROR_UNFINISHED_SPANS = 'datadog.tracer.error.unfinished_spans'.freeze
+            METRIC_INSTRUMENTATION_PATCHED = 'datadog.tracer.instrumentation_patched'.freeze
+            METRIC_QUEUE_ACCEPTED = 'datadog.tracer.queue.accepted'.freeze
+            METRIC_QUEUE_ACCEPTED_LENGTHS = 'datadog.tracer.queue.accepted_lengths'.freeze
+            METRIC_QUEUE_DROPPED = 'datadog.tracer.queue.dropped'.freeze
+            METRIC_QUEUE_LENGTH = 'datadog.tracer.queue.length'.freeze
+            METRIC_QUEUE_MAX_LENGTH = 'datadog.tracer.queue.max_length'.freeze
+            METRIC_QUEUE_SPANS = 'datadog.tracer.queue.spans'.freeze
+            METRIC_SAMPLING_SERVICE_CACHE_LENGTH = 'datadog.tracer.sampling.service_cache_length'.freeze
+            METRIC_TRACES_FILTERED = 'datadog.tracer.traces.filtered'.freeze
+            METRIC_TRANSPORT_CHUNKED = 'datadog.tracer.transport.chunked'.freeze
+            METRIC_TRANSPORT_TRACE_TOO_LARGE = 'datadog.tracer.transport.trace_too_large'.freeze
+            METRIC_WRITER_CPU_TIME = 'datadog.tracer.writer.cpu_time'.freeze
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/diagnostics/health.rb

@@ -0,0 +1,40 @@
+# typed: ignore
+
+require_relative 'ext'
+
+module Datadog
+  module Tracing
+    module Diagnostics
+      # Health-related diagnostics
+      module Health
+        # Health metrics for diagnostics
+        module Metrics
+          def self.extended(base)
+            base.class_eval do
+              count :api_errors, Ext::Health::Metrics::METRIC_API_ERRORS
+              count :api_requests, Ext::Health::Metrics::METRIC_API_REQUESTS
+              count :api_responses, Ext::Health::Metrics::METRIC_API_RESPONSES
+              count :error_context_overflow, Ext::Health::Metrics::METRIC_ERROR_CONTEXT_OVERFLOW
+              count :error_instrumentation_patch, Ext::Health::Metrics::METRIC_ERROR_INSTRUMENTATION_PATCH
+              count :error_span_finish, Ext::Health::Metrics::METRIC_ERROR_SPAN_FINISH
+              count :error_unfinished_spans, Ext::Health::Metrics::METRIC_ERROR_UNFINISHED_SPANS
+              count :instrumentation_patched, Ext::Health::Metrics::METRIC_INSTRUMENTATION_PATCHED
+              count :queue_accepted, Ext::Health::Metrics::METRIC_QUEUE_ACCEPTED
+              count :queue_accepted_lengths, Ext::Health::Metrics::METRIC_QUEUE_ACCEPTED_LENGTHS
+              count :queue_dropped, Ext::Health::Metrics::METRIC_QUEUE_DROPPED
+              count :traces_filtered, Ext::Health::Metrics::METRIC_TRACES_FILTERED
+              count :transport_trace_too_large, Ext::Health::Metrics::METRIC_TRANSPORT_TRACE_TOO_LARGE
+              count :transport_chunked, Ext::Health::Metrics::METRIC_TRANSPORT_CHUNKED
+              count :writer_cpu_time, Ext::Health::Metrics::METRIC_WRITER_CPU_TIME
+
+              gauge :queue_length, Ext::Health::Metrics::METRIC_QUEUE_LENGTH
+              gauge :queue_max_length, Ext::Health::Metrics::METRIC_QUEUE_MAX_LENGTH
+              gauge :queue_spans, Ext::Health::Metrics::METRIC_QUEUE_SPANS
+              gauge :sampling_service_cache_length, Ext::Health::Metrics::METRIC_SAMPLING_SERVICE_CACHE_LENGTH
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/distributed/b3_multi.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+# typed: true
+
+require_relative 'helpers'
+require_relative '../trace_digest'
+
+module Datadog
+  module Tracing
+    module Distributed
+      # B3 multi header-style trace propagation.
+      # @see https://github.com/openzipkin/b3-propagation#multiple-headers
+      class B3Multi
+        B3_TRACE_ID_KEY = 'x-b3-traceid'
+        B3_SPAN_ID_KEY = 'x-b3-spanid'
+        B3_SAMPLED_KEY = 'x-b3-sampled'
+
+        def initialize(
+          fetcher:,
+          trace_id_key: B3_TRACE_ID_KEY,
+          span_id_key: B3_SPAN_ID_KEY,
+          sampled_key: B3_SAMPLED_KEY
+        )
+          @trace_id_key = trace_id_key
+          @span_id_key = span_id_key
+          @sampled_key = sampled_key
+          @fetcher = fetcher
+        end
+
+        def inject!(digest, data = {})
+          return if digest.nil?
+
+          # DEV: We need these to be hex encoded
+          data[@trace_id_key] = digest.trace_id.to_s(16)
+          data[@span_id_key] = digest.span_id.to_s(16)
+
+          if digest.trace_sampling_priority
+            sampling_priority = Helpers.clamp_sampling_priority(
+              digest.trace_sampling_priority
+            )
+            data[@sampled_key] = sampling_priority.to_s
+          end
+
+          data
+        end
+
+        def extract(data)
+          # DEV: B3 doesn't have "origin"
+          fetcher = @fetcher.new(data)
+          trace_id = fetcher.id(@trace_id_key, base: 16)
+          span_id = fetcher.id(@span_id_key, base: 16)
+          # We don't need to try and convert sampled since B3 supports 0/1 (AUTO_REJECT/AUTO_KEEP)
+          sampling_priority = fetcher.number(@sampled_key)
+
+          # Return early if this propagation is not valid
+          return unless trace_id && span_id
+
+          TraceDigest.new(
+            trace_id: trace_id,
+            span_id: span_id,
+            trace_sampling_priority: sampling_priority
+          )
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/distributed/b3_single.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+# typed: true
+
+require_relative 'helpers'
+require_relative '../trace_digest'
+
+module Datadog
+  module Tracing
+    module Distributed
+      # B3 single header-style trace propagation.
+      #
+      # DEV: Format:
+      # DEV:   b3: {TraceId}-{SpanId}-{SamplingState}-{ParentSpanId}
+      # DEV: https://github.com/apache/incubator-zipkin-b3-propagation/tree/7c6e9f14d6627832bd80baa87ac7dabee7be23cf#single-header
+      # DEV: `{SamplingState}` and `{ParentSpanId}` are optional
+      #
+      # @see https://github.com/openzipkin/b3-propagation#single-header
+      class B3Single
+        B3_SINGLE_HEADER_KEY = 'b3'
+
+        def initialize(fetcher:, key: B3_SINGLE_HEADER_KEY)
+          @key = key
+          @fetcher = fetcher
+        end
+
+        def inject!(digest, env)
+          return if digest.nil?
+
+          # DEV: We need these to be hex encoded
+          value = "#{digest.trace_id.to_s(16)}-#{digest.span_id.to_s(16)}"
+
+          if digest.trace_sampling_priority
+            sampling_priority = Helpers.clamp_sampling_priority(
+              digest.trace_sampling_priority
+            )
+            value += "-#{sampling_priority}"
+          end
+
+          env[@key] = value
+          env
+        end
+
+        def extract(env)
+          fetcher = @fetcher.new(env)
+          value = fetcher[@key]
+
+          return unless value
+
+          parts = value.split('-')
+          trace_id = Helpers.value_to_id(parts[0], 16) unless parts.empty?
+          span_id = Helpers.value_to_id(parts[1], 16) if parts.length > 1
+          sampling_priority = Helpers.value_to_number(parts[2]) if parts.length > 2
+
+          # Return if this propagation is not valid
+          return unless trace_id && span_id
+
+          TraceDigest.new(
+            span_id: span_id,
+            trace_id: trace_id,
+            trace_sampling_priority: sampling_priority
+          )
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/distributed/datadog.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+# typed: true
+
+require_relative '../metadata/ext'
+require_relative '../trace_digest'
+require_relative 'datadog_tags_codec'
+
+module Datadog
+  module Tracing
+    module Distributed
+      # Datadog-style trace propagation.
+      class Datadog
+        TRACE_ID_KEY = 'x-datadog-trace-id'
+        PARENT_ID_KEY = 'x-datadog-parent-id'
+        SAMPLING_PRIORITY_KEY = 'x-datadog-sampling-priority'
+        ORIGIN_KEY = 'x-datadog-origin'
+        # Distributed trace-level tags
+        TAGS_KEY = 'x-datadog-tags'
+
+        # Prefix used by all Datadog-specific distributed tags
+        TAGS_PREFIX = 'x-datadog-'
+
+        def initialize(
+          fetcher:,
+          trace_id_key: TRACE_ID_KEY,
+          parent_id_key: PARENT_ID_KEY,
+          sampling_priority_key: SAMPLING_PRIORITY_KEY,
+          origin_key: ORIGIN_KEY,
+          tags_key: TAGS_KEY
+        )
+          @trace_id_key = trace_id_key
+          @parent_id_key = parent_id_key
+          @sampling_priority_key = sampling_priority_key
+          @origin_key = origin_key
+          @tags_key = tags_key
+          @fetcher = fetcher
+        end
+
+        def inject!(digest, data)
+          return if digest.nil?
+
+          data[@trace_id_key] = digest.trace_id.to_s
+          data[@parent_id_key] = digest.span_id.to_s
+          data[@sampling_priority_key] = digest.trace_sampling_priority.to_s if digest.trace_sampling_priority
+          data[@origin_key] = digest.trace_origin.to_s if digest.trace_origin
+
+          inject_tags(digest, data)
+
+          data
+        end
+
+        def extract(data)
+          fetcher = @fetcher.new(data)
+          trace_id = fetcher.id(@trace_id_key)
+          parent_id = fetcher.id(@parent_id_key)
+          sampling_priority = fetcher.number(@sampling_priority_key)
+          origin = fetcher[@origin_key]
+
+          # Return early if this propagation is not valid
+          # DEV: To be valid we need to have a trace id and a parent id
+          #      or when it is a synthetics trace, just the trace id.
+          # DEV: `Fetcher#id` will not return 0
+          return unless (trace_id && parent_id) || (origin && trace_id)
+
+          trace_distributed_tags = extract_tags(fetcher)
+
+          TraceDigest.new(
+            span_id: parent_id,
+            trace_id: trace_id,
+            trace_origin: origin,
+            trace_sampling_priority: sampling_priority,
+            trace_distributed_tags: trace_distributed_tags,
+          )
+        end
+
+        private
+
+        # Export trace distributed tags through the `x-datadog-tags` key.
+        #
+        # DEV: This method accesses global state (the active trace) to record its error state as a trace tag.
+        # DEV: This means errors cannot be reported if there's not active span.
+        # DEV: Ideally, we'd have a dedicated error reporting stream for all of ddtrace.
+        def inject_tags(digest, data)
+          return if digest.trace_distributed_tags.nil? || digest.trace_distributed_tags.empty?
+          return set_tags_propagation_error(reason: 'disabled') if tags_disabled?
+
+          tags = DatadogTagsCodec.encode(digest.trace_distributed_tags)
+
+          return set_tags_propagation_error(reason: 'inject_max_size') if tags_too_large?(tags.size, scenario: 'inject')
+
+          data[@tags_key] = tags
+        rescue => e
+          set_tags_propagation_error(reason: 'encoding_error')
+          ::Datadog.logger.warn(
+            "Failed to inject x-datadog-tags: #{e.class.name} #{e.message} at #{Array(e.backtrace).first}"
+          )
+        end
+
+        # Import `x-datadog-tags` tags as trace distributed tags.
+        # Only tags that have the `_dd.p.` prefix are processed.
+        #
+        # DEV: This method accesses global state (the active trace) to record its error state as a trace tag.
+        # DEV: This means errors cannot be reported if there's not active span.
+        # DEV: Ideally, we'd have a dedicated error reporting stream for all of ddtrace.
+        def extract_tags(fetcher)
+          tags = fetcher[@tags_key]
+
+          return if !tags || tags.empty?
+          return set_tags_propagation_error(reason: 'disabled') if tags_disabled?
+          return set_tags_propagation_error(reason: 'extract_max_size') if tags_too_large?(tags.size, scenario: 'extract')
+
+          tags_hash = DatadogTagsCodec.decode(tags)
+          # Only extract keys with the expected Datadog prefix
+          tags_hash.select! do |key, _|
+            key.start_with?(Tracing::Metadata::Ext::Distributed::TAGS_PREFIX) && key != EXCLUDED_TAG
+          end
+          tags_hash
+        rescue => e
+          set_tags_propagation_error(reason: 'decoding_error')
+          ::Datadog.logger.warn(
+            "Failed to extract x-datadog-tags: #{e.class.name} #{e.message} at #{Array(e.backtrace).first}"
+          )
+        end
+
+        def set_tags_propagation_error(reason:)
+          active_trace = Tracing.active_trace
+          active_trace.set_tag('_dd.propagation_error', reason) if active_trace
+          nil
+        end
+
+        def tags_disabled?
+          ::Datadog.configuration.tracing.x_datadog_tags_max_length <= 0
+        end
+
+        def tags_too_large?(size, scenario:)
+          return false if size <= ::Datadog.configuration.tracing.x_datadog_tags_max_length
+
+          ::Datadog.logger.warn(
+            "Failed to #{scenario} x-datadog-tags: tags are too large for configured limit (size:#{size} >= " \
+              "limit:#{::Datadog.configuration.tracing.x_datadog_tags_max_length}). This limit can be configured " \
+              'through the DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH environment variable.'
+          )
+
+          true
+        end
+
+        # We want to exclude tags that we don't want to propagate downstream.
+        EXCLUDED_TAG = '_dd.p.upstream_services'
+        private_constant :EXCLUDED_TAG
+      end
+    end
+  end
+end

data/lib/datadog/tracing/distributed/datadog_tags_codec.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+# typed: false
+
+module Datadog
+  module Tracing
+    module Distributed
+      # Encodes and decodes distributed 'x-datadog-tags' tags for transport
+      # to and from external processes.
+      module DatadogTagsCodec
+        # Backport `Regexp::match?` because it is measurably the most performant
+        # way to check if a string matches a regular expression.
+        module RefineRegexp
+          unless Regexp.method_defined?(:match?)
+            refine ::Regexp do
+              def match?(*args)
+                !match(*args).nil?
+              end
+            end
+          end
+        end
+        using RefineRegexp
+
+        # ASCII characters 32-126, except `,`, `=`, and ` `. At least one character.
+        VALID_KEY_CHARS = /\A(?:(?![,= ])[\u0020-\u007E])+\Z/.freeze
+        # ASCII characters 32-126, except `,`. At least one character.
+        VALID_VALUE_CHARS = /\A(?:(?!,)[\u0020-\u007E])+\Z/.freeze
+
+        # Serializes a {Hash<String,String>} into a `x-datadog-tags`-compatible
+        # String.
+        #
+        # @param tags [Hash<String,String>] trace tag hash
+        # @return [String] serialized tags hash
+        # @raise [EncodingError] if tags cannot be serialized to the `x-datadog-tags` format
+        def self.encode(tags)
+          begin
+            tags.map do |raw_key, raw_value|
+              key = raw_key.to_s
+              value = raw_value.to_s
+
+              raise EncodingError, "Invalid key `#{key}` for value `#{value}`" unless VALID_KEY_CHARS.match?(key)
+              raise EncodingError, "Invalid value `#{value}` for key `#{key}`" unless VALID_VALUE_CHARS.match?(value)
+
+              "#{key}=#{value.strip}"
+            end.join(',')
+          rescue => e
+            raise EncodingError, "Error encoding tags `#{tags}`: `#{e}`"
+          end
+        end
+
+        # Deserializes a `x-datadog-tags`-formatted String into a {Hash<String,String>}.
+        #
+        # @param string [String] tags as serialized by {#encode}
+        # @return [Hash<String,String>] decoded input as a hash of strings
+        # @raise [DecodingError] if string does not conform to the `x-datadog-tags` format
+        def self.decode(string)
+          result = Hash[string.split(',').map do |raw_tag|
+            raw_tag.split('=', 2).tap do |raw_key, raw_value|
+              key = raw_key.to_s
+              value = raw_value.to_s
+
+              raise DecodingError, "Invalid key: #{key}" unless VALID_KEY_CHARS.match?(key)
+              raise DecodingError, "Invalid value: #{value}" unless VALID_VALUE_CHARS.match?(value)
+
+              value.strip!
+            end
+          end]
+
+          raise DecodingError, "Invalid empty tags: #{string}" if result.empty? && !string.empty?
+
+          result
+        end
+
+        # An error occurred during distributed tags encoding.
+        # See {#message} for more information.
+        class EncodingError < StandardError
+        end
+
+        # An error occurred during distributed tags decoding.
+        # See {#message} for more information.
+        class DecodingError < StandardError
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/distributed/fetcher.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+# typed: true
+
+require_relative 'helpers'
+
+module Datadog
+  module Tracing
+    module Distributed
+      # Common fetcher that retrieves fields from a Hash data input
+      class Fetcher
+        # @param data [Hash]
+        def initialize(data)
+          @data = data
+        end
+
+        def [](key)
+          @data[key]
+        end
+
+        def id(key, base: 10)
+          Helpers.value_to_id(self[key], base)
+        end
+
+        def number(key, base: 10)
+          Helpers.value_to_number(self[key], base)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/distributed/headers/ext.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+# typed: true
+
+module Datadog
+  module Tracing
+    module Distributed
+      module Headers
+        # DEV-2.0: This module only exists for backwards compatibility with the public API. It should be removed.
+        # @deprecated use [Datadog::Tracing::Distributed::Ext]
+        # @public_api
+        module Ext
+          HTTP_HEADER_TRACE_ID = 'x-datadog-trace-id'
+          HTTP_HEADER_PARENT_ID = 'x-datadog-parent-id'
+          HTTP_HEADER_SAMPLING_PRIORITY = 'x-datadog-sampling-priority'
+          HTTP_HEADER_ORIGIN = 'x-datadog-origin'
+          # Distributed trace-level tags
+          HTTP_HEADER_TAGS = 'x-datadog-tags'
+
+          # B3 keys used for distributed tracing.
+          # @see https://github.com/openzipkin/b3-propagation
+          B3_HEADER_TRACE_ID = 'x-b3-traceid'
+          B3_HEADER_SPAN_ID = 'x-b3-spanid'
+          B3_HEADER_SAMPLED = 'x-b3-sampled'
+          B3_HEADER_SINGLE = 'b3'
+
+          # gRPC metadata keys for distributed tracing. https://github.com/grpc/grpc-go/blob/v1.10.x/Documentation/grpc-metadata.md
+          GRPC_METADATA_TRACE_ID = 'x-datadog-trace-id'
+          GRPC_METADATA_PARENT_ID = 'x-datadog-parent-id'
+          GRPC_METADATA_SAMPLING_PRIORITY = 'x-datadog-sampling-priority'
+          GRPC_METADATA_ORIGIN = 'x-datadog-origin'
+        end
+      end
+    end
+  end
+end