ddtrace 1.0.0 → 1.10.1

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

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require_relative '../configuration/ext'
+require_relative '../trace_digest'
+require_relative '../trace_operation'
+
+module Datadog
+  module Tracing
+    module Distributed
+      # Provides extraction and injection of distributed trace data.
+      class Propagation
+        # DEV: This class should receive the value for
+        # DEV: `Datadog.configuration.tracing.distributed_tracing.propagation_inject_style`
+        # DEV: at initialization time, instead of constantly reading global values.
+        # DEV: This means this class should be reconfigured on `Datadog.configure` calls, thus
+        # DEV: singleton instances should not used as they will become stale.
+        #
+        # @param propagation_styles [Hash<String,Object>]
+        def initialize(propagation_styles:)
+          @propagation_styles = propagation_styles
+        end
+
+        # inject! populates the env with span ID, trace ID and sampling priority
+        #
+        # This method will never raise errors, but instead log them to `Datadog.logger`.
+        #
+        # DEV-2.0: inject! should work without arguments, injecting the active_trace's digest
+        # DEV-2.0: and returning a new Hash with the injected data.
+        # DEV-2.0: inject! should also accept either a `trace` or a `digest`, as a `trace`
+        # DEV-2.0: argument is the common use case, but also allows us to set error tags in the `trace`
+        # DEV-2.0: if needed.
+        # DEV-2.0: Ideally, we'd have a separate stream to report tracer errors and never
+        # DEV-2.0: touch the active span.
+        #
+        # @param digest [TraceDigest]
+        # @param data [Hash]
+        # @return [Boolean] `true` if injected successfully, `false` if no propagation style is configured
+        # @return [nil] in case of error, see `Datadog.logger` output for details.
+        def inject!(digest, data)
+          if digest.nil?
+            ::Datadog.logger.debug('Cannot inject distributed trace data: digest is nil.')
+            return nil
+          end
+
+          digest = digest.to_digest if digest.respond_to?(:to_digest)
+
+          result = false
+
+          # Inject all configured propagation styles
+          ::Datadog.configuration.tracing.distributed_tracing.propagation_inject_style.each do |style|
+            propagator = @propagation_styles[style]
+            begin
+              if propagator
+                propagator.inject!(digest, data)
+                result = true
+              end
+            rescue => e
+              result = nil
+              ::Datadog.logger.error(
+                "Error injecting distributed trace data. Cause: #{e} Location: #{Array(e.backtrace).first}"
+              )
+            end
+          end
+
+          result
+        end
+
+        # extract returns {TraceDigest} containing the distributed trace information.
+        # sampling priority defined in data.
+        #
+        # This method will never raise errors, but instead log them to `Datadog.logger`.
+        #
+        # @param data [Hash]
+        def extract(data)
+          trace_digest = nil
+          dd_trace_digest = nil
+
+          ::Datadog.configuration.tracing.distributed_tracing.propagation_extract_style.each do |style|
+            propagator = @propagation_styles[style]
+            next if propagator.nil?
+
+            begin
+              extracted_trace_digest = propagator.extract(data)
+            rescue => e
+              ::Datadog.logger.error(
+                'Error extracting distributed trace data. ' \
+              "Cause: #{e} Location: #{Array(e.backtrace).first}"
+              )
+            end
+
+            # Skip if no valid data was found
+            next if extracted_trace_digest.nil?
+
+            # Keep track of the Datadog extracted digest, we want to return it if we have it.
+            if extracted_trace_digest && style == Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG
+              dd_trace_digest = extracted_trace_digest
+            end
+
+            # No previously extracted trace data, use the one we just extracted
+            if trace_digest.nil?
+              trace_digest = extracted_trace_digest
+            else
+              unless trace_digest.trace_id == extracted_trace_digest.trace_id \
+                    && trace_digest.span_id == extracted_trace_digest.span_id
+                # We have two mismatched propagation contexts
+                ::Datadog.logger.debug do
+                  'Cannot extract distributed trace data: extracted styles differ, ' \
+                  "#{trace_digest.trace_id} != #{extracted_trace_digest.trace_id} && " \
+                  "#{trace_digest.span_id} != #{extracted_trace_digest.span_id}"
+                end
+
+                # It's safer to create a new context than to attach ourselves to the wrong context
+                return TraceDigest.new # Early return from the whole method
+              end
+            end
+          end
+
+          # Return the extracted trace digest if we found one or else a new empty digest.
+          # Always return the Datadog trace digest if one exists since it has more
+          # information than the B3 digest, e.g. origin, priority sampling values.
+          dd_trace_digest || trace_digest || nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,373 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Distributed
+      # W3C Trace Context propagator implementation, version 00.
+      # The trace is propagated through two fields: `traceparent` and `tracestate`.
+      # @see https://www.w3.org/TR/trace-context/
+      class TraceContext
+        TRACEPARENT_KEY = 'traceparent'
+        TRACESTATE_KEY = 'tracestate'
+        SPEC_VERSION = '00'
+
+        def initialize(
+          fetcher:,
+          traceparent_key: TRACEPARENT_KEY,
+          tracestate_key: TRACESTATE_KEY
+        )
+          @fetcher = fetcher
+          @traceparent_key = traceparent_key
+          @tracestate_key = tracestate_key
+        end
+
+        def inject!(digest, data)
+          return if digest.nil?
+
+          if (traceparent = build_traceparent(digest))
+            data[@traceparent_key] = traceparent
+
+            if (tracestate = build_tracestate(digest))
+              data[@tracestate_key] = tracestate
+            end
+          end
+
+          data
+        end
+
+        def extract(data)
+          fetcher = @fetcher.new(data)
+
+          trace_id, parent_id, sampled, trace_flags = extract_traceparent(fetcher[@traceparent_key])
+
+          return unless trace_id # Could not parse traceparent
+
+          tracestate, sampling_priority, origin, tags, unknown_fields = extract_tracestate(fetcher[@tracestate_key])
+
+          sampling_priority = parse_priority_sampling(sampled, sampling_priority)
+
+          TraceDigest.new(
+            span_id: parent_id,
+            trace_id: trace_id,
+            trace_origin: origin,
+            trace_sampling_priority: sampling_priority,
+            trace_distributed_tags: tags,
+            trace_flags: trace_flags,
+            trace_state: tracestate,
+            trace_state_unknown_fields: unknown_fields,
+          )
+        end
+
+        private
+
+        # Refinements to ensure newer rubies do not suffer performance impact
+        # by needing to use older APIs.
+        module Refine
+          # Backport `Regexp::match?` because it is measurably the most performant
+          # way to check if a string matches a regular expression.
+          unless Regexp.method_defined?(:match?)
+            refine ::Regexp do
+              def match?(*args)
+                !match(*args).nil?
+              end
+            end
+          end
+
+          unless String.method_defined?(:delete_prefix)
+            refine ::String do
+              def delete_prefix(prefix)
+                prefix = prefix.to_s
+                if rindex(prefix, 0)
+                  self[prefix.length..-1]
+                else
+                  dup
+                end
+              end
+            end
+          end
+        end
+        using Refine
+
+        # @see https://www.w3.org/TR/trace-context/#traceparent-header
+        def build_traceparent(digest)
+          build_traceparent_string(
+            digest.trace_id,
+            digest.span_id,
+            build_trace_flags(digest)
+          )
+        end
+
+        # For the current version (00), the traceparent has the following format:
+        #
+        # `"#{version}-#{trace_id}-#{parent_id}-#{trace_flags}"`
+        #
+        # Where:
+        #   * `version`: 2 hex-encoded digits, zero padded.
+        #   * `trace_id`: 32 hex-encoded digits, zero padded.
+        #   * `parent_id`: 16 hex-encoded digits, zero padded.
+        #   * `trace_flags`: 2 hex-encoded digits, zero padded.
+        #
+        # All hex values should be lowercase.
+        #
+        # @param trace_id [Integer] 128-bit
+        # @param parent_id [Integer] 64-bit
+        # @param trace_flags [Integer] 8-bit
+        def build_traceparent_string(trace_id, parent_id, trace_flags)
+          "00-#{format('%032x', trace_id)}-#{format('%016x', parent_id)}-#{format('%02x', trace_flags)}"
+        end
+
+        # Sets the trace flag to an existing `trace_flags`.
+        def build_trace_flags(digest)
+          trace_flags = digest.trace_flags || DEFAULT_TRACE_FLAGS
+
+          if digest.trace_sampling_priority
+            if Tracing::Sampling::PrioritySampler.sampled?(digest.trace_sampling_priority)
+              trace_flags |= TRACE_FLAGS_SAMPLED
+            else
+              trace_flags &= ~TRACE_FLAGS_SAMPLED
+            end
+          end
+
+          trace_flags
+        end
+
+        # @see https://www.w3.org/TR/trace-context/#tracestate-header
+        def build_tracestate(digest)
+          tracestate = String.new('dd=')
+          tracestate << "s:#{digest.trace_sampling_priority};" if digest.trace_sampling_priority
+          tracestate << "o:#{serialize_origin(digest.trace_origin)};" if digest.trace_origin
+
+          if digest.trace_distributed_tags
+            digest.trace_distributed_tags.each do |name, value|
+              tag = "t.#{serialize_tag_key(name)}:#{serialize_tag_value(value)};"
+
+              # If tracestate size limit is exceed, drop the remaining data.
+              # String#bytesize is used because only ASCII characters are allowed.
+              #
+              # We add 1 to the limit because of the trailing comma, which will be removed before returning.
+              break if tracestate.bytesize + tag.bytesize > (TRACESTATE_VALUE_SIZE_LIMIT + 1)
+
+              tracestate << tag
+            end
+          end
+
+          tracestate << digest.trace_state_unknown_fields if digest.trace_state_unknown_fields
+
+          # Is there any Datadog-specific information to propagate.
+          # Check for > 3 size because the empty prefix `dd=` has 3 characters.
+          if tracestate.size > 3
+            # Propagate upstream tracestate with `dd=...` appended to the list
+            tracestate.chop! # Removes trailing `;` from Datadog trace state string.
+
+            if digest.trace_state
+              # Delete existing `dd=` tracestate fields, if present.
+              vendors = split_tracestate(digest.trace_state)
+              vendors.reject! { |v| v.start_with?('dd=') }
+            end
+
+            if vendors && !vendors.empty?
+              # Ensure the list has at most 31 elements, as we need to prepend Datadog's
+              # entry and the limit is 32 elements total.
+              vendors = vendors[0..30]
+              "#{tracestate},#{vendors.join(',')}"
+            else
+              tracestate.to_s
+            end
+          else
+            digest.trace_state # Propagate upstream tracestate with no Datadog changes
+          end
+        end
+
+        # If any characters in <origin_value> are invalid, replace each invalid character with 0x5F (underscore).
+        # Invalid characters are: characters outside the ASCII range 0x20 to 0x7E, 0x2C (comma), and 0x3D (equals).
+        def serialize_origin(value)
+          # DEV: It's unlikely that characters will be out of range, as they mostly
+          # DEV: come from Datadog-controlled sources.
+          # DEV: Trying to `match?` is measurably faster than a `gsub` that does not match.
+          if INVALID_ORIGIN_CHARS.match?(value)
+            value.gsub(INVALID_ORIGIN_CHARS, '_')
+          else
+            value
+          end
+        end
+
+        # Serialize `_dd.p.{key}` by first removing the `_dd.p.` prefix.
+        # Then replacing invalid characters with `_`.
+        def serialize_tag_key(name)
+          key = name.delete_prefix(Tracing::Metadata::Ext::Distributed::TAGS_PREFIX)
+
+          # DEV: It's unlikely that characters will be out of range, as they mostly
+          # DEV: come from Datadog-controlled sources.
+          # DEV: Trying to `match?` is measurably faster than a `gsub` that does not match.
+          if INVALID_TAG_KEY_CHARS.match?(key)
+            key.gsub(INVALID_TAG_KEY_CHARS, '_')
+          else
+            key
+          end
+        end
+
+        # Replaces invalid characters with `_`, then replaces `=` with `:`.
+        def serialize_tag_value(value)
+          # DEV: It's unlikely that characters will be out of range, as they mostly
+          # DEV: come from Datadog-controlled sources.
+          # DEV: Trying to `match?` is measurably faster than a `gsub` that does not match.
+          ret = if INVALID_TAG_VALUE_CHARS.match?(value)
+                  value.gsub(INVALID_TAG_VALUE_CHARS, '_')
+                else
+                  value
+                end
+
+          # DEV: Checking for an unlikely '=' is faster than a no-op `tr!`.
+          ret.tr!('=', ':') if ret.include?('=')
+          ret
+        end
+
+        def extract_traceparent(traceparent)
+          trace_id, parent_id, trace_flags = parse_traceparent_string(traceparent)
+
+          # Return unless all traceparent fields are valid.
+          return unless trace_id && !trace_id.zero? && parent_id && !parent_id.zero? && trace_flags
+
+          sampled = parse_sampled_flag(trace_flags)
+
+          [trace_id, parent_id, sampled, trace_flags]
+        end
+
+        def parse_traceparent_string(traceparent)
+          return unless traceparent
+
+          version, trace_id, parent_id, trace_flags, extra = traceparent.strip.split('-')
+
+          return if version == INVALID_VERSION
+
+          # Extra fields are not allowed in version 00, but we have to be lenient for future versions.
+          return if version == SPEC_VERSION && extra
+
+          # Invalid field sizes
+          return if version.size != 2 || trace_id.size != 32 || parent_id.size != 16 || trace_flags.size != 2
+
+          [Integer(trace_id, 16), Integer(parent_id, 16), Integer(trace_flags, 16)]
+        rescue ArgumentError # Conversion to integer failed
+          nil
+        end
+
+        def parse_sampled_flag(trace_flags)
+          trace_flags & TRACE_FLAGS_SAMPLED
+        end
+
+        # @return [Array<String,Integer,String,Hash>] returns 4 values: tracestate, sampling_priority, origin, tags.
+        def extract_tracestate(tracestate)
+          return unless tracestate
+
+          vendors = split_tracestate(tracestate)
+
+          # Find Datadog's `dd=` tracestate field.
+          idx = vendors.index { |v| v.start_with?('dd=') }
+          return tracestate unless idx
+
+          # Delete `dd=` prefix
+          dd_tracestate = vendors.delete_at(idx)
+          dd_tracestate.slice!(0..2)
+
+          origin, sampling_priority, tags, unknown_fields = extract_datadog_fields(dd_tracestate)
+
+          [vendors.join(','), sampling_priority, origin, tags, unknown_fields]
+        end
+
+        def extract_datadog_fields(dd_tracestate)
+          sampling_priority = nil
+          origin = nil
+          tags = nil
+          unknown_fields = nil
+
+          # DEV: Since Ruby 2.6 `split` can receive a block, so `each` can be removed then.
+          dd_tracestate.split(';').each do |pair|
+            key, value = pair.split(':', 2)
+            case key
+            when 's'
+              sampling_priority = Integer(value) rescue nil
+            when 'o'
+              origin = value
+            when /^t\./
+              key.slice!(0..1) # Delete `t.` prefix
+
+              # Ignore the high order 64 bit trace id propagation tag to avoid confusion,
+              # the single source of truth is from traceparent
+              next if key == Tracing::Metadata::Ext::Distributed::TID
+
+              value = deserialize_tag_value(value)
+
+              tags ||= {}
+              tags["#{Tracing::Metadata::Ext::Distributed::TAGS_PREFIX}#{key}"] = value
+            else
+              unknown_fields ||= String.new
+              unknown_fields << pair
+              unknown_fields << ';'
+            end
+          end
+
+          [origin, sampling_priority, tags, unknown_fields]
+        end
+
+        # Restore `:` back to `=`.
+        def deserialize_tag_value(value)
+          value.tr!(':', '=')
+          value
+        end
+
+        # If `sampled` and `sampling_priority` disagree, `sampled` overrides the decision.
+        # @return [Integer] one of the {Datadog::Tracing::Sampling::Ext::Priority} values
+        def parse_priority_sampling(sampled, sampling_priority)
+          # If both fields agree
+          if sampling_priority &&
+              (!Tracing::Sampling::PrioritySampler.sampled?(sampling_priority) && sampled == 0 || # Both drop
+                Tracing::Sampling::PrioritySampler.sampled?(sampling_priority) && sampled == 1) # Both keep
+
+            return sampling_priority # Return the richer `sampling_priority`
+          end
+
+          sampled # Sampled flag trumps `sampling_priority` on conflict
+        end
+
+        def split_tracestate(tracestate)
+          tracestate.split(/[ \t]*,[ \t]*/)[0..31]
+        end
+
+        # Version 0xFF is invalid as per spec
+        # @see https://www.w3.org/TR/trace-context/#version
+        INVALID_VERSION = 'ff'
+        private_constant :INVALID_VERSION
+
+        # Empty 8-bit `trace-flags`.
+        # @see https://www.w3.org/TR/trace-context/#trace-flags
+        DEFAULT_TRACE_FLAGS = 0b00000000
+        private_constant :DEFAULT_TRACE_FLAGS
+
+        # Bit-mask for `trace-flags` that represents a sampled span (sampled==true).
+        # @see https://www.w3.org/TR/trace-context/#trace-flags
+        TRACE_FLAGS_SAMPLED = 0b00000001
+        private_constant :TRACE_FLAGS_SAMPLED
+
+        # The limit is inclusive: sizes *greater* than 256 are disallowed.
+        # @see https://www.w3.org/TR/trace-context/#value
+        TRACESTATE_VALUE_SIZE_LIMIT = 256
+        private_constant :TRACESTATE_VALUE_SIZE_LIMIT
+
+        # Replace all characters with `_`, except ASCII characters 0x20-0x7E.
+        # Additionally, `,`, ';', and `=` must also be replaced by `_`.
+        INVALID_ORIGIN_CHARS = /[\u0000-\u0019,;=\u007F-\u{10FFFF}]/.freeze
+        private_constant :INVALID_ORIGIN_CHARS
+
+        # Replace all characters with `_`, except ASCII characters 0x21-0x7E.
+        # Additionally, `,` and `=` must also be replaced by `_`.
+        INVALID_TAG_KEY_CHARS = /[\u0000-\u0020,=\u007F-\u{10FFFF}]/.freeze
+        private_constant :INVALID_TAG_KEY_CHARS
+
+        # Replace all characters with `_`, except ASCII characters 0x20-0x7E.
+        # Additionally, `,`, ':' and `;` must also be replaced by `_`.
+        INVALID_TAG_VALUE_CHARS = /[\u0000-\u001F,:;\u007F-\u{10FFFF}]/.freeze
+        private_constant :INVALID_TAG_VALUE_CHARS
+      end
+    end
+  end
+end

