datadog 2.0.0.beta1 → 2.0.0.rc1

data/lib/datadog/tracing/correlation.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative 'utils'
-require_relative 'metadata/ext'
 require_relative '../core/logging/ext'
 
 module Datadog
@@ -36,11 +35,11 @@ module Datadog
           version: nil
         )
           # Dup and freeze strings so they aren't modified by reference.
-          @env = Core::Utils::SafeDup.frozen_dup(env || Datadog.configuration.env)
-          @service = Core::Utils::SafeDup.frozen_dup(service || Datadog.configuration.service)
+          @env = env || Datadog.configuration.env
+          @service = service || Datadog.configuration.service
           @span_id = (span_id || 0).to_s
           @trace_id = trace_id || 0
-          @version = Core::Utils::SafeDup.frozen_dup(version || Datadog.configuration.version)
+          @version = version || Datadog.configuration.version
         end
 
         def to_h

data/lib/datadog/tracing/remote.rb

@@ -12,12 +12,16 @@ module Datadog
       class << self
         PRODUCT = 'APM_TRACING'
 
+        CAPABILITIES = [
+          1 << 29 # APM_TRACING_SAMPLE_RULES: Dynamic trace sampling rules configuration
+        ].freeze
+
         def products
           [PRODUCT]
         end
 
         def capabilities
-          [] # No capabilities advertised
+          CAPABILITIES
         end
 
         def process_config(config, content)

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

@@ -40,7 +40,7 @@ module Datadog
           DEFAULT = '-0'
           # The sampling rate received in the agent's http response.
           AGENT_RATE = '-1'
-          # Sampling rule or sampling rate based on tracer config.
+          # Locally configured rule.
           TRACE_SAMPLING_RULE = '-3'
           # User directly sets sampling priority via {Tracing.reject!} or {Tracing.keep!},
           # or by a custom sampler implementation.
@@ -49,6 +49,10 @@ module Datadog
           ASM = '-5'
           # Single Span Sampled.
           SPAN_SAMPLING_RATE = '-8'
+          # Dynamically configured rule, explicitly created by the user.
+          REMOTE_USER_RULE = '-11'
+          # Dynamically configured  rule, automatically generated by Datadog.
+          REMOTE_DYNAMIC_RULE = '-12'
         end
       end
     end

data/lib/datadog/tracing/sampling/matcher.rb

@@ -6,6 +6,9 @@ module Datadog
       # Checks if a trace conforms to a matching criteria.
       # @abstract
       class Matcher
+        # Pattern that matches any string
+        MATCH_ALL_PATTERN = '*'
+
         # Returns `true` if the trace should conforms to this rule, `false` otherwise
         #
         # @param [TraceOperation] trace
@@ -13,51 +16,97 @@ module Datadog
         def match?(trace)
           raise NotImplementedError
         end
-      end
 
-      # A {Datadog::Sampling::Matcher} that supports matching a trace by
-      # trace name and/or service name.
-      class SimpleMatcher < Matcher
-        # Returns `true` for case equality (===) with any object
+        # Converts a glob pattern String to a case-insensitive String matcher object.
+        # The match object will only return `true` if it matches the complete String.
+        #
+        # The following special characters are supported:
+        # - `?` matches any single character
+        # - `*` matches any substring
+        #
+        # @param glob [String]
+        # @return [#match?(String)]
+        def self.glob_to_regex(glob)
+          # Optimization for match-all case
+          return MATCH_ALL if glob == MATCH_ALL_PATTERN
+
+          # Ensure no undesired characters are treated as regex.
+          glob = Regexp.quote(glob)
+
+          # Our valid special characters, `?` and `*`, were just escaped
+          # by `Regexp.quote` above. We need to unescape them:
+          glob.gsub!('\?', '.') # Any single character
+          glob.gsub!('\*', '.*') # Any substring
+
+          # Patterns have to match the whole input string
+          glob = "\\A#{glob}\\z"
+
+          Regexp.new(glob, Regexp::IGNORECASE)
+        end
+
+        # Returns `true` for any input
         MATCH_ALL = Class.new do
-          # DEV: A class that implements `#===` is ~20% faster than
-          # DEV: a `Proc` that always returns `true`.
-          def ===(other)
+          def match?(_other)
             true
           end
+
+          def inspect
+            "MATCH_ALL:Matcher('*')"
+          end
         end.new
+      end
 
