ddtrace 0.54.2 → 1.0.0.beta1

data/lib/ddtrace/sampling/rate_limiter.rb

@@ -1,177 +0,0 @@
-# typed: true
-require 'ddtrace/utils/time'
-
-module Datadog
-  module Sampling
-    # Checks for rate limiting on a resource.
-    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
-    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)
-        @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 = 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 = 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 = 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
-
-    # \RateLimiter that accepts all resources,
-    # with no limits.
-    class UnlimitedLimiter < RateLimiter
-      # @return [Boolean] always +true+
-      def allow?(_)
-        true
-      end
-
-      # @return [Float] always 100%
-      def effective_rate
-        1.0
-      end
-    end
-  end
-end

data/lib/ddtrace/sampling/rule.rb

@@ -1,62 +0,0 @@
-# typed: true
-require 'forwardable'
-
-require 'ddtrace/sampling/matcher'
-require 'ddtrace/sampler'
-
-module Datadog
-  module Sampling
-    # Sampling rule that dictates if a span matches
-    # a specific criteria and what sampling strategy to
-    # apply in case of a positive match.
-    class Rule
-      extend Forwardable
-
-      attr_reader :matcher, :sampler
-
-      # @param [Matcher] matcher A matcher to verify span 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 `span` conforms to the `matcher`.
-      #
-      # @param [Span] span
-      # @return [Boolean] whether this rules applies to the span
-      # @return [NilClass] if the matcher fails errs during evaluation
-      def match?(span)
-        @matcher.match?(span)
-      rescue => e
-        Datadog.logger.error("Matcher failed. Cause: #{e.message} Source: #{Array(e.backtrace).first}")
-        nil
-      end
-
-      def_delegators :@sampler, :sample?, :sample_rate
-    end
-
-    # A \Rule that matches a span based on
-    # operation name and/or service name and
-    # applies a fixed sampling to matching spans.
-    class SimpleRule < Rule
-      # @param name [String,Regexp,Proc] Matcher for case equality (===) with the span 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 \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 \RateSampler
-        # because it breaks its current contract to existing users.
-        sampler = Datadog::RateSampler.new
-        sampler.sample_rate = sample_rate
-
-        super(SimpleMatcher.new(name: name, service: service), sampler)
-      end
-    end
-  end
-end

data/lib/ddtrace/sampling/rule_sampler.rb

@@ -1,133 +0,0 @@
-# typed: true
-require 'forwardable'
-
-require 'ddtrace/ext/priority'
-
-require 'ddtrace/ext/sampling'
-require 'ddtrace/sampler'
-require 'ddtrace/sampling/rate_limiter'
-require 'ddtrace/sampling/rule'
-
-module Datadog
-  module Sampling
-    # Span {Sampler} that applies a set of {Rule}s to decide
-    # on sampling outcome. Then, a rate limiter is applied.
-    #
-    # If a span does not conform to any rules, a default
-    # sampling strategy is applied.
-    class RuleSampler
-      extend Forwardable
-
-      AGENT_RATE_METRIC_KEY = '_dd.agent_psr'.freeze
-
-      attr_reader :rules, :rate_limiter, :default_sampler
-
-      # @param rules [Array<Rule>] ordered list of rules to be applied to a span
-      # @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 span,
-      #   between +[0,1]+, defaults to +1+
-      # @param default_sampler [Sample] fallback strategy when no rules apply to a span
-      def initialize(rules = [],
-                     rate_limit: Datadog.configuration.sampling.rate_limit,
-                     rate_limiter: nil,
-                     default_sample_rate: Datadog.configuration.sampling.default_rate,
-                     default_sampler: nil)
-
-        @rules = rules
-
-        @rate_limiter = if rate_limiter
-                          rate_limiter
-                        elsif rate_limit
-                          Datadog::Sampling::TokenBucket.new(rate_limit)
-                        else
-                          Datadog::Sampling::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 span
-                             @rules << SimpleRule.new(sample_rate: default_sample_rate)
-                           else
-                             RateByServiceSampler.new(1.0, env: -> { Datadog.tracer.tags[:env] })
-                           end
-      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 span.
-      #
-      # Use {#sample!} instead
-      def sample?(_span)
-        raise 'RuleSampler cannot be evaluated without side-effects'
-      end
-
-      def sample!(span)
-        sampled = sample_span(span) do |s|
-          @default_sampler.sample!(s).tap do
-            # We want to make sure the span 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.
-            if @default_sampler.is_a?(RateByServiceSampler)
-              s.set_metric(AGENT_RATE_METRIC_KEY, @default_sampler.sample_rate(span))
-            end
-          end
-        end
-
-        sampled.tap do
-          span.sampled = sampled
-        end
-      end
-
-      def update(*args)
-        return false unless @default_sampler.respond_to?(:update)
-
-        @default_sampler.update(*args)
-      end
-
-      private
-
-      def sample_span(span)
-        rule = @rules.find { |r| r.match?(span) }
-
-        return yield(span) if rule.nil?
-
-        sampled = rule.sample?(span)
-        sample_rate = rule.sample_rate(span)
-
-        set_priority(span, sampled)
-        set_rule_metrics(span, sample_rate)
-
-        return false unless sampled
-
-        rate_limiter.allow?(1).tap do |allowed|
-          set_priority(span, allowed)
-          set_limiter_metrics(span, rate_limiter.effective_rate)
-        end
-      rescue StandardError => e
-        Datadog.logger.error("Rule sampling failed. Cause: #{e.message} Source: #{Array(e.backtrace).first}")
-        yield(span)
-      end
-
-      # Span priority should only be set when the {RuleSampler}
-      # was responsible for the sampling decision.
-      def set_priority(span, sampled)
-        if sampled
-          ForcedTracing.keep(span)
-        else
-          ForcedTracing.drop(span)
-        end
-      end
-
-      def set_rule_metrics(span, sample_rate)
-        span.set_metric(Ext::Sampling::RULE_SAMPLE_RATE, sample_rate)
-      end
-
-      def set_limiter_metrics(span, limiter_rate)
-        span.set_metric(Ext::Sampling::RATE_LIMITER_RATE, limiter_rate)
-      end
-    end
-  end
-end

data/lib/ddtrace/sampling.rb

@@ -1,3 +0,0 @@
-# typed: strict
-require 'ddtrace/sampling/rule'
-require 'ddtrace/sampling/rule_sampler'