dox-jaeger-client 2.0.0

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'
+      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.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative 'samplers/const'
+require_relative 'samplers/guaranteed_throughput_probabilistic'
+require_relative 'samplers/per_operation'
+require_relative 'samplers/probabilistic'
+require_relative 'samplers/rate_limiting'
+require_relative 'samplers/remote_controlled'

data/lib/jaeger/scope.rb

@@ -0,0 +1,39 @@
+# 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/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

data/lib/jaeger/scope_manager.rb

@@ -0,0 +1,48 @@
+# 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/span/thrift_log_builder.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Jaeger
+  class Span
+    class ThriftLogBuilder
+      FIELDS = Jaeger::Thrift::Log::FIELDS
+      TIMESTAMP = FIELDS[Jaeger::Thrift::Log::TIMESTAMP].fetch(:name)
+      LOG_FIELDS = FIELDS[Jaeger::Thrift::Log::LOG_FIELDS].fetch(:name)
+
+      def self.build(timestamp, fields)
+        Jaeger::Thrift::Log.new(
+          TIMESTAMP => (timestamp.to_f * 1_000_000).to_i,
+          LOG_FIELDS => fields.map { |key, value| ThriftTagBuilder.build(key, value) }
+        )
+      end
+    end
+  end
+end

data/lib/jaeger/span.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require_relative 'span/thrift_log_builder'
+
+module Jaeger
+  class Span
+    attr_accessor :operation_name
+
+    attr_reader :context, :start_time, :end_time, :references, :tags, :logs
+
+    # Creates a new {Span}
+    #
+    # @param context [SpanContext] the context of the span
+    # @param operation_name [String] the operation name
+    # @param reporter [#report] span reporter
+    #
+    # @return [Span] a new Span
+    def initialize(context, operation_name, reporter, start_time: Time.now, references: [], tags: {})
+      @context = context
+      @operation_name = operation_name
+      @reporter = reporter
+      @start_time = start_time
+      @references = references
+      @tags = []
+      @logs = []
+
+      tags.each { |key, value| set_tag(key, value) }
+    end
+
+    # Set a tag value on this span
+    #
+    # @param key [String] the key of the tag
+    # @param value [String, Numeric, Boolean] the value of the tag. If it's not
+    # a String, Numeric, or Boolean it will be encoded with to_s
+    def set_tag(key, value)
+      if key == 'sampling.priority'
+        if value.to_i.positive?
+          return self if @context.debug?
+
+          @context.flags = @context.flags | SpanContext::Flags::SAMPLED | SpanContext::Flags::DEBUG
+        else
+          @context.flags = @context.flags & ~SpanContext::Flags::SAMPLED
+        end
+        return self
+      end
+
+      # Using Thrift::Tag to avoid unnecessary memory allocations
+      @tags << ThriftTagBuilder.build(key, value)
+
+      self
+    end
+
+    # Set a baggage item on the span
+    #
+    # @param key [String] the key of the baggage item
+    # @param value [String] the value of the baggage item
+    def set_baggage_item(key, value)
+      @context.set_baggage_item(key, value)
+      self
+    end
+
+    # Get a baggage item
+    #
+    # @param key [String] the key of the baggage item
+    #
+    # @return Value of the baggage item
+    def get_baggage_item(key)
+      @context.get_baggage_item(key)
+    end
+
+    # Add a log entry to this span
+    #
+    # @deprecated Use {#log_kv} instead.
+    def log(...)
+      warn 'Span#log is deprecated. Please use Span#log_kv instead.'
+      log_kv(...)
+    end
+
+    # Add a log entry to this span
+    #
+    # @param timestamp [Time] time of the log
+    # @param fields [Hash] Additional information to log
+    def log_kv(timestamp: Time.now, **fields)
+      # Using Thrift::Log to avoid unnecessary memory allocations
+      @logs << ThriftLogBuilder.build(timestamp, fields)
+      nil
+    end
+
+    # Finish the {Span}
+    #
+    # @param end_time [Time] custom end time, if not now
+    def finish(end_time: Time.now)
+      @end_time = end_time
+      @reporter.report(self)
+    end
+  end
+end