data/lib/datadog/tracing/event.rb

@@ -1,6 +1,4 @@
-# typed: false
-
-require 'datadog/core'
+require_relative '../core'
 
 module Datadog
   module Tracing
@@ -65,7 +63,8 @@ module Datadog
             block.call(*args)
           rescue StandardError => e
             Datadog.logger.debug do
-              "Error while handling '#{name}' event with '#{block}': #{e.message} at #{Array(e.backtrace).first}"
+              "Error while handling '#{name}' event with '#{block}': #{e.class.name} #{e.message} " \
+              "at #{Array(e.backtrace).first}"
             end
           end
         end

data/lib/datadog/tracing/flush.rb

@@ -1,73 +1,93 @@
-# typed: true
-
 module Datadog
   module Tracing
     module Flush
-      # Consumes only completed traces (where all spans have finished)
-      class Finished
-        # Consumes and returns completed traces (where all spans have finished)
-        # from the provided \trace_op, if any.
+      # Consumes and returns a {TraceSegment} to be flushed, from
+      # the provided {TraceSegment}.
+      #
+      # Only finished spans are consumed. Any spans consumed are
+      # removed from +trace_op+ as a side effect. Unfinished spans are
+      # unaffected.
+      #
+      # @abstract
+      class Base
+        # Consumes and returns a {TraceSegment} to be flushed, from
+        # the provided {TraceSegment}.
         #
