datadog 2.8.0 → 2.39.0

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

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require_relative 'ext'
-require_relative 'all_sampler'
-require_relative 'rate_sampler'
-require_relative 'rate_by_service_sampler'
+require_relative "ext"
+require_relative "all_sampler"
+require_relative "rate_sampler"
+require_relative "rate_by_service_sampler"
 
 module Datadog
   module Tracing
@@ -60,7 +60,9 @@ module Datadog
         ensure
           if trace.sampling_priority && trace.sampling_priority > 0
             # Don't modify decision if priority was set upstream.
-            if !distributed_sampling_priority && !trace.has_tag?(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER)
+            # Steep: https://github.com/soutaro/steep/issues/1971
+            if !distributed_sampling_priority && # steep:ignore FallbackAny
+                !trace.has_tag?(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER)
               # If no sampling priority being assigned at this point, a custom
               # sampler implementation is configured: this means the user has
               # full control over the sampling decision.
@@ -75,6 +77,19 @@ module Datadog
           end
         end
 
+        def reconsider_sample_resource!(trace)
+          return unless @priority_sampler.respond_to?(:reconsider_sample_resource!)
+
+          preserving_sampling(trace) do
+            @priority_sampler.reconsider_sample_resource!(trace)
+          end
+        end
+
+        def resource_sampling?
+          @priority_sampler.respond_to?(:resource_sampling?) &&
+            @priority_sampler.resource_sampling?
+        end
+
         # (see Datadog::Tracing::Sampling::RateByServiceSampler#update)
         def update(rate_by_service, decision: nil)
           @priority_sampler.update(rate_by_service, decision: decision)

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'sampler'
-require_relative 'rate_sampler'
+require_relative "sampler"
+require_relative "rate_sampler"
 
 module Datadog
   module Tracing
@@ -14,7 +14,7 @@ module Datadog
         def initialize(default_key, default_rate = 1.0, decision: nil, &block)
           super()
 
-          raise ArgumentError, 'No resolver given!' unless block
+          raise ArgumentError, "No resolver given!" unless block
 
           @default_key = default_key
           @resolver = block

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

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require_relative 'rate_by_key_sampler'
+require_relative "rate_by_key_sampler"
 
 module Datadog
   module Tracing
     module Sampling
       # {Datadog::Tracing::Sampling::RateByServiceSampler} samples different services at different rates
       class RateByServiceSampler < RateByKeySampler
