jaeger-client 0.10.0 → 1.3.0

data/lib/jaeger/extractors.rb

@@ -6,10 +6,12 @@ module Jaeger
       def self.parse(trace)
         return nil if !trace || trace == ''
 
-        trace_arguments = trace.split(':').map(&TraceId.method(:base16_hex_id_to_uint64))
+        trace_arguments = trace.split(':')
         return nil if trace_arguments.size != 4
 
-        trace_id, span_id, parent_id, flags = trace_arguments
+        trace_id = TraceId.base16_hex_id_to_uint128(trace_arguments[0])
+        span_id, parent_id, flags = trace_arguments[1..3].map(&TraceId.method(:base16_hex_id_to_uint64))
+
         return nil if trace_id.zero? || span_id.zero?
 
         SpanContext.new(
@@ -63,13 +65,47 @@ module Jaeger
     end
 
     class B3RackCodec
+      class Keys
+        TRACE_ID = 'HTTP_X_B3_TRACEID'
+        SPAN_ID = 'HTTP_X_B3_SPANID'
+        PARENT_SPAN_ID = 'HTTP_X_B3_PARENTSPANID'
+        FLAGS = 'HTTP_X_B3_FLAGS'
+        SAMPLED = 'HTTP_X_B3_SAMPLED'
+      end.freeze
+
+      def self.extract(carrier)
+        B3CodecCommon.extract(carrier, Keys)
+      end
+    end
+
+    class B3TextMapCodec
+      class Keys
+        TRACE_ID = 'x-b3-traceid'
+        SPAN_ID = 'x-b3-spanid'
+        PARENT_SPAN_ID = 'x-b3-parentspanid'
+        FLAGS = 'x-b3-flags'
+        SAMPLED = 'x-b3-sampled'
+      end.freeze
+
       def self.extract(carrier)
-        trace_id = TraceId.base16_hex_id_to_uint64(carrier['HTTP_X_B3_TRACEID'])
-        span_id = TraceId.base16_hex_id_to_uint64(carrier['HTTP_X_B3_SPANID'])
-        parent_id = TraceId.base16_hex_id_to_uint64(carrier['HTTP_X_B3_PARENTSPANID'])
-        flags = parse_flags(carrier['HTTP_X_B3_FLAGS'], carrier['HTTP_X_B3_SAMPLED'])
+        B3CodecCommon.extract(carrier, Keys)
+      end
+    end
+
+    class B3CodecCommon
+      def self.extract(carrier, keys)
+        return nil if carrier[keys::TRACE_ID].nil? || carrier[keys::SPAN_ID].nil?
+
+        trace_id = if carrier[keys::TRACE_ID].length <= 16
+                     TraceId.base16_hex_id_to_uint64(carrier[keys::TRACE_ID])
+                   else
+                     TraceId.base16_hex_id_to_uint128(carrier[keys::TRACE_ID])
+                   end
+
+        span_id = TraceId.base16_hex_id_to_uint64(carrier[keys::SPAN_ID])
+        parent_id = TraceId.base16_hex_id_to_uint64(carrier[keys::PARENT_SPAN_ID])
+        flags = parse_flags(carrier[keys::FLAGS], carrier[keys::SAMPLED])
 
-        return nil if span_id.nil? || trace_id.nil?
         return nil if span_id.zero? || trace_id.zero?
 
         SpanContext.new(
@@ -91,6 +127,34 @@ module Jaeger
       private_class_method :parse_flags
     end
 
+    class TraceContextRackCodec
+      # Internal regex used to identify the TraceContext version
+      VERSION_PATTERN = /^([0-9a-fA-F]{2})-(.+)$/.freeze
+
+      # Internal regex used to parse fields in version 0
+      HEADER_V0_PATTERN = /^([0-9a-fA-F]{32})-([0-9a-fA-F]{16})(-([0-9a-fA-F]{2}))?$/.freeze
+
+      def self.extract(carrier)
+        header_value = carrier['HTTP_TRACEPARENT']
+
+        version_match = VERSION_PATTERN.match(header_value)
+        return nil unless version_match
+
+        # We currently only support version 0
+        return nil if version_match[1].to_i(16) != 0
+
+        match = HEADER_V0_PATTERN.match(version_match[2])
+        return nil unless match
+
+        trace_id = TraceId.base16_hex_id_to_uint128(match[1])
+        span_id = TraceId.base16_hex_id_to_uint64(match[2])
+        flags = TraceId.base16_hex_id_to_uint64(match[4])
+        return nil if trace_id.zero? || span_id.zero?
+
+        SpanContext.new(trace_id: trace_id, span_id: span_id, flags: flags)
+      end
+    end
+
     DEFAULT_EXTRACTORS = {
       OpenTracing::FORMAT_TEXT_MAP => JaegerTextMapCodec,
       OpenTracing::FORMAT_BINARY => JaegerBinaryCodec,

data/lib/jaeger/http_sender.rb

@@ -4,7 +4,7 @@ require 'logger'
 
 module Jaeger
   class HttpSender
-    def initialize(url:, headers: {}, encoder:, logger: Logger.new(STDOUT))
+    def initialize(url:, encoder:, headers: {}, logger: Logger.new($stdout))
       @encoder = encoder
       @logger = logger
 
@@ -21,8 +21,8 @@ module Jaeger
       batch = @encoder.encode(spans)
       @transport.write(@serializer.serialize(batch))
       @transport.flush
-    rescue StandardError => error
-      @logger.error("Failure while sending a batch of spans: #{error}")
+    rescue StandardError => e
+      @logger.error("Failure while sending a batch of spans: #{e}")
     end
   end
 end

data/lib/jaeger/injectors.rb

@@ -51,18 +51,32 @@ module Jaeger
       end
     end
 
+    class TraceContextRackCodec
+      def self.inject(span_context, carrier)
+        flags = span_context.sampled? || span_context.debug? ? 1 : 0
+
+        carrier['traceparent'] = format(
+          '%<version>s-%<trace_id>s-%<span_id>s-%<flags>s',
+          version: '00',
+          trace_id: span_context.trace_id.to_s(16).rjust(32, '0'),
+          span_id: span_context.span_id.to_s(16).rjust(16, '0'),
+          flags: flags.to_s(16).rjust(2, '0')
+        )
+      end
+    end
+
     DEFAULT_INJECTORS = {
       OpenTracing::FORMAT_TEXT_MAP => JaegerTextMapCodec,
       OpenTracing::FORMAT_BINARY => JaegerBinaryCodec,
       OpenTracing::FORMAT_RACK => JaegerRackCodec
     }.freeze
 
-    def self.prepare(extractors)
-      DEFAULT_INJECTORS.reduce(extractors) do |acc, (format, default)|
-        provided_extractors = Array(extractors[format])
-        provided_extractors += [default] if provided_extractors.empty?
+    def self.prepare(injectors)
+      DEFAULT_INJECTORS.reduce(injectors) do |acc, (format, default)|
+        provided_injectors = Array(injectors[format])
+        provided_injectors += [default] if provided_injectors.empty?
 
-        acc.merge(format => provided_extractors)
+        acc.merge(format => provided_injectors)
       end
     end
   end

data/lib/jaeger/recurring_executor.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Jaeger
+  # Executes a given block periodically. The block will be executed only once
+  # when interval is set to 0.
+  class RecurringExecutor
+    def initialize(interval:)
+      @interval = interval
+    end
+
+    def start(&block)
+      raise 'Already running' if @thread
+
+      @thread = Thread.new do
+        if @interval <= 0
+          yield
+        else
+          loop do
+            yield
+            sleep @interval
+          end
+        end
+      end
+    end
+
+    def running?
+      @thread&.alive?
+    end
+
+    def stop
+      @thread.kill
+      @thread = nil
+    end
+  end
+end

data/lib/jaeger/samplers/const.rb

@@ -16,7 +16,7 @@ module Jaeger
         }
       end
 
-      def sample?(*)
+      def sample(*)
         [@decision, @tags]
       end
     end

data/lib/jaeger/samplers/guaranteed_throughput_probabilistic.rb

@@ -12,27 +12,34 @@ module Jaeger
     # emitted, ie. if is_sampled() for both samplers return true, the tags
     # for Probabilistic sampler will be used.
     class GuaranteedThroughputProbabilistic
-      attr_reader :tags
+      attr_reader :tags, :probabilistic_sampler, :lower_bound_sampler
 
       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
+          'sampler.param' => rate
         }
       end
 
-      def sample?(*args)
-        is_sampled, probabilistic_tags = @probabilistic_sampler.sample?(*args)
+      def update(lower_bound:, rate:)
+        is_updated = @probabilistic_sampler.update(rate: rate)
+        is_updated = @lower_bound_sampler.update(max_traces_per_second: lower_bound) || is_updated
+        @lower_bound_tags['sampler.param'] = rate
+        is_updated
+      end
+
+      def sample(...)
+        is_sampled, probabilistic_tags = @probabilistic_sampler.sample(...)
         if is_sampled
           # We still call lower_bound_sampler to update the rate limiter budget
-          @lower_bound_sampler.sample?(*args)
+          @lower_bound_sampler.sample(...)
 
           return [is_sampled, probabilistic_tags]
         end
 
-        is_sampled, _tags = @lower_bound_sampler.sample?(*args)
+        is_sampled, _tags = @lower_bound_sampler.sample(...)
         [is_sampled, @lower_bound_tags]
       end
     end

data/lib/jaeger/samplers/per_operation.rb

@@ -10,37 +10,67 @@ module Jaeger
       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
+        @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)
+        if @default_sampler
+          is_updated = @default_sampler.update(rate: @default_sampling_probability)
+        else
+          @default_sampler = Probabilistic.new(rate: @default_sampling_probability)
         end