-        attr_reader :name, :service
+      # A {Datadog::Sampling::Matcher} that supports matching a trace by
+      # trace name and/or service name.
+      class SimpleMatcher < Matcher
+        attr_reader :name, :service, :resource, :tags
 
         # @param name [String,Regexp,Proc] Matcher for case equality (===) with the trace name,
         #             defaults to always match
         # @param service [String,Regexp,Proc] Matcher for case equality (===) with the service name,
         #                defaults to always match
-        def initialize(name: MATCH_ALL, service: MATCH_ALL)
+        # @param resource [String,Regexp,Proc] Matcher for case equality (===) with the resource name,
+        #                defaults to always match
+        def initialize(
+          name: MATCH_ALL_PATTERN,
+          service: MATCH_ALL_PATTERN,
+          resource: MATCH_ALL_PATTERN,
+          tags: {}
+        )
           super()
-          @name = name
-          @service = service
+
+          name = Matcher.glob_to_regex(name)
+          service = Matcher.glob_to_regex(service)
+          resource = Matcher.glob_to_regex(resource)
+          tags = tags.transform_values { |matcher| Matcher.glob_to_regex(matcher) }
+
+          @name = name || Datadog::Tracing::Sampling::Matcher::MATCH_ALL
+          @service = service || Datadog::Tracing::Sampling::Matcher::MATCH_ALL
+          @resource = resource || Datadog::Tracing::Sampling::Matcher::MATCH_ALL
+          @tags = tags
         end
 
         def match?(trace)
-          name === trace.name && service === trace.service
+          @name.match?(trace.name) &&
+            @service.match?(trace.service) &&
+            @resource.match?(trace.resource) &&
+            tags_match?(trace)
         end
-      end
 
-      # A {Datadog::Tracing::Sampling::Matcher} that allows for arbitrary trace matching
-      # based on the return value of a provided block.
-      class ProcMatcher < Matcher
-        attr_reader :block
+        private
 
-        # @yield [name, service] Provides trace name and service to the block
-        # @yieldreturn [Boolean] Whether the trace conforms to this matcher
-        def initialize(&block)
-          super()
-          @block = block
-        end
+        # Match against the trace tags and metrics.
+        def tags_match?(trace)
+          @tags.all? do |name, matcher|
+            tag = trace.get_tag(name)
 
-        def match?(trace)
-          block.call(trace.name, trace.service)
+            # Format metrics as strings, to allow for partial number matching (/4.*/ matching '400', '404', etc.).
+            # Because metrics are floats, we use the '%g' format specifier to avoid trailing zeros, which
+            # can affect exact string matching (e.g. '400' matching '400.0').
+            tag = format('%g', tag) if tag.is_a?(Numeric)
+
+            matcher.match?(tag)
+          end
         end
       end
     end

data/lib/datadog/tracing/sampling/rule.rb

@@ -10,13 +10,18 @@ module Datadog
       # a specific criteria and what sampling strategy to
       # apply in case of a positive match.
       class Rule
-        attr_reader :matcher, :sampler
+        PROVENANCE_LOCAL = :local
+        PROVENANCE_REMOTE_USER = :customer
+        PROVENANCE_REMOTE_DYNAMIC = :dynamic
+
+        attr_reader :matcher, :sampler, :provenance
 
         # @param [Matcher] matcher A matcher to verify trace conformity against
         # @param [Sampler] sampler A sampler to be consulted on a positive match
-        def initialize(matcher, sampler)
+        def initialize(matcher, sampler, provenance)
           @matcher = matcher
           @sampler = sampler
+          @provenance = provenance
         end
 
         # Evaluates if the provided `trace` conforms to the `matcher`.
@@ -51,9 +56,27 @@ module Datadog
         # @param name [String,Regexp,Proc] Matcher for case equality (===) with the trace name, defaults to always match
         # @param service [String,Regexp,Proc] Matcher for case equality (===) with the service name,
         #                defaults to always match
+        # @param resource [String,Regexp,Proc] Matcher for case equality (===) with the resource name,
+        #                defaults to always match
         # @param sample_rate [Float] Sampling rate between +[0,1]+