data/lib/jaeger/span_context.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Jaeger
+  # SpanContext holds the data for a span that gets inherited to child spans
+  class SpanContext
+    module Flags
+      NONE = 0x00
+      SAMPLED = 0x01
+      DEBUG = 0x02
+    end
+
+    def self.create_from_parent_context(span_context)
+      new(
+        trace_id: span_context.trace_id,
+        parent_id: span_context.span_id,
+        span_id: TraceId.generate,
+        flags: span_context.flags,
+        baggage: span_context.baggage.dup
+      )
+    end
+
+    attr_accessor :flags
+    attr_reader :span_id, :parent_id, :trace_id, :baggage
+
+    def initialize(span_id:, trace_id:, flags:, parent_id: 0, baggage: {})
+      @span_id = span_id
+      @parent_id = parent_id
+      @trace_id = trace_id
+      @baggage = baggage
+      @flags = flags
+    end
+
+    def sampled?
+      @flags & Flags::SAMPLED == Flags::SAMPLED
+    end
+
+    def debug?
+      @flags & Flags::DEBUG == Flags::DEBUG
+    end
+
+    def to_trace_id
+      @to_trace_id ||= @trace_id.to_s(16)
+    end
+
+    def to_span_id
+      @to_span_id ||= @span_id.to_s(16)
+    end
+
+    def set_baggage_item(key, value)
+      @baggage[key.to_s] = value.to_s
+    end
+
+    def get_baggage_item(key)
+      @baggage[key.to_s]
+    end
+  end
+end

data/lib/jaeger/thrift_tag_builder.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Jaeger
+  class ThriftTagBuilder
+    FIELDS = Jaeger::Thrift::Tag::FIELDS
+    KEY = FIELDS[Jaeger::Thrift::Tag::KEY].fetch(:name)
+    VTYPE = FIELDS[Jaeger::Thrift::Tag::VTYPE].fetch(:name)
+    VLONG = FIELDS[Jaeger::Thrift::Tag::VLONG].fetch(:name)
+    VDOUBLE = FIELDS[Jaeger::Thrift::Tag::VDOUBLE].fetch(:name)
+    VBOOL = FIELDS[Jaeger::Thrift::Tag::VBOOL].fetch(:name)
+    VSTR = FIELDS[Jaeger::Thrift::Tag::VSTR].fetch(:name)
+
+    def self.build(key, value)
+      case value
+      when Integer
+        Jaeger::Thrift::Tag.new(
+          KEY => key.to_s,
+          VTYPE => Jaeger::Thrift::TagType::LONG,
+          VLONG => value
+        )
+      when Float
+        Jaeger::Thrift::Tag.new(
+          KEY => key.to_s,
+          VTYPE => Jaeger::Thrift::TagType::DOUBLE,
+          VDOUBLE => value
+        )
+      when TrueClass, FalseClass
+        Jaeger::Thrift::Tag.new(
+          KEY => key.to_s,
+          VTYPE => Jaeger::Thrift::TagType::BOOL,
+          VBOOL => value
+        )
+      else
+        Jaeger::Thrift::Tag.new(
+          KEY => key.to_s,
+          VTYPE => Jaeger::Thrift::TagType::STRING,
+          VSTR => value.to_s
+        )
+      end
+    end
+  end
+end

data/lib/jaeger/trace_id.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Jaeger
+  module TraceId
+    MAX_64BIT_SIGNED_INT = (1 << 63) - 1
+    MAX_64BIT_UNSIGNED_INT = (1 << 64) - 1
+    MAX_128BIT_UNSIGNED_INT = (1 << 128) - 1
+    TRACE_ID_UPPER_BOUND = MAX_64BIT_UNSIGNED_INT + 1
+
+    def self.generate
+      rand(TRACE_ID_UPPER_BOUND)
+    end
+
+    def self.base16_hex_id_to_uint64(id)
+      return nil unless id
+
+      value = id.to_i(16)
+      value > MAX_64BIT_UNSIGNED_INT || value.negative? ? 0 : value
+    end
+
+    def self.base16_hex_id_to_uint128(id)
+      return nil unless id
+
+      value = id.to_i(16)
+      value > MAX_128BIT_UNSIGNED_INT || value.negative? ? 0 : value
+    end
+
+    # Thrift defines ID fields as i64, which is signed, therefore we convert
+    # large IDs (> 2^63) to negative longs
+    def self.uint64_id_to_int64(id)
+      id > MAX_64BIT_SIGNED_INT ? id - MAX_64BIT_UNSIGNED_INT - 1 : id
+    end
+
+    # Convert an integer id into a 0 padded hex string.
+    # If the string is shorter than 16 characters, it will be padded to 16.
+    # If it is longer than 16 characters, it is padded to 32.
+    def self.to_hex(id)
+      hex_str = id.to_s(16)
+
+      # pad the string with '0's to 16 or 32 characters
+      if hex_str.length > 16
+        hex_str.rjust(32, '0')
+      else
+        hex_str.rjust(16, '0')
+      end
+    end
+  end
+end