ddtrace 1.4.2 → 1.23.3

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

@@ -1,4 +1,4 @@
-# typed: true
+# frozen_string_literal: true
 
 require_relative 'ext'
 require_relative 'all_sampler'
@@ -21,17 +21,26 @@ module Datadog
 
         def initialize(opts = {})
           @pre_sampler = opts[:base_sampler] || AllSampler.new
-          @priority_sampler = opts[:post_sampler] || RateByServiceSampler.new
+          @priority_sampler = opts[:post_sampler] || RateByServiceSampler.new(decision: Sampling::Ext::Decision::AGENT_RATE)
         end
 
         def sample?(trace)
           @pre_sampler.sample?(trace)
         end
 
+        # DEV-2.0:We should get rid of this complicated interaction between @pre_sampler and @priority_sampler.
+        # DEV-2.0:If the user wants to configure a custom sampler, we should only allow them to provide a complete
+        # DEV-2.0:sampling suite, not having this convoluted support for mixing arbitrary provided samplers in
+        # DEV-2.0:the PrioritySampler. Ideally, the PrioritySampler is only used by Datadog.
+        # DEV-2.0:There are too many edge cases and combinations to work around currently in this class.
         def sample!(trace)
+          # The priority that was set before the sampler ran.
+          # This comes from distributed tracing priority propagation.
+          distributed_sampling_priority = priority_assigned?(trace)
+
           # If pre-sampling is configured, do it first. (By default, this will sample at 100%.)
           # NOTE: Pre-sampling at rates < 100% may result in partial traces; not recommended.
-          trace.sampled = pre_sample?(trace) ? @pre_sampler.sample!(trace) : true
+          trace.sampled = pre_sample?(trace) ? preserving_priority_sampling(trace) { @pre_sampler.sample!(trace) } : true
 
           if trace.sampled?
             # If priority sampling has already been applied upstream, use that value.
@@ -53,11 +62,38 @@ module Datadog
           end
 
           trace.sampled?
+        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)
+              # 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.
+              trace.set_tag(
+                Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER,
+                Sampling::Ext::Decision::MANUAL
+              )
+            end
+          else
+            # The sampler decided to not keep this span, removing sampling decision.
+            trace.clear_tag(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER)
+          end
         end
 
         # (see Datadog::Tracing::Sampling::RateByServiceSampler#update)
-        def update(rate_by_service)
-          @priority_sampler.update(rate_by_service)
+        def update(rate_by_service, decision: nil)
+          @priority_sampler.update(rate_by_service, decision: decision)
+        end
+
+        # Check if the Priority Sampling decision is to keep or drop the trace.
+        # Other factors can influence the sampling decision; this method is only
+        # responsible for interpreting the Sampling Priority decision.
+        #
+        # @param priority_sampling [Integer] priority sampling number
+        # @return [Boolean] true if trace is "kept" by priority sampling
+        # @return [Boolean] false if trace is "dropped" by priority sampling
+        def self.sampled?(priority_sampling)
+          priority_sampling >= Ext::Priority::AUTO_KEEP
         end
 
         private
@@ -83,6 +119,23 @@ module Datadog
           end
         end
 
+        # Ensures the trace's priority sampling decision is not changed by the @pre_sampler.
+        # The @pre_sampler should only change `trace.sampled`.
+        def preserving_priority_sampling(trace)
+          sampling_priority = trace.sampling_priority
+          sampling_decision = trace.get_tag(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER)
+
+          yield.tap do
+            trace.sampling_priority = sampling_priority
+
+            if sampling_decision
+              trace.set_tag(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER, sampling_decision)
+            else
+              trace.clear_tag(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER)
+            end
+          end
+        end
+
         # Ensures the trace is always propagated to the writer and that
         # the sample rate metric represents the true client-side sampling.
         def preserving_sampling(trace)

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

@@ -1,5 +1,3 @@
-# typed: true
-
 require_relative 'sampler'
 require_relative 'rate_sampler'
 
@@ -12,7 +10,7 @@ module Datadog
         attr_reader \
           :default_key
 