-        def initialize(name: SimpleMatcher::MATCH_ALL, service: SimpleMatcher::MATCH_ALL, sample_rate: 1.0)
-          super(SimpleMatcher.new(name: name, service: service), RateSampler.new(sample_rate))
+        def initialize(
+          name: SimpleMatcher::MATCH_ALL_PATTERN, service: SimpleMatcher::MATCH_ALL_PATTERN,
+          resource: SimpleMatcher::MATCH_ALL_PATTERN, tags: {},
+          provenance: Rule::PROVENANCE_LOCAL,
+          sample_rate: 1.0
+        )
+          # We want to allow 0.0 to drop all traces, but {Datadog::Tracing::Sampling::RateSampler}
+          # considers 0.0 an invalid rate and falls back to 100% sampling.
+          #
+          # We address that here by not setting the rate in the constructor,
+          # but using the setter method.
+          #
+          # We don't want to make this change directly to {Datadog::Tracing::Sampling::RateSampler}
+          # because it breaks its current contract to existing users.
+          sampler = RateSampler.new
+          sampler.sample_rate = sample_rate
+
+          super(SimpleMatcher.new(name: name, service: service, resource: resource, tags: tags), sampler, provenance)
         end
       end
     end

data/lib/datadog/tracing/sampling/rule_sampler.rb

@@ -62,7 +62,15 @@ module Datadog
             kwargs = {
               name: rule['name'],
               service: rule['service'],
+              resource: rule['resource'],
+              tags: rule['tags'],
               sample_rate: sample_rate,
+              provenance: if (provenance = rule['provenance'])
+                            # `Rule::PROVENANCE_*` values are symbols, so convert strings to match
+                            provenance.to_sym
+                          else
+                            Rule::PROVENANCE_LOCAL
+                          end,
             }
 
             kwargs.compact!
@@ -116,7 +124,17 @@ module Datadog
           rate_limiter.allow?(1).tap do |allowed|
             set_priority(trace, allowed)
             set_limiter_metrics(trace, rate_limiter.effective_rate)
-            trace.set_tag(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER, Ext::Decision::TRACE_SAMPLING_RULE)
+
+            provenance = case rule.provenance
+                         when Rule::PROVENANCE_REMOTE_USER
+                           Ext::Decision::REMOTE_USER_RULE
+                         when Rule::PROVENANCE_REMOTE_DYNAMIC
+                           Ext::Decision::REMOTE_DYNAMIC_RULE
+                         else
+                           Ext::Decision::TRACE_SAMPLING_RULE
+                         end
+
+            trace.set_tag(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER, provenance)
           end
         rescue StandardError => e
           Datadog.logger.error(

data/lib/datadog/tracing/sampling/span/matcher.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../matcher'
+
 module Datadog
   module Tracing
     module Sampling
@@ -31,29 +33,19 @@ module Datadog
           # @param name_pattern [String] a pattern to be matched against {SpanOperation#name}
           # @param service_pattern [String] a pattern to be matched against {SpanOperation#service}
           def initialize(name_pattern: MATCH_ALL_PATTERN, service_pattern: MATCH_ALL_PATTERN)
-            @name = pattern_to_regex(name_pattern)
-            @service = pattern_to_regex(service_pattern)
+            @name = Sampling::Matcher.glob_to_regex(name_pattern)
+            @service = Sampling::Matcher.glob_to_regex(service_pattern)
           end
 
-          # {Regexp#match?} was added in Ruby 2.4, and it's measurably
-          # the least costly way to get a boolean result for a Regexp match.
-          # @see https://www.ruby-lang.org/en/news/2016/12/25/ruby-2-4-0-released/
-          if Regexp.method_defined?(:match?)
-            # Returns `true` if the span conforms to the configured patterns,
-            # `false` otherwise
-            #
-            # @param [SpanOperation] span
-            # @return [Boolean]
-            def match?(span)
-              # Matching is performed at the end of the lifecycle of a Span,
-              # thus both `name` and `service` are guaranteed to be not `nil`.
-              @name.match?(span.name) && @service.match?(span.service)
-            end
-          else
-            # DEV: Remove when support for Ruby 2.3 and older is removed.
-            def match?(span)
-              @name === span.name && @service === span.service
-            end
+          # Returns `true` if the span conforms to the configured patterns,
+          # `false` otherwise
+          #
+          # @param [SpanOperation] span
+          # @return [Boolean]
+          def match?(span)
+            # Matching is performed at the end of the lifecycle of a Span,
+            # thus both `name` and `service` are guaranteed to be not `nil`.
+            @name.match?(span.name) && @service.match?(span.service)
           end
 
           def ==(other)
@@ -62,26 +54,6 @@ module Datadog
             name == other.name &&
               service == other.service
           end
-
-          private
-
-          # @param pattern [String]
-          # @return [Regexp]
-          def pattern_to_regex(pattern)
-            # Ensure no undesired characters are treated as regex.
-            # Our valid special characters, `?` and `*`,
-            # will be escaped so...
-            pattern = Regexp.quote(pattern)
-
-            # ...we account for that here:
-            pattern.gsub!('\?', '.') # Any single character
-            pattern.gsub!('\*', '.*') # Any substring
-
-            # Patterns have to match the whole input string
-            pattern = "\\A#{pattern}\\z"
-
-            Regexp.new(pattern)
-          end
         end
       end
     end

data/lib/datadog/tracing/span.rb

@@ -26,6 +26,7 @@ module Datadog
         :parent_id,
         :resource,
         :service,
+        :links,
         :type,
         :start_time,
         :status,
@@ -58,7 +59,8 @@ module Datadog
         status: 0,
         type: nil,
         trace_id: nil,
-        service_entry: nil
+        service_entry: nil,
+        links: nil
       )
         @name = Core::Utils::SafeDup.frozen_or_dup(name)
         @service = Core::Utils::SafeDup.frozen_or_dup(service)
