jaeger-client 0.7.1 → 1.1.0

data/lib/jaeger/samplers/per_operation.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Jaeger
+  module Samplers
+    # A sampler that leverages both Probabilistic sampler and RateLimiting
+    # sampler via the GuaranteedThroughputProbabilistic sampler. This sampler
+    # keeps track of all operations and delegates calls the the respective
+    # GuaranteedThroughputProbabilistic sampler.
+    class PerOperation
+      DEFAULT_SAMPLING_PROBABILITY = 0.001
+      DEFAULT_LOWER_BOUND = 1.0 / (10.0 * 60.0) # sample once every 10 minutes'
+
+      attr_reader :default_sampling_probability, :lower_bound, :samplers
+
+      def initialize(strategies:, max_operations:)
+        @max_operations = max_operations
+        @samplers = {}
+        update(strategies: strategies)
+      end
+
+      def update(strategies:)
+        is_updated = false
+
+        @default_sampling_probability =
+          strategies[:default_sampling_probability] || DEFAULT_SAMPLING_PROBABILITY
+        @lower_bound =
+          strategies[:default_lower_bound_traces_per_second] || DEFAULT_LOWER_BOUND
+
+        if @default_sampler
+          is_updated = @default_sampler.update(rate: @default_sampling_probability)
+        else
+          @default_sampler = Probabilistic.new(rate: @default_sampling_probability)
+        end
+
+        is_updated = update_operation_strategies(strategies) || is_updated
+
+        is_updated
+      end
+
+      def sample(opts)
+        operation_name = opts.fetch(:operation_name)
+        sampler = @samplers[operation_name]
+        return sampler.sample(opts) if sampler
+
+        return @default_sampler.sample(opts) if @samplers.length >= @max_operations
+
+        sampler = GuaranteedThroughputProbabilistic.new(
+          lower_bound: @lower_bound,
+          rate: @default_sampling_probability
+        )
+        @samplers[operation_name] = sampler
+        sampler.sample(opts)
+      end
+
+      private
+
+      def update_operation_strategies(strategies)
+        is_updated = false
+
+        (strategies[:per_operation_strategies] || []).each do |strategy|
+          operation = strategy.fetch(:operation)
+          rate = strategy.fetch(:probabilistic_sampling).fetch(:sampling_rate)
+
+          if (sampler = @samplers[operation])
+            is_updated = sampler.update(lower_bound: @lower_bound, rate: rate) || is_updated
+          else
+            @samplers[operation] = GuaranteedThroughputProbabilistic.new(
+              lower_bound: @lower_bound,
+              rate: rate
+            )
+            is_updated = true
+          end
+        end
+
+        is_updated
+      end
+    end
+  end
+end

data/lib/jaeger/samplers/probabilistic.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Jaeger
+  module Samplers
+    # Probabilistic sampler
+    #
+    # Sample a portion of traces using trace_id as the random decision
+    class Probabilistic
+      attr_reader :rate
+
+      def initialize(rate: 0.001)
+        update(rate: rate)
+      end
+
+      def update(rate:)
+        if rate < 0.0 || rate > 1.0
+          raise "Sampling rate must be between 0.0 and 1.0, got #{rate.inspect}"
+        end
+
+        new_boundary = TraceId::TRACE_ID_UPPER_BOUND * rate
+        return false if @boundary == new_boundary
+
+        @rate = rate
+        @boundary = TraceId::TRACE_ID_UPPER_BOUND * rate
+        @tags = {
+          'sampler.type' => 'probabilistic',
+          'sampler.param' => rate
+        }
+
+        true
+      end
+
+      def sample(trace_id:, **)
+        [@boundary >= trace_id, @tags]
+      end
+    end
+  end
+end

data/lib/jaeger/samplers/rate_limiting.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Jaeger
+  module Samplers
+    # Samples at most max_traces_per_second. The distribution of sampled
+    # traces follows burstiness of the service, i.e. a service with uniformly
+    # distributed requests will have those requests sampled uniformly as
+    # well, but if requests are bursty, especially sub-second, then a number
+    # of sequential requests can be sampled each second.
+    class RateLimiting
+      attr_reader :tags, :max_traces_per_second
+
+      def initialize(max_traces_per_second: 10)
+        update(max_traces_per_second: max_traces_per_second)
+      end
+
+      def update(max_traces_per_second:)
+        if max_traces_per_second < 0.0
+          raise "max_traces_per_second must not be negative, got #{max_traces_per_second}"
+        end
+
+        return false if max_traces_per_second == @max_traces_per_second
+
+        @tags = {
+          'sampler.type' => 'ratelimiting',
+          'sampler.param' => max_traces_per_second
+        }
+        @max_traces_per_second = max_traces_per_second
+        max_balance = [max_traces_per_second, 1.0].max
+
+        if @rate_limiter
+          @rate_limiter.update(
+            credits_per_second: max_traces_per_second,
+            max_balance: max_balance
+          )
+        else
+          @rate_limiter = RateLimiter.new(
+            credits_per_second: max_traces_per_second,
+            max_balance: [max_traces_per_second, 1.0].max
+          )
+        end
+
+        true
+      end
+
+      def sample(*)
+        [@rate_limiter.check_credit(1.0), @tags]
+      end
+    end
+  end
+end