-        # Any traces consumed are removed from +trace_op+ as a side effect.
+        # Only finished spans are consumed. Any spans consumed are
+        # removed from +trace_op+ as a side effect. Unfinished spans are
+        # unaffected.
         #
+        # @param [TraceOperation] trace_op
         # @return [TraceSegment] trace to be flushed, or +nil+ if the trace is not finished
         def consume!(trace_op)
-          return unless full_flush?(trace_op)
+          return unless flush?(trace_op)
 
           get_trace(trace_op)
         end
 
-        def full_flush?(trace_op)
-          trace_op && trace_op.sampled? && trace_op.finished?
+        # Should we consume spans from the +trace_op+?
+        # @abstract
+        def flush?(trace_op)
+          raise NotImplementedError
         end
 
         protected
 
+        # Consumes all finished spans from trace.
+        # @return [TraceSegment]
         def get_trace(trace_op)
-          trace_op.flush!
+          trace_op.flush! do |spans|
+            spans.select! { |span| single_sampled?(span) } unless trace_op.sampled?
+
+            spans
+          end
+        end
+
+        # Single Span Sampling has chosen to keep this span
+        # regardless of the trace-level sampling decision
+        def single_sampled?(span)
+          span.get_metric(Sampling::Span::Ext::TAG_MECHANISM) == Sampling::Ext::Mechanism::SPAN_SAMPLING_RATE
+        end
+      end
+
+      # Consumes and returns completed traces (where all spans have finished),
+      # if any, from the provided +trace_op+.
+      #
+      # Spans consumed are removed from +trace_op+ as a side effect.
+      class Finished < Base
+        # Are all spans finished?
+        def flush?(trace_op)
+          trace_op && trace_op.finished?
         end
       end
 