-        DEFAULT_KEY = 'service:,env:'
+        DEFAULT_KEY = "service:,env:"
 
         def initialize(default_rate = 1.0, env: nil, decision: Datadog::Tracing::Sampling::Ext::Decision::DEFAULT)
           super(

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'sampler'
-require_relative '../utils'
+require_relative "sampler"
+require_relative "../../core/knuth_sampler"
 
 module Datadog
   module Tracing
@@ -15,39 +15,29 @@ module Datadog
         # reduce the instrumentation footprint.
         #
         # @param sample_rate [Numeric] the sample rate between 0.0 and 1.0, inclusive.
-        #   0.0 means that no trace will be sampled; 1.0 means that all traces will be  sampled.
+        #   0.0 means that no trace will be sampled; 1.0 means that all traces will be sampled.
         def initialize(sample_rate = 1.0, decision: nil)
           super()
-
-          unless sample_rate >= 0.0 && sample_rate <= 1.0
-            Datadog.logger.warn('sample rate is not between 0 and 1, falling back to 1')
-            sample_rate = 1.0
-          end
-
-          self.sample_rate = sample_rate
-
+          @sampler = Core::KnuthSampler.new(sample_rate, knuth_factor: KNUTH_FACTOR)
           @decision = decision
         end
 
         def sample_rate(*_)
-          @sample_rate
+          @sampler.rate
         end
 
         def sample_rate=(sample_rate)
-          @sample_rate = sample_rate
-          @sampling_id_threshold = sample_rate * Tracing::Utils::EXTERNAL_MAX_ID
+          @sampler = Core::KnuthSampler.new(sample_rate, knuth_factor: KNUTH_FACTOR)
         end
 
         def sample?(trace)
-          ((trace.id * KNUTH_FACTOR) % Tracing::Utils::EXTERNAL_MAX_ID) <= @sampling_id_threshold
+          @sampler.sample?(trace.id)
         end
 
         def sample!(trace)
-          sampled = sample?(trace)
-
-          return false unless sampled
+          return false unless sample?(trace)
 
-          trace.sample_rate = @sample_rate
+          trace.sample_rate = sample_rate
           trace.set_tag(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER, @decision) if @decision
 
           true

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative 'matcher'
-require_relative 'rate_sampler'
-require_relative '../../core/telemetry/logger'
+require_relative "matcher"
+require_relative "rate_sampler"
+require_relative "../../core/telemetry/logger"
 
 module Datadog
   module Tracing
@@ -34,9 +34,9 @@ module Datadog
           @matcher.match?(trace)
         rescue => e
           Datadog.logger.error(
-            "Matcher failed. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+            "Matcher failed. Cause: #{e.class}: #{e.message} Source: #{Array(e.backtrace).first}"
           )
-          Datadog::Core::Telemetry::Logger.report(e, description: 'Matcher failed')
+          Datadog::Core::Telemetry::Logger.report(e, description: "Matcher failed")
           nil
         end
 

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

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require_relative 'ext'
-require_relative '../../core/rate_limiter'
-require_relative 'rule'
-require_relative '../../core/telemetry/logger'
+require_relative "ext"
+require_relative "../../core/rate_limiter"
+require_relative "rule"
+require_relative "../../core/telemetry/logger"
 
 module Datadog
   module Tracing
@@ -30,31 +30,32 @@ module Datadog
           default_sampler: nil
         )
           @rules = if default_sample_rate && !default_sampler
-                     # Add to the end of the rule list a rule always matches any trace
-                     rules << SimpleRule.new(sample_rate: default_sample_rate)
-                   else
-                     rules
-                   end
+            # Add to the end of the rule list a rule always matches any trace
+            rules << SimpleRule.new(sample_rate: default_sample_rate)
+          else
+            rules
+          end
           @rate_limiter = if rate_limiter
-                            rate_limiter
-                          elsif rate_limit
-                            Core::TokenBucket.new(rate_limit)
-                          else
-                            Core::UnlimitedLimiter.new
-                          end
+            rate_limiter
+          elsif rate_limit
+            Core::TokenBucket.new(rate_limit)
+          else
+            Core::UnlimitedLimiter.new
+          end
           @default_sampler = if default_sampler
-                               default_sampler
-                             elsif default_sample_rate
-                               nil
-                             else
-                               # TODO: Simplify .tags access, as `Tracer#tags` can't be arbitrarily changed anymore
-                               RateByServiceSampler.new(1.0, env: -> { Tracing.send(:tracer).tags['env'] })
-                             end
+            default_sampler
+          elsif default_sample_rate
+            nil
+          else
+            # TODO: Simplify .tags access, as `Tracer#tags` can't be arbitrarily changed anymore
+            RateByServiceSampler.new(1.0, env: -> { Tracing.send(:tracer).tags["env"] })
+          end
+          @reconsider_sample_resource_enabled = @rules.any? { |rule| resource_rule?(rule) }
         end
 
         def self.parse(rules, rate_limit, default_sample_rate)
           parsed_rules = JSON.parse(rules).map do |rule|
-            sample_rate = rule['sample_rate']
+            sample_rate = rule["sample_rate"]
 
             begin
               sample_rate = Float(sample_rate)
