jaeger-client 0.9.0 → 0.10.0

data/lib/jaeger/rate_limiter.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Jaeger
+  # RateLimiter is based on leaky bucket algorithm, formulated in terms of a
+  # credits balance that is replenished every time check_credit() method is
+  # called (tick) by the amount proportional to the time elapsed since the
+  # last tick, up to the max_balance. A call to check_credit() takes a cost
+  # of an item we want to pay with the balance. If the balance exceeds the
+  # cost of the item, the item is "purchased" and the balance reduced,
+  # indicated by returned value of true. Otherwise the balance is unchanged
+  # and return false.
+  #
+  # This can be used to limit a rate of messages emitted by a service by
+  # instantiating the Rate Limiter with the max number of messages a service
+  # is allowed to emit per second, and calling check_credit(1.0) for each
+  # message to determine if the message is within the rate limit.
+  #
+  # It can also be used to limit the rate of traffic in bytes, by setting
+  # credits_per_second to desired throughput as bytes/second, and calling
+  # check_credit() with the actual message size.
+  class RateLimiter
+    def initialize(credits_per_second:, max_balance:)
+      @credits_per_second = credits_per_second
+      @max_balance = max_balance
+      @balance = max_balance
+      @last_tick = Time.now
+    end
+
+    def check_credit(item_cost)
+      update_balance
+
+      return false if @balance < item_cost
+
+      @balance -= item_cost
+      true
+    end
+
+    def update(credits_per_second:, max_balance:)
+      update_balance
+
+      @credits_per_second = credits_per_second
+
+      # The new balance should be proportional to the old balance
+      @balance = max_balance * @balance / @max_balance
+      @max_balance = max_balance
+    end
+
+    private
+
+    def update_balance
+      current_time = Time.now
+      elapsed_time = current_time - @last_tick
+      @last_tick = current_time
+
+      @balance += elapsed_time * @credits_per_second
+      return if @balance <= @max_balance
+
+      @balance = @max_balance
+    end
+  end
+end

data/lib/jaeger/reporters/composite_reporter.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Jaeger
+  module Reporters
+    class CompositeReporter
+      def initialize(reporters:)
+        @reporters = reporters
+      end
+
+      def report(span)
+        @reporters.each do |reporter|
+          reporter.report(span)
+        end
+      end
+    end
+  end
+end

data/lib/jaeger/reporters/in_memory_reporter.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Jaeger
+  module Reporters
+    class InMemoryReporter
+      def initialize
+        @spans = []
+        @mutex = Mutex.new
+      end
+
+      def report(span)
+        @mutex.synchronize do
+          @spans << span
+        end
+      end
+
+      def spans
+        @mutex.synchronize do
+          @spans
+        end
+      end
+
+      def clear
+        @mutex.synchronize do
+          @spans.clear
+        end
+      end
+    end
+  end
+end

data/lib/jaeger/reporters/logging_reporter.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Jaeger
+  module Reporters
+    class LoggingReporter
+      def initialize(logger: Logger.new($stdout))
+        @logger = logger
+      end
+
+      def report(span)
+        span_info = {
+          operation_name: span.operation_name,
+          start_time: span.start_time.iso8601,
+          end_time: span.end_time.iso8601,
+          trace_id: span.context.to_trace_id,
+          span_id: span.context.to_span_id
+        }
+        @logger.info "Span reported: #{span_info}"
+      end
+    end
+  end
+end

data/lib/jaeger/reporters/null_reporter.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Jaeger
+  module Reporters
+    class NullReporter
+      def report(_span)
+        # no-op
+      end
+    end
+  end
+end

