jaeger-client 0.9.0 → 0.10.0

data/lib/jaeger/client/rate_limiter.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-module Jaeger
-  module Client
-    # 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
-end

data/lib/jaeger/client/reporters/composite_reporter.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Jaeger
-  module Client
-    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
-end

data/lib/jaeger/client/reporters/in_memory_reporter.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module Jaeger
-  module Client
-    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
-end

data/lib/jaeger/client/reporters/logging_reporter.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Jaeger
-  module Client
-    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
-end

data/lib/jaeger/client/reporters/null_reporter.rb

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

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

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-require_relative './remote_reporter/buffer'
-
-module Jaeger
-  module Client
-    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
-end

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

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Jaeger
-  module Client
-    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
-end

data/lib/jaeger/client/samplers/const.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Jaeger
-  module Client
-    module Samplers
-      # Const sampler
-      #
-      # A sampler that always makes the same decision for new traces depending
-      # on the initialization value. Use `Jaeger::Client::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
-end

data/lib/jaeger/client/samplers/guaranteed_throughput_probabilistic.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module Jaeger
-  module Client
-    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
-end

data/lib/jaeger/client/samplers/per_operation.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module Jaeger
-  module Client
-    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
-end

data/lib/jaeger/client/samplers/probabilistic.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Jaeger
-  module Client
-    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
-end

data/lib/jaeger/client/samplers/rate_limiting.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Jaeger
-  module Client
-    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
-end

data/lib/jaeger/client/scope.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Jaeger
-  module Client
-    # 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
-end