@@ -63,12 +64,12 @@ module Datadog
             end
 
             kwargs = {
-              name: rule['name'],
-              service: rule['service'],
-              resource: rule['resource'],
-              tags: rule['tags'],
+              name: rule["name"],
+              service: rule["service"],
+              resource: rule["resource"],
+              tags: rule["tags"],
               sample_rate: sample_rate,
-              provenance: if (provenance = rule['provenance'])
+              provenance: if (provenance = rule["provenance"])
                             # `Rule::PROVENANCE_*` values are symbols, so convert strings to match
                             provenance.to_sym
                           else
@@ -84,7 +85,7 @@ module Datadog
           new(parsed_rules, rate_limit: rate_limit, default_sample_rate: default_sample_rate)
         rescue => e
           Datadog.logger.warn do
-            "Could not parse trace sampling rules '#{rules}': #{e.class.name} #{e.message} at #{Array(e.backtrace).first}"
+            "Could not parse trace sampling rules '#{rules}': #{e.class}: #{e.message} at #{Array(e.backtrace).first}"
           end
 
           nil
@@ -103,6 +104,18 @@ module Datadog
           trace.sampled = sampled
         end
 
+        def reconsider_sample_resource!(trace)
+          rule = @rules.find { |r| resource_rule?(r) && r.match?(trace) }
+          return if rule.nil?
+
+          reconsider_matching_rule!(trace, rule)
+        end
+
+        # Do any rules match on the resource name?
+        def resource_sampling?
+          @reconsider_sample_resource_enabled
+        end
+
         # @!visibility private
         def update(*args, **kwargs)
           return false unless @default_sampler.respond_to?(:update)
@@ -117,34 +130,12 @@ module Datadog
 
           return yield(trace) if rule.nil?
 
-          sampled = rule.sample!(trace)
-          sample_rate = rule.sample_rate(trace)
-
-          set_priority(trace, sampled)
-          set_rule_metrics(trace, sample_rate)
-
-          return false unless sampled
-
-          rate_limiter.allow?.tap do |allowed|
-            set_priority(trace, allowed)
-            set_limiter_metrics(trace, rate_limiter.effective_rate)
-
-            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
+          apply_rule!(trace, rule)
+        rescue => e
           Datadog.logger.error(
-            "Rule sampling failed. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+            "Rule sampling failed. Cause: #{e.class}: #{e.message} Source: #{Array(e.backtrace).first}"
           )
-          Datadog::Core::Telemetry::Logger.report(e, description: 'Rule sampling failed')
+          Datadog::Core::Telemetry::Logger.report(e, description: "Rule sampling failed")
 
           yield(trace)
         end
@@ -153,10 +144,10 @@ module Datadog
         # was responsible for the sampling decision.
         def set_priority(trace, sampled)
           trace.sampling_priority = if sampled
-                                      Sampling::Ext::Priority::USER_KEEP
-                                    else
-                                      Sampling::Ext::Priority::USER_REJECT
-                                    end
+            Sampling::Ext::Priority::USER_KEEP
+          else
+            Sampling::Ext::Priority::USER_REJECT
+          end
         end
 
         def set_rule_metrics(trace, sample_rate)
@@ -166,6 +157,44 @@ module Datadog
         def set_limiter_metrics(trace, limiter_rate)
           trace.rate_limiter_rate = limiter_rate
         end
+
+        def apply_rule!(trace, rule)
+          sampled = rule.sample!(trace)
+          sample_rate = rule.sample_rate(trace)
+
+          set_priority(trace, sampled)
+          set_rule_metrics(trace, sample_rate)
+
+          return false unless sampled
+
+          rate_limiter.allow?.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, provenance_for(rule))
+          end
+        end
+
+        def provenance_for(rule)
+          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
+        end
+
+        def resource_rule?(rule)
+          matcher = rule.matcher
+          matcher.respond_to?(:resource) && matcher.resource != Matcher::MATCH_ALL
+        end
+
+        def reconsider_matching_rule!(trace, rule)
+          trace.agent_sample_rate = nil
+          trace.clear_tag(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER)
+          apply_rule!(trace, rule)
+        end
       end
     end
   end

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

@@ -15,7 +15,7 @@ module Datadog
         # @param [Datadog::Tracing::TraceOperation] trace
         # @return [Boolean] should this trace be kept?
         def sample!(trace)