data/lib/jaeger/samplers/remote_controlled.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require_relative 'remote_controlled/instructions_fetcher'
+
+module Jaeger
+  module Samplers
+    class RemoteControlled
+      DEFAULT_REFRESH_INTERVAL = 60
+      DEFAULT_SAMPLING_HOST = 'localhost'.freeze
+      DEFAULT_SAMPLING_PORT = 5778
+
+      attr_reader :sampler
+
+      def initialize(opts = {})
+        @sampler = opts.fetch(:sampler, Probabilistic.new)
+        @logger = opts.fetch(:logger, Logger.new($stdout))
+
+        @poll_executor = opts[:poll_executor] || begin
+          refresh_interval = opts.fetch(:refresh_interval, DEFAULT_REFRESH_INTERVAL)
+          RecurringExecutor.new(interval: refresh_interval)
+        end
+
+        @instructions_fetcher = opts[:instructions_fetcher] || begin
+          service_name = opts.fetch(:service_name)
+          host = opts.fetch(:host, DEFAULT_SAMPLING_HOST)
+          port = opts.fetch(:port, DEFAULT_SAMPLING_PORT)
+          InstructionsFetcher.new(host: host, port: port, service_name: service_name)
+        end
+      end
+
+      def sample(*args)
+        @poll_executor.start(&method(:poll)) unless @poll_executor.running?
+
+        @sampler.sample(*args)
+      end
+
+      def poll
+        @logger.debug 'Fetching sampling strategy'
+
+        instructions = @instructions_fetcher.fetch
+        handle_instructions(instructions)
+      rescue InstructionsFetcher::FetchFailed => e
+        @logger.warn "Fetching sampling strategy failed: #{e.message}"
+      end
+
+      private
+
+      def handle_instructions(instructions)
+        if instructions['operationSampling']
+          update_per_operation_sampler(instructions['operationSampling'])
+        else
+          update_rate_limiting_or_probabilistic_sampler(instructions['strategyType'], instructions)
+        end
+      end
+
+      def update_per_operation_sampler(instructions)
+        strategies = normalize(instructions)
+
+        if @sampler.is_a?(PerOperation)
+          @sampler.update(strategies: strategies)
+        else
+          @sampler = PerOperation.new(strategies: strategies, max_operations: 2000)
+        end
+      end
+
+      def normalize(instructions)
+        {
+          default_sampling_probability: instructions['defaultSamplingProbability'],
+          default_lower_bound_traces_per_second: instructions['defaultLowerBoundTracesPerSecond'],
+          per_operation_strategies: instructions['perOperationStrategies'].map do |strategy|
+            {
+              operation: strategy['operation'],
+              probabilistic_sampling: {
+                sampling_rate: strategy['probabilisticSampling']['samplingRate']
+              }
+            }
+          end
+        }
+      end
+
+      def update_rate_limiting_or_probabilistic_sampler(strategy, instructions)
+        case strategy
+        when 'PROBABILISTIC'
+          update_probabilistic_strategy(instructions['probabilisticSampling'])
+        when 'RATE_LIMITING'
+          update_rate_limiting_strategy(instructions['rateLimitingSampling'])
+        else
+          @logger.warn "Unknown sampling strategy #{strategy}"
+        end
+      end
+
+      def update_probabilistic_strategy(instructions)
+        rate = instructions['samplingRate']
+        return unless rate
+
+        if @sampler.is_a?(Probabilistic)
+          @sampler.update(rate: rate)
+          @logger.info "Updated Probabilistic sampler (rate=#{rate})"
+        else
+          @sampler = Probabilistic.new(rate: rate)
+          @logger.info "Updated sampler to Probabilistic (rate=#{rate})"
+        end
+      end
+
+      def update_rate_limiting_strategy(instructions)
+        max_traces_per_second = instructions['maxTracesPerSecond']
+        return unless max_traces_per_second
+
+        if @sampler.is_a?(RateLimiting)
+          @sampler.update(max_traces_per_second: max_traces_per_second)
+          @logger.info "Updated Ratelimiting sampler (max_traces_per_second=#{max_traces_per_second})"
+        else
+          @sampler = RateLimiting.new(max_traces_per_second: max_traces_per_second)
+          @logger.info "Updated sampler to Ratelimiting (max_traces_per_second=#{max_traces_per_second})"
+        end
+      end
+    end
+  end
+end