+
+        update_operation_strategies(strategies) || is_updated
       end
 
-      def sample?(opts)
+      def sample(opts)
         operation_name = opts.fetch(:operation_name)
         sampler = @samplers[operation_name]
-        return sampler.sample?(opts) if sampler
+        return sampler.sample(opts) if sampler
 
-        return @default_sampler.sample?(opts) if @samplers.length >= @max_operations
+        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)
+        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

data/lib/jaeger/samplers/probabilistic.rb

@@ -6,19 +6,33 @@ module Jaeger
     #
     # 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:, **)
+      def sample(opts)
+        trace_id = opts.fetch(:trace_id)
+
         [@boundary >= trace_id, @tags]
       end
     end

data/lib/jaeger/samplers/rate_limiting.rb

@@ -8,24 +8,42 @@ module Jaeger
     # 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
+      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
 
-        @rate_limiter = RateLimiter.new(
-          credits_per_second: max_traces_per_second,
-          max_balance: [max_traces_per_second, 1.0].max
-        )
+        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?(*)
+      def sample(*)
         [@rate_limiter.check_credit(1.0), @tags]
       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/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

@@ -5,3 +5,4 @@ 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

@@ -23,6 +23,7 @@ module Jaeger
     # 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
@@ -30,8 +31,8 @@ module Jaeger
 
       if removed_scope != self # rubocop:disable Style/GuardClause
         raise 'Removed non-active scope, ' \