-        def initialize(default_key, default_rate = 1.0, &block)
+        def initialize(default_key, default_rate = 1.0, decision: nil, &block)
           super()
 
           raise ArgumentError, 'No resolver given!' unless block
@@ -22,7 +20,7 @@ module Datadog
           @mutex = Mutex.new
           @samplers = {}
 
-          set_rate(default_key, default_rate)
+          set_rate(default_key, default_rate, decision)
         end
 
         def resolve(trace)
@@ -57,15 +55,15 @@ module Datadog
           end
         end
 
-        def update(key, rate)
+        def update(key, rate, decision: nil)
           @mutex.synchronize do
-            set_rate(key, rate)
+            set_rate(key, rate, decision)
           end
         end
 
-        def update_all(rate_by_key)
+        def update_all(rate_by_key, decision: nil)
           @mutex.synchronize do
-            rate_by_key.each { |key, rate| set_rate(key, rate) }
+            rate_by_key.each { |key, rate| set_rate(key, rate, decision) }
           end
         end
 
@@ -87,9 +85,8 @@ module Datadog
 
         private
 
-        def set_rate(key, rate)
-          @samplers[key] ||= RateSampler.new(rate)
-          @samplers[key].sample_rate = rate
+        def set_rate(key, rate, decision)
+          @samplers[key] = RateSampler.new(rate, decision: decision)
         end
       end
     end

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

@@ -1,6 +1,3 @@
-# typed: true
-
-require_relative '../../core'
 require_relative 'rate_by_key_sampler'
 
 module Datadog
@@ -11,17 +8,23 @@ module Datadog
       class RateByServiceSampler < RateByKeySampler
         DEFAULT_KEY = 'service:,env:'.freeze
 
-        def initialize(default_rate = 1.0, options = {})
-          super(DEFAULT_KEY, default_rate, &method(:key_for))
-          @env = options[:env]
+        def initialize(default_rate = 1.0, env: nil, decision: Datadog::Tracing::Sampling::Ext::Decision::DEFAULT)
+          super(
+            DEFAULT_KEY,
+            default_rate,
+            decision: decision,
+            &method(:key_for)
+          )
+
+          @env = env
         end
 
-        def update(rate_by_service)
+        def update(rate_by_service, decision: nil)
           # Remove any old services
           delete_if { |key, _| key != DEFAULT_KEY && !rate_by_service.key?(key) }
 
           # Update each service rate
-          update_all(rate_by_service)
+          update_all(rate_by_service, decision: decision)
 
           # Emit metric for service cache size
           Datadog.health_metrics.sampling_service_cache_length(length)
@@ -29,6 +32,24 @@ module Datadog
 
         private
 
+        # DEV: Creating a string on every trace to perform a single Hash lookup is expensive.
+        #
+        # Using 2 nested hashes: 1 for env and 1 for service is the fastest option.
+        # This approach requires large API changes to `RateByKeySampler`.
+        #
+        # Reducing the interpolated string size, by using a 1 character separator,
+        # is also measurably faster than the current method. This approach does not
+        # require changes to `RateByKeySampler`.
+        #
+        # Keep in mind that these changes also require changes to `#update`.
+        #
+        # Comparison:
+        #  2 nested hashes: `service_hash.fetch(service, {}).fetch(env, default_rate)`
+        #                   7730045 i/s
+        # 1 char separator: `hash.fetch("#{service}\0#{env}", default_rate)`
+        #                   4302801 i/s - 1.80x slower
+        #          current: `hash.fetch("service:#{service},env:#{env}", default_rate)`
+        #                   2720459 i/s - 2.84x slower
         def key_for(trace)
           # Resolve env dynamically, if Proc is given.
           env = @env.is_a?(Proc) ? @env.call : @env

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

@@ -1,5 +1,3 @@
-# typed: true
-
 require_relative '../../core/utils/time'
 
 module Datadog
@@ -39,6 +37,9 @@ module Datadog
         def initialize(rate, max_tokens = rate)
           super()
 