data/lib/jaeger/samplers/remote_controlled/instructions_fetcher.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Jaeger
+  module Samplers
+    class RemoteControlled
+      class InstructionsFetcher
+        FetchFailed = Class.new(StandardError)
+
+        def initialize(host:, port:, service_name:)
+          @host = host
+          @port = port
+          @service_name = service_name
+        end
+
+        def fetch
+          http = Net::HTTP.new(@host, @port)
+          path = "/sampling?service=#{CGI.escape(@service_name)}"
+          response =
+            begin
+              http.request(Net::HTTP::Get.new(path))
+            rescue StandardError => e
+              raise FetchFailed, e.inspect
+            end
+
+          unless response.is_a?(Net::HTTPSuccess)
+            raise FetchFailed, "Unsuccessful response (code=#{response.code})"
+          end
+
+          JSON.parse(response.body)
+        end
+      end
+    end
+  end
+end

data/lib/jaeger/scope.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Jaeger
+  # Scope represents an OpenTracing Scope
+  #
+  # See http://www.opentracing.io for more information.
+  class Scope
+    def initialize(span, scope_stack, finish_on_close:)
+      @span = span
+      @scope_stack = scope_stack
+      @finish_on_close = finish_on_close
+      @closed = false
+    end
+
+    # Return the Span scoped by this Scope
+    #
+    # @return [Span]
+    attr_reader :span
+
+    # Close scope
+    #
+    # Mark the end of the active period for the current thread and Scope,
+    # updating the ScopeManager#active in the process.
+    def close
+      raise "Tried to close already closed span: #{inspect}" if @closed
+      @closed = true
+
+      @span.finish if @finish_on_close
+      removed_scope = @scope_stack.pop
+
+      if removed_scope != self # rubocop:disable Style/GuardClause
+        raise 'Removed non-active scope, ' \
+          "removed: #{removed_scope.inspect}, "\
+          "expected: #{inspect}"
+      end
+    end
+  end
+end

data/lib/jaeger/scope_manager.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative 'scope_manager/scope_stack'
+require_relative 'scope_manager/scope_identifier'
+
+module Jaeger
+  # ScopeManager represents an OpenTracing ScopeManager
+  #
+  # See http://www.opentracing.io for more information.
+  #
+  # The ScopeManager interface abstracts both the activation of Span instances
+  # via ScopeManager#activate and access to an active Span/Scope via
+  # ScopeManager#active
+  #
+  class ScopeManager
+    def initialize
+      @scope_stack = ScopeStack.new
+    end
+
+    # Make a span instance active
+    #
+    # @param span [Span] the Span that should become active
+    # @param finish_on_close [Boolean] whether the Span should automatically be
+    #   finished when Scope#close is called
+    # @return [Scope] instance to control the end of the active period for the
+    #  Span. It is a programming error to neglect to call Scope#close on the
+    #  returned instance.
+    def activate(span, finish_on_close: true)
+      return active if active && active.span == span
+      scope = Scope.new(span, @scope_stack, finish_on_close: finish_on_close)
+      @scope_stack.push(scope)
+      scope
+    end
+
+    # Return active scope
+    #
+    # If there is a non-null Scope, its wrapped Span becomes an implicit parent
+    # (as Reference#CHILD_OF) of any newly-created Span at
+    # Tracer#start_active_span or Tracer#start_span time.
+    #
+    # @return [Scope] the currently active Scope which can be used to access the
+    #   currently active Span.
+    def active
+      @scope_stack.peek
+    end
+  end
+end

data/lib/jaeger/scope_manager/scope_identifier.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Jaeger
+  class ScopeManager
+    # @api private
+    class ScopeIdentifier
+      def self.generate
+        # 65..90.chr are characters between A and Z
+        "opentracing_#{(0...8).map { rand(65..90).chr }.join}".to_sym
+      end
+    end
+  end
+end

data/lib/jaeger/scope_manager/scope_stack.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Jaeger
+  class ScopeManager
+    # @api private
+    class ScopeStack
+      def initialize
+        # Generate a random identifier to use as the Thread.current key. This is
+        # needed so that it would be possible to create multiple tracers in one
+        # thread (mostly useful for testing purposes)
+        @scope_identifier = ScopeIdentifier.generate
+      end
+
+      def push(scope)
+        store << scope
+      end
+
+      def pop
+        store.pop
+      end
+
+      def peek
+        store.last
+      end
+
+      private
+
+      def store
+        Thread.current[@scope_identifier] ||= []
+      end
+    end
+  end
+end