-          raise NotImplementedError, 'Samplers must implement the #sample! method'
+          raise NotImplementedError, "Samplers must implement the #sample! method"
         end
 
         # The sampling rate, if this sampler has such concept.
@@ -24,7 +24,7 @@ module Datadog
         # @param [Datadog::Tracing::TraceOperation] trace
         # @return [Float,nil] sampling ratio between 0.0 and 1.0 (inclusive), or `nil` if not applicable
         def sample_rate(trace)
-          raise NotImplementedError, 'Samplers must implement the #sample_rate method'
+          raise NotImplementedError, "Samplers must implement the #sample_rate method"
         end
       end
     end

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

@@ -13,11 +13,11 @@ module Datadog
           DEFAULT_MAX_PER_SECOND = -1
 
           # Sampling decision method used to come to the sampling decision for this span
-          TAG_MECHANISM = '_dd.span_sampling.mechanism'
+          TAG_MECHANISM = "_dd.span_sampling.mechanism"
           # Sampling rate applied to this span, if a rule applies
-          TAG_RULE_RATE = '_dd.span_sampling.rule_rate'
+          TAG_RULE_RATE = "_dd.span_sampling.rule_rate"
           # Rate limit configured for this span, if a rule applies
-          TAG_MAX_PER_SECOND = '_dd.span_sampling.max_per_second'
+          TAG_MAX_PER_SECOND = "_dd.span_sampling.max_per_second"
         end
       end
     end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../matcher'
+require_relative "../matcher"
 
 module Datadog
   module Tracing
@@ -11,7 +11,7 @@ module Datadog
           attr_reader :name, :service
 
           # Pattern that matches any string
-          MATCH_ALL_PATTERN = '*'
+          MATCH_ALL_PATTERN = "*"
 
           # Matches span name and service to their respective patterns provided.
           #

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'ext'
+require_relative "ext"
 
 module Datadog
   module Tracing
@@ -24,7 +24,6 @@ module Datadog
             sample_rate: Span::Ext::DEFAULT_SAMPLE_RATE,
             rate_limit: Span::Ext::DEFAULT_MAX_PER_SECOND
           )
-
             @matcher = matcher
             @sample_rate = sample_rate
             @rate_limit = rate_limit

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

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require 'json'
+require "json"
 
-require_relative 'ext'
-require_relative 'matcher'
-require_relative 'rule'
+require_relative "ext"
+require_relative "matcher"
+require_relative "rule"
 
 module Datadog
   module Tracing
@@ -28,8 +28,8 @@ module Datadog
                 list = JSON.parse(rules)
               rescue => e
                 Datadog.logger.warn(
-                  "Error parsing Span Sampling Rules `#{rules.inspect}`: "\
-                  "#{e.class.name} #{e.message} at #{Array(e.backtrace).first}"
+                  "Error parsing Span Sampling Rules `#{rules.inspect}`: " \
+                  "#{e.class}: #{e.message} at #{Array(e.backtrace).first}"
                 )
                 return nil
               end
@@ -61,7 +61,7 @@ module Datadog
                 rescue => e
                   Datadog.logger.warn(
                     "Cannot parse Span Sampling Rule #{hash.inspect}: " \
-                    "#{e.class.name} #{e} at #{Array(e.backtrace).first}"
+                    "#{e.class}: #{e.message} at #{Array(e.backtrace).first}"
                   )
                   return nil
                 end
@@ -75,22 +75,22 @@ module Datadog
 
             def parse_rule(hash)
               matcher_options = {}
-              if (name_pattern = hash['name'])
+              if (name_pattern = hash["name"])
                 matcher_options[:name_pattern] = name_pattern
               end
 
-              if (service_pattern = hash['service'])
+              if (service_pattern = hash["service"])
                 matcher_options[:service_pattern] = service_pattern
               end
 
               matcher = Matcher.new(**matcher_options)
 
               rule_options = {}
-              if (sample_rate = hash['sample_rate'])
+              if (sample_rate = hash["sample_rate"])
                 rule_options[:sample_rate] = sample_rate
               end
 