+          raise ArgumentError, "rate must be a number: #{rate}" unless rate.is_a?(Numeric)
+          raise ArgumentError, "max_tokens must be a number: #{max_tokens}" unless max_tokens.is_a?(Numeric)
+
           @rate = rate
           @max_tokens = max_tokens
 

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

@@ -1,9 +1,5 @@
-# typed: true
-
-require_relative '../../core'
-
 require_relative 'sampler'
-require_relative '../span'
+require_relative '../utils'
 
 module Datadog
   module Tracing
@@ -20,7 +16,17 @@ module Datadog
         # * +sample_rate+: the sample rate as a {Float} between 0.0 and 1.0. 0.0
         #   means that no trace will be sampled; 1.0 means that all traces will be
         #   sampled.
-        def initialize(sample_rate = 1.0)
+        #
+        # DEV-2.0: Allow for `sample_rate` zero (drop all) to be allowed. This eases
+        # DEV-2.0: usage for all internal users of the {RateSampler} class: both
+        # DEV-2.0: RuleSampler and Single Span Sampling leverage the RateSampler, but want
+        # DEV-2.0: `sample_rate` zero to mean "drop all". They work around this by hard-
+        # DEV-2.0: setting the `sample_rate` to zero like so:
+        # DEV-2.0: ```
+        # DEV-2.0: sampler = RateSampler.new
+        # DEV-2.0: sampler.sample_rate = sample_rate
+        # DEV-2.0: ```
+        def initialize(sample_rate = 1.0, decision: nil)
           super()
 
           unless sample_rate > 0.0 && sample_rate <= 1.0
@@ -29,6 +35,8 @@ module Datadog
           end
 
           self.sample_rate = sample_rate
+
+          @decision = decision
         end
 
         def sample_rate(*_)
@@ -37,17 +45,22 @@ module Datadog
 
         def sample_rate=(sample_rate)
           @sample_rate = sample_rate
-          @sampling_id_threshold = sample_rate * Tracing::Span::EXTERNAL_MAX_ID
+          @sampling_id_threshold = sample_rate * Tracing::Utils::EXTERNAL_MAX_ID
         end
 
         def sample?(trace)
-          ((trace.id * KNUTH_FACTOR) % Tracing::Span::EXTERNAL_MAX_ID) <= @sampling_id_threshold
+          ((trace.id * KNUTH_FACTOR) % Tracing::Utils::EXTERNAL_MAX_ID) <= @sampling_id_threshold
         end
 
         def sample!(trace)
           sampled = trace.sampled = sample?(trace)
-          trace.sample_rate = @sample_rate if sampled
-          sampled
+
+          return false unless sampled
+
+          trace.sample_rate = @sample_rate
+          trace.set_tag(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER, @decision) if @decision
+
+          true
         end
       end
     end

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

@@ -1,7 +1,3 @@
-# typed: true
-
-require_relative '../../core'
-
 require_relative 'matcher'
 require_relative 'rate_sampler'
 
@@ -55,8 +51,13 @@ 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)
+        def initialize(
+          name: SimpleMatcher::MATCH_ALL, service: SimpleMatcher::MATCH_ALL,
+          resource: SimpleMatcher::MATCH_ALL, tags: {}, 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.
           #
@@ -68,7 +69,7 @@ module Datadog
           sampler = RateSampler.new
           sampler.sample_rate = sample_rate
 
-          super(SimpleMatcher.new(name: name, service: service), sampler)
+          super(SimpleMatcher.new(name: name, service: service, resource: resource, tags: tags), sampler)
         end
       end
     end

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

@@ -1,7 +1,3 @@
-# typed: true
-
-require_relative '../../core'
-
 require_relative 'ext'
 require_relative 'rate_limiter'
 require_relative 'rule'
@@ -48,10 +44,41 @@ module Datadog
                                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] })
+                               RateByServiceSampler.new(1.0, env: -> { Tracing.send(:tracer).tags['env'] })
                              end
         end
 