@@ -86,6 +88,8 @@ module Datadog
 
         @service_entry = service_entry
 
+        @links = links || []
+
         # Mark with the service entry span metric, if applicable
         set_metric(Metadata::Ext::TAG_TOP_LEVEL, 1.0) if service_entry
       end
@@ -136,7 +140,8 @@ module Datadog
           service: @service,
           span_id: @id,
           trace_id: @trace_id,
-          type: @type
+          type: @type,
+          span_links: @links.map(&:to_hash)
         }
 
         if stopped?

data/lib/datadog/tracing/span_link.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    # SpanLink represents a causal link between two spans.
+    # @public_api
+    class SpanLink
+      # @!attribute [r] span_id
+      #   Datadog id for the currently active span.
+      #   @return [Integer]
+      attr_reader :span_id
+
+      # @!attribute [r] trace_id
+      #   Datadog id for the currently active trace.
+      #   @return [Integer]
+      attr_reader :trace_id
+
+      # @!attribute [r] attributes
+      #   Datadog-specific tags that support richer distributed tracing association.
+      #   @return [Hash<String,String>]
+      attr_reader :attributes
+
+      # @!attribute [r] trace_flags
+      #   The W3C "trace-flags" extracted from a distributed context. This field is an 8-bit unsigned integer.
+      #   @return [Integer]
+      #   @see https://www.w3.org/TR/trace-context/#trace-flags
+      attr_reader :trace_flags
+
+      # @!attribute [r] trace_state
+      #   The W3C "tracestate" extracted from a distributed context.
+      #   This field is a string representing vendor-specific distribution data.
+      #   The `dd=` entry is removed from `trace_state` as its value is dynamically calculated
+      #   on every propagation injection.
+      #   @return [String]
+      #   @see https://www.w3.org/TR/trace-context/#tracestate-header
+      attr_reader :trace_state
+
+      # @!attribute [r] dropped_attributes
+      #   The number of attributes that were discarded due to serialization limits.
+      #   @return [Integer]
+      attr_reader :dropped_attributes
+
+      def initialize(
+        digest,
+        attributes: nil
+      )
+        @span_id = digest.span_id
+        @trace_id = digest.trace_id
+        @trace_flags = if digest.trace_sampling_priority.nil?
+                         nil
+                       elsif digest.trace_sampling_priority > 0
+                         1
+                       else
+                         0
+                       end
+        @trace_state = digest.trace_state && digest.trace_state.dup
+        @dropped_attributes = 0
+        @attributes = (attributes && attributes.dup) || {}
+      end
+
+      def to_hash
+        h = {
+          span_id: @span_id || 0,
+          trace_id: Tracing::Utils::TraceId.to_low_order(@trace_id) || 0,
+        }
+        # Optimization: Hash non empty attributes
+        if @trace_id.to_i > Tracing::Utils::EXTERNAL_MAX_ID
+          h[:trace_id_high] =
+            Tracing::Utils::TraceId.to_high_order(@trace_id)
+        end
+        unless @attributes&.empty?
+          h[:attributes] = {}
+          @attributes.each do |k1, v1|
+            Tracing::Utils.serialize_attribute(k1, v1).each do |new_k1, value|
+              h[:attributes][new_k1] = value.to_s
+            end
+          end
+        end
+        h[:dropped_attributes_count] = @dropped_attributes if @dropped_attributes > 0
+        h[:tracestate] = @trace_state if @trace_state
+        # If traceflags set, the high bit (bit 31) should be set to 1 (uint32).
+        # This helps us distinguish between when the sample decision is zero or not set
+        h[:flags] = if @trace_flags.nil?
+                      0
+                    else
+                      @trace_flags | (1 << 31)
+                    end
+        h
+      end
+    end
+  end
+end

