ddtrace 0.54.2 → 1.18.0

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

@@ -0,0 +1,186 @@
+require_relative '../../core/utils/time'
+
+module Datadog
+  module Tracing
+    module Sampling
+      # Checks for rate limiting on a resource.
+      # @public_api
+      class RateLimiter
+        # Checks if resource of specified size can be
+        # conforms with the current limit.
+        #
+        # Implementations of this method are not guaranteed
+        # to be side-effect free.
+        #
+        # @return [Boolean] whether a resource conforms with the current limit
+        def allow?(size); end
+
+        # The effective rate limiting ratio based on
+        # recent calls to `allow?`.
+        #
+        # @return [Float] recent allowance ratio
+        def effective_rate; end
+      end
+
+      # Implementation of the Token Bucket metering algorithm
+      # for rate limiting.
+      #
+      # @see https://en.wikipedia.org/wiki/Token_bucket Token bucket
+      # @public_api
+      class TokenBucket < RateLimiter
+        attr_reader :rate, :max_tokens
+
+        # @param rate [Numeric] Allowance rate, in units per second
+        #  if rate is negative, always allow
+        #  if rate is zero, never allow
+        # @param max_tokens [Numeric] Limit of available tokens
+        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
+
+          @tokens = max_tokens
+          @total_messages = 0
+          @conforming_messages = 0
+          @prev_conforming_messages = nil
+          @prev_total_messages = nil
+          @current_window = nil
+
+          @last_refill = Core::Utils::Time.get_time
+        end
+
+        # Checks if a message of provided +size+
+        # conforms with the current bucket limit.
+        #
+        # If it does, return +true+ and remove +size+
+        # tokens from the bucket.
+        # If it does not, return +false+ without affecting
+        # the tokens from the bucket.
+        #
+        # @return [Boolean] +true+ if message conforms with current bucket limit
+        def allow?(size)
+          allowed = should_allow?(size)
+          update_rate_counts(allowed)
+          allowed
+        end
+
+        # Ratio of 'conformance' per 'total messages' checked
+        # averaged for the past 2 buckets
+        #
+        # Returns +1.0+ when no messages have been checked yet.
+        #
+        # @return [Float] Conformance ratio, between +[0,1]+
+        def effective_rate
+          return 0.0 if @rate.zero?
+          return 1.0 if @rate < 0 || @total_messages.zero?
+
+          return current_window_rate if @prev_conforming_messages.nil? || @prev_total_messages.nil?
+
+          (@conforming_messages.to_f + @prev_conforming_messages.to_f) / (@total_messages + @prev_total_messages)
+        end
+
+        # Ratio of 'conformance' per 'total messages' checked
+        # on this bucket
+        #
+        # Returns +1.0+ when no messages have been checked yet.
+        #
+        # @return [Float] Conformance ratio, between +[0,1]+
+        def current_window_rate
+          return 1.0 if @total_messages.zero?
+
+          @conforming_messages.to_f / @total_messages
+        end
+
+        # @return [Numeric] number of tokens currently available
+        def available_tokens
+          @tokens
+        end
+
+        private
+
+        def refill_since_last_message
+          now = Core::Utils::Time.get_time
+          elapsed = now - @last_refill
+
+          # Update the number of available tokens, but ensure we do not exceed the max
+          # we return the min of tokens + rate*elapsed, or max tokens
+          refill_tokens(@rate * elapsed)
+
+          @last_refill = now
+        end
+
+        def refill_tokens(size)
+          @tokens += size
+          @tokens = @max_tokens if @tokens > @max_tokens
+        end
+
+        def increment_total_count
+          @total_messages += 1
+        end
+
+        def increment_conforming_count
+          @conforming_messages += 1
+        end
+
+        def should_allow?(size)
+          # rate limit of 0 blocks everything
+          return false if @rate.zero?
+
+          # negative rate limit disables rate limiting
+          return true if @rate < 0
+
+          refill_since_last_message
+
+          # if tokens < 1 we don't allow?
+          return false if @tokens < size
+
+          @tokens -= size
+
+          true
+        end
+
+        # Sets and Updates the past two 1 second windows for which
+        # the rate limiter must compute it's rate over and updates
+        # the total count, and conforming message count if +allowed+
+        def update_rate_counts(allowed)
+          now = Core::Utils::Time.get_time
+
+          # No tokens have been seen yet, start a new window
+          if @current_window.nil?
+            @current_window = now
+          # If more than 1 second has past since last window, reset
+          elsif now - @current_window >= 1
+            @prev_conforming_messages = @conforming_messages
+            @prev_total_messages = @total_messages
+            @conforming_messages = 0
+            @total_messages = 0
+            @current_window = now
+          end
+
+          increment_conforming_count if allowed
+
+          increment_total_count
+        end
+      end
+
+      # {Datadog::Tracing::Sampling::RateLimiter} that accepts all resources,
+      # with no limits.
+      # @public_api
+      class UnlimitedLimiter < RateLimiter
+        # @return [Boolean] always +true+
+        def allow?(_)
+          true
+        end
+
+        # @return [Float] always 100%
+        def effective_rate
+          1.0
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+require_relative 'sampler'
+require_relative '../utils'
+
+module Datadog
+  module Tracing
+    module Sampling
+      # {Datadog::Tracing::Sampling::RateSampler} is based on a sample rate.
+      # @public_api
+      class RateSampler < Sampler
+        KNUTH_FACTOR = 1111111111111111111
+
+        # Initialize a {Datadog::Tracing::Sampling::RateSampler}.
+        # This sampler keeps a random subset of the traces. Its main purpose is to
+        # reduce the instrumentation footprint.
+        #
+        # * +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.
+        #
+        # 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
+            Datadog.logger.error('sample rate is not between 0 and 1, disabling the sampler')
+            sample_rate = 1.0
+          end
+
+          self.sample_rate = sample_rate
+
+          @decision = decision
+        end
+
+        def sample_rate(*_)
+          @sample_rate
+        end
+
+        def sample_rate=(sample_rate)
+          @sample_rate = sample_rate
+          @sampling_id_threshold = sample_rate * Tracing::Utils::EXTERNAL_MAX_ID
+        end
+
+        def sample?(trace)
+          ((trace.id * KNUTH_FACTOR) % Tracing::Utils::EXTERNAL_MAX_ID) <= @sampling_id_threshold
+        end
+
+        def sample!(trace)
+          sampled = trace.sampled = sample?(trace)
+
+          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
+  end
+end

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