data/lib/jaeger/reporters/remote_reporter.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative './remote_reporter/buffer'
+
+module Jaeger
+  module Reporters
+    class RemoteReporter
+      def initialize(sender:, flush_interval:)
+        @sender = sender
+        @flush_interval = flush_interval
+        @buffer = Buffer.new
+      end
+
+      def flush
+        spans = @buffer.retrieve
+        @sender.send_spans(spans) if spans.any?
+        spans
+      end
+
+      def report(span)
+        return if !span.context.sampled? && !span.context.debug?
+
+        init_reporter_thread
+        @buffer << span
+      end
+
+      private
+
+      def init_reporter_thread
+        return if @initializer_pid == Process.pid
+
+        @initializer_pid = Process.pid
+        Thread.new do
+          loop do
+            flush
+            sleep(@flush_interval)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jaeger/reporters/remote_reporter/buffer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Jaeger
+  module Reporters
+    class RemoteReporter
+      class Buffer
+        def initialize
+          @buffer = []
+          @mutex = Mutex.new
+        end
+
+        def <<(element)
+          @mutex.synchronize do
+            @buffer << element
+            true
+          end
+        end
+
+        def retrieve
+          @mutex.synchronize do
+            elements = @buffer.dup
+            @buffer.clear
+            elements
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jaeger/samplers/const.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Jaeger
+  module Samplers
+    # Const sampler
+    #
+    # A sampler that always makes the same decision for new traces depending
+    # on the initialization value. Use `Jaeger::Samplers::Const.new(true)`
+    # to mark all new traces as sampled.
+    class Const
+      def initialize(decision)
+        @decision = decision
+        @tags = {
+          'sampler.type' => 'const',
+          'sampler.param' => @decision ? 1 : 0
+        }
+      end
+
+      def sample?(*)
+        [@decision, @tags]
+      end
+    end
+  end
+end

data/lib/jaeger/samplers/guaranteed_throughput_probabilistic.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Jaeger
+  module Samplers
+    # A sampler that leverages both Probabilistic sampler and RateLimiting
+    # sampler. The RateLimiting is used as a guaranteed lower bound sampler
+    # such that every operation is sampled at least once in a time interval
+    # defined by the lower_bound. ie a lower_bound of 1.0 / (60 * 10) will
+    # sample an operation at least once every 10 minutes.
+    #
+    # The Probabilistic sampler is given higher priority when tags are
+    # emitted, ie. if is_sampled() for both samplers return true, the tags
+    # for Probabilistic sampler will be used.
+    class GuaranteedThroughputProbabilistic
+      attr_reader :tags
+
+      def initialize(lower_bound:, rate:, lower_bound_sampler: nil)
+        @probabilistic_sampler = Probabilistic.new(rate: rate)
+        @lower_bound_sampler = lower_bound_sampler || RateLimiting.new(max_traces_per_second: lower_bound)
+        @lower_bound_tags = {
+          'sampler.type' => 'lowerbound',
+          'sampler.param' => lower_bound
+        }
+      end
+
+      def sample?(*args)
+        is_sampled, probabilistic_tags = @probabilistic_sampler.sample?(*args)
+        if is_sampled
+          # We still call lower_bound_sampler to update the rate limiter budget
+          @lower_bound_sampler.sample?(*args)
+
+          return [is_sampled, probabilistic_tags]
+        end
+
+        is_sampled, _tags = @lower_bound_sampler.sample?(*args)
+        [is_sampled, @lower_bound_tags]
+      end
+    end
+  end
+end

data/lib/jaeger/samplers/per_operation.rb

@@ -0,0 +1,47 @@
+# 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'
+
+      def initialize(strategies:, max_operations:)
+        @max_operations = max_operations
+        @default_sampling_probability =
+          strategies[:default_sampling_probability] || DEFAULT_SAMPLING_PROBABILITY
+        @lower_bound = strategies[:default_lower_bound_traces_per_second] || DEFAULT_LOWER_BOUND
+
+        @default_sampler = Probabilistic.new(rate: @default_sampling_probability)
+        @samplers = (strategies[:per_operation_strategies] || []).reduce({}) do |acc, strategy|
+          operation = strategy.fetch(:operation)
+          rate = strategy.fetch(:probabilistic_sampling)
+          sampler = GuaranteedThroughputProbabilistic.new(
+            lower_bound: @lower_bound,
+            rate: rate
+          )
+          acc.merge(operation => sampler)
+        end
+      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
+    end
+  end
+end

data/lib/jaeger/samplers/probabilistic.rb

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

data/lib/jaeger/samplers/rate_limiting.rb

@@ -0,0 +1,33 @@
+# 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
+
+      def initialize(max_traces_per_second: 10)
+        if max_traces_per_second < 0.0
+          raise "max_traces_per_second must not be negative, got #{max_traces_per_second}"
+        end
+
+        @rate_limiter = RateLimiter.new(
+          credits_per_second: max_traces_per_second,
+          max_balance: [max_traces_per_second, 1.0].max
+        )
+        @tags = {
+          'sampler.type' => 'ratelimiting',
+          'sampler.param' => max_traces_per_second
+        }
+      end
+
+      def sample?(*)
+        [@rate_limiter.check_credit(1.0), @tags]
+      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