+        def self.parse(rules, rate_limit, default_sample_rate)
+          parsed_rules = JSON.parse(rules).map do |rule|
+            sample_rate = rule['sample_rate']
+
+            begin
+              sample_rate = Float(sample_rate)
+            rescue
+              raise "Rule '#{rule.inspect}' does not contain a float property `sample_rate`"
+            end
+
+            kwargs = {
+              name: rule['name'],
+              service: rule['service'],
+              resource: rule['resource'],
+              tags: rule['tags'],
+              sample_rate: sample_rate,
+            }
+
+            Core::BackportFrom24.hash_compact!(kwargs)
+
+            SimpleRule.new(**kwargs)
+          end
+
+          new(parsed_rules, rate_limit: rate_limit, default_sample_rate: default_sample_rate)
+        rescue => e
+          Datadog.logger.error do
+            "Could not parse trace sampling rules '#{rules}': #{e.class.name} #{e.message} at #{Array(e.backtrace).first}"
+          end
+          nil
+        end
+
         # /RuleSampler's components (it's rate limiter, for example) are
         # not be guaranteed to be size-effect free.
         # It is not possible to guarantee that a call to {#sample?} will
@@ -76,10 +103,10 @@ module Datadog
         end
 
         # @!visibility private
-        def update(*args)
+        def update(*args, **kwargs)
           return false unless @default_sampler.respond_to?(:update)
 
-          @default_sampler.update(*args)
+          @default_sampler.update(*args, **kwargs)
         end
 
         private