-          "removed: #{removed_scope.inspect}, "\
-          "expected: #{inspect}"
+              "removed: #{removed_scope.inspect}, "\
+              "expected: #{inspect}"
       end
     end
   end

data/lib/jaeger/scope_manager.rb

@@ -27,6 +27,7 @@ module Jaeger
     #  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

data/lib/jaeger/span.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'span/thrift_tag_builder'
 require_relative 'span/thrift_log_builder'
 
 module Jaeger
@@ -35,7 +34,7 @@ module Jaeger
     # 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 > 0
+        if value.to_i.positive?
           return self if @context.debug?
 
           @context.flags = @context.flags | SpanContext::Flags::SAMPLED | SpanContext::Flags::DEBUG
@@ -72,9 +71,9 @@ module Jaeger
     # Add a log entry to this span
     #
     # @deprecated Use {#log_kv} instead.
-    def log(*args)
+    def log(...)
       warn 'Span#log is deprecated. Please use Span#log_kv instead.'
-      log_kv(*args)
+      log_kv(...)
     end
 
     # Add a log entry to this span

data/lib/jaeger/span_context.rb

@@ -19,10 +19,10 @@ module Jaeger
       )
     end
 
-    attr_reader :span_id, :parent_id, :trace_id, :baggage, :flags
-    attr_writer :flags
+    attr_accessor :flags
+    attr_reader :span_id, :parent_id, :trace_id, :baggage
 
-    def initialize(span_id:, parent_id: 0, trace_id:, flags:, baggage: {})
+    def initialize(span_id:, trace_id:, flags:, parent_id: 0, baggage: {})
       @span_id = span_id
       @parent_id = parent_id
       @trace_id = trace_id