-      # Performs partial trace flushing to avoid large traces residing in memory for too long
-      class Partial
+      # Consumes and returns completed or partially completed
+      # traces from the provided +trace_op+, if any.
+      #
+      # Partial trace flushing avoids large traces residing in memory for too long.
+      #
+      # Partially completed traces, where not all spans have finished,
+      # will only be returned if there are at least
+      # +@min_spans_for_partial+ finished spans.
+      #
+      # Spans consumed are removed from +trace_op+ as a side effect.
+      class Partial < Base
         # Start flushing partial trace after this many active spans in one trace
         DEFAULT_MIN_SPANS_FOR_PARTIAL_FLUSH = 500
 
         attr_reader :min_spans_for_partial
 
         def initialize(options = {})
+          super()
           @min_spans_for_partial = options.fetch(:min_spans_before_partial_flush, DEFAULT_MIN_SPANS_FOR_PARTIAL_FLUSH)
         end
 
-        # Consumes and returns completed or partially completed
-        # traces from the provided +trace_op+, if any.
-        #
-        # Partially completed traces, where not all spans have finished,
-        # will only be returned if there are at least
-        # +@min_spans_for_partial+ finished spans.
-        #
-        # Any spans consumed are removed from +trace_op+ as a side effect.
-        #
-        # @return [TraceSegment] partial or complete trace to be flushed, or +nil+ if no spans are finished
-        def consume!(trace_op)
-          return unless partial_flush?(trace_op)
-
-          get_trace(trace_op)
-        end
-
-        def partial_flush?(trace_op)
-          return false unless trace_op.sampled?
+        def flush?(trace_op)
           return true if trace_op.finished?
           return false if trace_op.finished_span_count < @min_spans_for_partial
 
           true
         end
-
-        protected
-
-        def get_trace(trace_op)
-          trace_op.flush!
-        end
       end
     end
   end

data/lib/datadog/tracing/metadata/analytics.rb

@@ -1,7 +1,5 @@
-# typed: true
-
-require 'datadog/tracing/analytics'
-require 'datadog/tracing/metadata/ext'
+require_relative '../analytics'
+require_relative 'ext'
 
 module Datadog
   module Tracing

data/lib/datadog/tracing/metadata/errors.rb

@@ -1,8 +1,6 @@
-# typed: false
+require_relative '../../core/error'
 
-require 'datadog/core/error'
-
-require 'datadog/tracing/metadata/ext'
+require_relative 'ext'
 
 module Datadog
   module Tracing