data/lib/datadog/tracing/span_operation.rb

@@ -35,9 +35,7 @@ module Datadog
         :start_time,
         :trace_id,
         :type
-
-      attr_accessor \
-        :status
+      attr_accessor :links, :status
 
       def initialize(
         name,
@@ -49,7 +47,8 @@ module Datadog
         start_time: nil,
         tags: nil,
         trace_id: nil,
-        type: nil
+        type: nil,
+        links: nil
       )
         # Ensure dynamically created strings are UTF-8 encoded.
         #
@@ -66,6 +65,8 @@ module Datadog
         @trace_id = trace_id || Tracing::Utils::TraceId.next_id
 
         @status = 0
+        # stores array of span links
+        @links = links || []
 
         # start_time and end_time track wall clock. In Ruby, wall clock
         # has less accuracy than monotonic clock, so if possible we look to only use wall clock
@@ -452,6 +453,7 @@ module Datadog
           status: @status,
           type: @type,
           trace_id: @trace_id,
+          links: @links,
           service_entry: parent.nil? || (service && parent.service != service)
         )
       end

data/lib/datadog/tracing/trace_operation.rb

@@ -8,6 +8,7 @@ require_relative 'metadata/tagging'
 require_relative 'sampling/ext'
 require_relative 'span_operation'
 require_relative 'trace_digest'
+require_relative 'correlation'
 require_relative 'trace_segment'
 require_relative 'utils'
 
@@ -306,6 +307,17 @@ module Datadog
         ).freeze
       end
 
+      def to_correlation
+        # Resolve current span ID
+        span_id = @active_span && @active_span.id
+        span_id ||= @parent_span_id unless finished?
+
+        Correlation::Identifier.new(
+          trace_id: @id,
+          span_id: span_id
+        )
+      end
+
       # Returns a copy of this trace suitable for forks (w/o spans.)
       # Used for continuation of traces across forks.
       def fork_clone

data/lib/datadog/tracing/tracer.rb

@@ -224,9 +224,10 @@ module Datadog
       # @return [Datadog::Tracing::Correlation::Identifier] correlation object
       def active_correlation(key = nil)
         trace = active_trace(key)
-        Correlation.identifier_from_digest(
-          trace && trace.to_digest
-        )
+
+        return Datadog::Tracing::Correlation::Identifier.new unless trace
+
+        trace.to_correlation
       end
 
       # Setup a new trace to continue from where another

data/lib/datadog/tracing/transport/serializable_trace.rb

@@ -58,7 +58,7 @@ module Datadog
         def to_msgpack(packer = nil)
           packer ||= MessagePack::Packer.new
 
-          number_of_elements_to_write = 10
+          number_of_elements_to_write = 11
 
           if span.stopped?
             packer.write_map_header(number_of_elements_to_write + 2) # Set header with how many elements in the map
@@ -93,6 +93,8 @@ module Datadog
           packer.write(span.meta)
           packer.write('metrics')
           packer.write(span.metrics)
+          packer.write('span_links')
+          packer.write(span.links.map(&:to_hash))
           packer.write('error')
           packer.write(span.status)
           packer

data/lib/datadog/tracing/utils.rb

@@ -45,6 +45,22 @@ module Datadog
         @id_rng = Random.new
       end
 
+      # Serialize values into Datadog span tags and metrics.
+      # Notably, arrays are exploded into many keys, each with
+      # a numeric suffix representing the array index, for example:
+      # `'foo' => ['a','b']` becomes `'foo.0' => 'a', 'foo.1' => 'b'`
+      def self.serialize_attribute(key, value)
+        if value.is_a?(Array)
+          value.flat_map.with_index do |v, idx|
+            serialize_attribute("#{key}.#{idx}", v)
+          end
+        elsif value.is_a?(TrueClass) || value.is_a?(FalseClass)
+          [[key, value.to_s]]
+        else
+          [[key, value]]
+        end
+      end
+
       private_class_method :id_rng, :reset!
 
       # The module handles bitwise operation for trace id

data/lib/datadog/version.rb

@@ -5,7 +5,7 @@ module Datadog
     MAJOR = 2
     MINOR = 0
     PATCH = 0
-    PRE = 'beta1'
+    PRE = 'rc1'
     BUILD = nil
     # PRE and BUILD above are modified for dev gems during gem build GHA workflow