-              if (max_per_second = hash['max_per_second'])
+              if (max_per_second = hash["max_per_second"])
                 rule_options[:rate_limit] = max_per_second
               end
 

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

@@ -58,13 +58,6 @@ module Datadog
 
               next if decision == :not_matched # Iterate until we find a matching decision
 
-              if decision == :kept
-                trace_op.set_tag(
-                  Metadata::Ext::Distributed::TAG_DECISION_MAKER,
-                  Sampling::Ext::Decision::SPAN_SAMPLING_RATE
-                )
-              end
-
               break # Found either a `kept` or `rejected` decision
             end
 

data/lib/datadog/tracing/span.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require_relative '../core/utils/safe_dup'
-require_relative 'utils'
+require_relative "../core/utils/safe_dup"
+require_relative "utils"
 
-require_relative 'metadata/ext'
-require_relative 'metadata'
+require_relative "metadata/ext"
+require_relative "metadata"
 
 module Datadog
   module Tracing
@@ -33,6 +33,9 @@ module Datadog
         :status,
         :trace_id
 
+      attr_reader \
+        :metastruct
+
       attr_writer \
         :duration
 
@@ -54,6 +57,7 @@ module Datadog
         id: nil,
         meta: nil,
         metrics: nil,
+        metastruct: nil,
         parent_id: 0,
         resource: name,
         service: nil,
@@ -76,6 +80,7 @@ module Datadog
 
         @meta = meta || {}
         @metrics = metrics || {}
+        @metastruct = metastruct || Metastruct.new
         @status = status || 0
 
         # start_time and end_time track wall clock. In Ruby, wall clock
@@ -108,11 +113,14 @@ module Datadog
       def stopped?
         !@end_time.nil?
       end
-      alias :finished? :stopped?
+      alias_method :finished?, :stopped?
 
       def duration
         return @duration if @duration
-        return @end_time - @start_time if @start_time && @end_time
+
+        start_time = @start_time
+        end_time = @end_time
+        end_time - start_time if start_time && end_time
       end
 
       def set_error(e)
@@ -135,10 +143,13 @@ module Datadog
       # TODO: Change this to reflect attributes when serialization
       # isn't handled by this method.
       def to_hash
+        @meta["events"] = @events.map(&:to_hash).to_json unless @events.empty?
+
         h = {
           error: @status,
           meta: @meta,
           metrics: @metrics,
+          meta_struct: @metastruct.to_h,
           name: @name,
           parent_id: @parent_id,
           resource: @resource,
@@ -154,8 +165,6 @@ module Datadog
           h[:duration] = duration_nano
         end
 
-        h[:meta]['events'] = @events.map(&:to_hash).to_json unless @events.empty?
-
         h
       end
 
@@ -176,18 +185,21 @@ module Datadog
           q.text "Start: #{start_time}\n"
           q.text "End: #{end_time}\n"
           q.text "Duration: #{duration.to_f}\n"
-          q.group(2, 'Tags: [', "]\n") do
+          q.group(2, "Tags: [", "]\n") do
             q.breakable
             q.seplist @meta.each do |key, value|
               q.text "#{key} => #{value}"
             end
           end
-          q.group(2, 'Metrics: [', ']') do
+          q.group(2, "Metrics: [", "]\n") do
             q.breakable
             q.seplist @metrics.each do |key, value|
               q.text "#{key} => #{value}"
             end
           end
+          q.group(2, "Metastruct: [", "]") do
+            metastruct.pretty_print(q)
+          end
         end
       end
 
@@ -196,12 +208,17 @@ module Datadog
       # Used for serialization
       # @return [Integer] in nanoseconds since Epoch
       def start_time_nano
-        @start_time.to_i * 1000000000 + @start_time.nsec
+        return unless (start_time = @start_time)
+
+        start_time.to_i * 1000000000 + start_time.nsec
       end
 
       # Used for serialization
       # @return [Integer] in nanoseconds since Epoch
       def duration_nano
+        duration = self.duration
+        return unless duration
+
         (duration * 1e9).to_i
       end