@@ -100,6 +127,7 @@ 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)
           end
         rescue StandardError => e
           Datadog.logger.error(

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

@@ -1,5 +1,3 @@
-# typed: true
-
 module Datadog
   module Tracing
     module Sampling

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Sampling
+      module Span
+        # Single Span Sampling constants.
+        module Ext
+          # Accept all spans (100% retention).
+          DEFAULT_SAMPLE_RATE = 1.0
+          # Unlimited.
+          # @see Datadog::Tracing::Sampling::TokenBucket
+          DEFAULT_MAX_PER_SECOND = -1
+
+          # Sampling decision method used to come to the sampling decision for this span
+          TAG_MECHANISM = '_dd.span_sampling.mechanism'
+          # Sampling rate applied to this span, if a rule applies
+          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'
+        end
+      end
+    end
+  end
+end

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

@@ -6,6 +6,8 @@ module Datadog
       module Span
         # Checks if a span conforms to a matching criteria.
         class Matcher
+          attr_reader :name, :service
+
           # Pattern that matches any string
           MATCH_ALL_PATTERN = '*'
 
@@ -54,6 +56,13 @@ module Datadog
             end
           end
 
+          def ==(other)
+            return super unless other.is_a?(Matcher)
+
+            name == other.name &&
+              service == other.service
+          end
+
           private
 
           # @param pattern [String]

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative 'ext'
+
+module Datadog
+  module Tracing
+    module Sampling
+      module Span
+        # Span sampling rule that applies a sampling rate if the span
+        # matches the provided {Matcher}.
+        # Additionally, a rate limiter is also applied.
+        #
+        # If a span does not conform to the matcher, no changes are made.
+        class Rule
+          attr_reader :matcher, :sample_rate, :rate_limit
+
+          # Creates a new span sampling rule.
+          #
+          # @param [Sampling::Span::Matcher] matcher whether this rule applies to a specific span
+          # @param [Float] sample_rate span sampling ratio, between 0.0 (0%) and 1.0 (100%).
+          # @param [Numeric] rate_limit maximum number of spans sampled per second. Negative numbers mean unlimited spans.
+          def initialize(
+            matcher,
+            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
+
+            @sampler = Sampling::RateSampler.new
+            # Set the sample_rate outside of the initializer to allow for
+            # zero to be a "drop all".
+            # The RateSampler initializer enforces non-zero, falling back to 100% sampling
+            # if zero is provided.
+            @sampler.sample_rate = sample_rate
+            @rate_limiter = Sampling::TokenBucket.new(rate_limit)
+          end
+
+          # This method should only be invoked for spans that are part
+          # of a trace that has been dropped by trace-level sampling.
+          # Invoking it for other spans will cause incorrect sampling
+          # metrics to be reported by the Datadog App.
+          #
+          # Returns `true` if the provided span is sampled.
+          # If the span is dropped due to sampling rate or rate limiting,
+          # it returns `false`.
+          #
+          # Returns `nil` if the span did not meet the matching criteria by the
+          # provided matcher.
+          #
+          # This method modifies the `span` if it matches the provided matcher.
+          #
+          # @param [Datadog::Tracing::SpanOperation] span_op span to be sampled
+          # @return [:kept,:rejected] should this span be sampled?
+          # @return [:not_matched] span did not satisfy the matcher, no changes are made to the span
+          def sample!(span_op)
+            return :not_matched unless @matcher.match?(span_op)
+
+            if @sampler.sample?(span_op) && @rate_limiter.allow?(1)
+              span_op.set_metric(Span::Ext::TAG_MECHANISM, Sampling::Ext::Mechanism::SPAN_SAMPLING_RATE)
+              span_op.set_metric(Span::Ext::TAG_RULE_RATE, @sample_rate)
+              span_op.set_metric(Span::Ext::TAG_MAX_PER_SECOND, @rate_limit)
+              :kept
+            else
+              :rejected
+            end
+          end
+
+          def ==(other)
+            return super unless other.is_a?(Rule)
+
+            matcher == other.matcher &&
+              sample_rate == other.sample_rate &&
+              rate_limit == other.rate_limit
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'json'
+
+require_relative 'ext'
+require_relative 'matcher'
+require_relative 'rule'
+
+module Datadog
+  module Tracing
+    module Sampling
+      module Span
+        # Converts user configuration into {Datadog::Tracing::Sampling::Span::Rule} objects,
+        # handling any parsing errors.
+        module RuleParser
+          class << self
+            # Parses the provided JSON string containing the Single Span
+            # Sampling configuration list.
+            # In case of parsing errors, `nil` is returned.
+            #
+            # @param rules [String] the JSON configuration rules to be parsed
+            # @return [Array<Datadog::Tracing::Sampling::Span::Rule>] a list of parsed rules
+            # @return [nil] if parsing failed
+            def parse_json(rules)
+              return nil unless rules
+
+              begin
+                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}"
+                )
+                return nil
+              end
+
+              parse_list(list)
+            end
+
+            # Parses a list of Hashes containing the parsed JSON information
+            # for Single Span Sampling configuration.
+            # In case of parsing errors, `nil` is returned.
+            #
+            # @param rules [Array<String] the JSON configuration rules to be parsed
+            # @return [Array<Datadog::Tracing::Sampling::Span::Rule>] a list of parsed rules
+            # @return [nil] if parsing failed
+            def parse_list(rules)
+              unless rules.is_a?(Array)
+                Datadog.logger.warn("Span Sampling Rules are not an array: #{rules.inspect}")
+                return nil
+              end
+
+              parsed = rules.map do |hash|
+                unless hash.is_a?(Hash)
+                  Datadog.logger.warn("Span Sampling Rule is not a key-value object: #{hash.inspect}")
+                  return nil
+                end
+
+                begin
+                  parse_rule(hash)
+                rescue => e
+                  Datadog.logger.warn(
+                    "Cannot parse Span Sampling Rule #{hash.inspect}: " \
+                    "#{e.class.name} #{e} at #{Array(e.backtrace).first}"
+                  )
+                  return nil
+                end
+              end
+
+              parsed.compact!
+              parsed
+            end
+
+            private
+
+            def parse_rule(hash)
+              matcher_options = {}
+              if (name_pattern = hash['name'])
+                matcher_options[:name_pattern] = name_pattern
+              end
+
+              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'])
+                rule_options[:sample_rate] = sample_rate
+              end
+
+              if (max_per_second = hash['max_per_second'])
+                rule_options[:rate_limit] = max_per_second
+              end
+
+              Rule.new(matcher, **rule_options)
+            end
+          end
+        end
+      end
+    end
+  end
+end