@@ -0,0 +1,72 @@
+require_relative 'matcher'
+require_relative 'rate_sampler'
+
+module Datadog
+  module Tracing
+    module Sampling
+      # Sampling rule that dictates if a trace matches
+      # a specific criteria and what sampling strategy to
+      # apply in case of a positive match.
+      # @public_api
+      class Rule
+        attr_reader :matcher, :sampler
+
+        # @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)
+          @matcher = matcher
+          @sampler = sampler
+        end
+
+        # Evaluates if the provided `trace` conforms to the `matcher`.
+        #
+        # @param [TraceOperation] trace
+        # @return [Boolean] whether this rules applies to the trace
+        # @return [NilClass] if the matcher fails errs during evaluation
+        def match?(trace)
+          @matcher.match?(trace)
+        rescue => e
+          Datadog.logger.error(
+            "Matcher failed. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+          )
+          nil
+        end
+
+        # (see Datadog::Tracing::Sampling::Sampler#sample?)
+        def sample?(trace)
+          @sampler.sample?(trace)
+        end
+
+        # (see Datadog::Tracing::Sampling::Sampler#sample_rate)
+        def sample_rate(trace)
+          @sampler.sample_rate(trace)
+        end
+      end
+
+      # A {Datadog::Tracing::Sampling::Rule} that matches a trace based on
+      # trace name and/or service name and
+      # applies a fixed sampling to matching spans.
+      # @public_api
+      class SimpleRule < Rule
+        # @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 sample_rate [Float] Sampling rate between +[0,1]+
+        def initialize(name: SimpleMatcher::MATCH_ALL, service: SimpleMatcher::MATCH_ALL, 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), sampler)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,157 @@
+require_relative 'ext'
+require_relative 'rate_limiter'
+require_relative 'rule'
+
+module Datadog
+  module Tracing
+    module Sampling
+      # Span {Sampler} that applies a set of {Rule}s to decide
+      # on sampling outcome. Then, a rate limiter is applied.
+      #
+      # If a trace does not conform to any rules, a default
+      # sampling strategy is applied.
+      # @public_api
+      class RuleSampler
+        attr_reader :rules, :rate_limiter, :default_sampler
+
+        # @param rules [Array<Rule>] ordered list of rules to be applied to a trace
+        # @param rate_limit [Float] number of traces per second, defaults to +100+
+        # @param rate_limiter [RateLimiter] limiter applied after rule matching
+        # @param default_sample_rate [Float] fallback sample rate when no rules apply to a trace,
+        #   between +[0,1]+, defaults to +1+
+        # @param default_sampler [Sample] fallback strategy when no rules apply to a trace
+        def initialize(
+          rules = [],
+          rate_limit: Datadog.configuration.tracing.sampling.rate_limit,
+          rate_limiter: nil,
+          default_sample_rate: Datadog.configuration.tracing.sampling.default_rate,
+          default_sampler: nil
+        )
+          @rules = rules
+          @rate_limiter = if rate_limiter
+                            rate_limiter
+                          elsif rate_limit
+                            TokenBucket.new(rate_limit)
+                          else
+                            UnlimitedLimiter.new
+                          end
+
+          @default_sampler = if default_sampler
+                               default_sampler
+                             elsif default_sample_rate
+                               # Add to the end of the rule list a rule always matches any trace
+                               @rules << SimpleRule.new(sample_rate: 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
+        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'],
+              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
+        # return the same result as a successive call to {#sample!} with the same trace.
+        #
+        # Use {#sample!} instead
+        def sample?(_trace)
+          raise 'RuleSampler cannot be evaluated without side-effects'
+        end
+
+        def sample!(trace)
+          sampled = sample_trace(trace) do |t|
+            @default_sampler.sample!(t).tap do
+              # We want to make sure the trace is tagged with the agent-derived
+              # service rate. Retrieve this from the rate by service sampler.
+              # Only do this if it was set by a RateByServiceSampler.
+              trace.agent_sample_rate = @default_sampler.sample_rate(trace) if @default_sampler.is_a?(RateByServiceSampler)
+            end
+          end
+
+          trace.sampled = sampled
+        end
+
+        # @!visibility private
+        def update(*args, **kwargs)
+          return false unless @default_sampler.respond_to?(:update)
+
+          @default_sampler.update(*args, **kwargs)
+        end
+
+        private
+
+        def sample_trace(trace)
+          rule = @rules.find { |r| r.match?(trace) }
+
+          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?(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(
+            "Rule sampling failed. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+          )
+          yield(trace)
+        end
+
+        # Span priority should only be set when the {RuleSampler}
+        # 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
+        end
+
+        def set_rule_metrics(trace, sample_rate)
+          trace.rule_sample_rate = sample_rate
+        end
+
+        def set_limiter_metrics(trace, limiter_rate)
+          trace.rate_limiter_rate = limiter_rate
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module Datadog
+  module Tracing
+    module Sampling
+      # Interface for client-side trace sampling.
+      # @abstract
+      # @public_api
+      class Sampler
+        # Returns `true` if the provided trace should be kept.
+        # Otherwise, `false`.
+        #
+        # This method *must not* modify the `trace`.
+        #
+        # @param [Datadog::Tracing::TraceOperation] trace
+        # @return [Boolean] should this trace be kept?
+        def sample?(trace)
+          raise NotImplementedError, 'Samplers must implement the #sample? method'
+        end
+
+        # Returns `true` if the provided trace should be kept.
+        # Otherwise, `false`.
+        #
+        # This method *may* modify the `trace`, in case changes are necessary based on the
+        # sampling decision.
+        #
+        # @param [Datadog::Tracing::TraceOperation] trace
+        # @return [Boolean] should this trace be kept?
+        def sample!(trace)
+          raise NotImplementedError, 'Samplers must implement the #sample! method'
+        end
+
+        # The sampling rate, if this sampler has such concept.
+        # Otherwise, `nil`.
+        #
+        # @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'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Sampling
+      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 = '*'
+
+          # Matches span name and service to their respective patterns provided.
+          #
+          # The patterns are {String}s with two special characters available:
+          # 1. `?`: matches exactly one of any character.
+          # 2. `*`: matches a substring of any size, including zero.
+          # These patterns can occur any point of the string, any number of times.
+          #
+          # Both {SpanOperation#name} and {SpanOperation#service} must match the provided patterns.
+          #
+          # The whole String has to match the provided patterns: providing a pattern that
+          # matches a portion of the provided String is not considered a match.
+          #
+          # @example web-*
+          #   `'web-*'` will match any string starting with `web-`.
+          # @example cache-?
+          #   `'cache-?'` will match any string starting with `database-` followed by exactly one character.
+          #
+          # @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)
+          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
+          end
+
+          def ==(other)
+            return super unless other.is_a?(Matcher)
+
+            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
+  end
+end