jaeger-client 0.10.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7de16fd42664a20ad343e3fdc701f057b93df9e9c8ac6e76d4ea6b36895a7733
-  data.tar.gz: 32421b715a39b2710cae5bf9f7c6ca075872717ac53964de98429f063ebc93ba
+  metadata.gz: 8f4b7e773d00ccb0b54390db7b973e674733017ed4c1253bab10931ffdc6358f
+  data.tar.gz: b03393cae166cc9a189f3629cfa2a6eb5eb06fe975e2225aa3c2cc1ffb6ebe36
 SHA512:
-  metadata.gz: dacf1771b57e8f12074a0426b75b09b6a19610c13d4cb86b687e9930fc24a7e4a20f5c5e2819760e02a88baf01a8438f2175688be57dff2dffd80e5d45303522
-  data.tar.gz: b8bdaa192c6c2109b7711431ec9eebe3e4352e5e71426c65355abd5aad358cf0f4ceaaecb25dec2cf3a622d0982294ea578858234c71682a841f7bb3bb4090c0
+  metadata.gz: 2fa33017d53652e38133d4dab7d134b0d7ff1ee262e07a70b9c9114d80831eaad2f88df16b467ebe7c167c80798e34c39a70b33472d1cf204314d922a43b98d1
+  data.tar.gz: 3a7b325ee92c532bf2b1c50c40fd483cf42458d51e9148f63dc98f0c56513e3d0dc3c2a36ec04f07c8953cff91e162b430d1ebb0d9ccc50f51796db9dea3c62d

data/.rubocop.yml

@@ -48,3 +48,6 @@ Style/FrozenStringLiteralComment:
 
 Metrics/LineLength:
   Max: 120
+
+Style/SingleLineMethods:
+  Enabled: false

data/README.md

@@ -109,8 +109,8 @@ Set `sampler` to
   Jaeger::Samplers::PerOperation.new(
     strategies: {
       per_operation_strategies: [
-        { operation: 'GET /articles', probabilistic_sampling: 0.5 },
-        { operation: 'POST /articles', probabilistic_sampling: 1.0 }
+        { operation: 'GET /articles', probabilistic_sampling: { sampling_rate: 0.5 } },
+        { operation: 'POST /articles', probabilistic_sampling: { sampling_rate: 1.0 } }
       ],
       default_sampling_probability: 0.001,
       default_lower_bound_traces_per_second: 1.0 / (10.0 * 60.0)
@@ -119,6 +119,39 @@ Set `sampler` to
   )
 ```
 
+#### RemoteControlled sampler
+
+`RemoteControlled` sampler is a sampler that is controller by jaeger agent. It starts out with `Probabilistic` sampler. It polls the jaeger-agent and changes sampling strategy accordingly. Set `sampler` to `Jaeger::Client::Samplers::RemoteControlled.new(service_name: 'service_name')`.
+
+RemoteControlled sampler options:
+
+| Param             | Required | Description |
+|-------------------|----------|-------------|
+| service_name      | x | name of the current service / application, same as given to Tracer |
+| sampler           |   | initial sampler to use prior to retrieving strategies from Agent |
+| refresh_interval  |   | interval in seconds before sampling strategy refreshes (0 to not refresh, defaults to 60) |
+| host              |   | host for jaeger-agent (defaults to 'localhost') |
+| port              |   | port for jaeger-agent for SamplingManager endpoint (defaults to 5778) |
+| logger            |   | logger for communication between jaeger-agent (default to $stdout logger) |
+
+### TraceContext compatible header propagation
+
+It is possible to use [W3C Trace Context](https://www.w3.org/TR/trace-context/#overview) headers to propagate the tracing information.
+
+To set it up you need to change FORMAT_RACK injector and extractor.
+
+```ruby
+OpenTracing.global_tracer = Jaeger::Client.build(
+  service_name: 'service_name',
+  injectors: {
+    OpenTracing::FORMAT_RACK => [Jaeger::Injectors::TraceContextRackCodec]
+  },
+  extractors: {
+    OpenTracing::FORMAT_RACK => [Jaeger::Extractors::TraceContextRackCodec]
+  }
+)
+```
+
 ### Zipkin HTTP B3 compatible header propagation
 
 Jaeger Tracer supports Zipkin B3 Propagation HTTP headers, which are used by a lot of Zipkin tracers. This means that you can use Jaeger in conjunction with OpenZipkin tracers.
@@ -141,6 +174,20 @@ It's also possible to set up multiple injectors and extractors. Each injector wi
 
 If multiple extractors is used then the span context from the first match will be returned.
 
+### Process Tags
+
+Jaeger Tracer allows you to define process level tags. By default the tracer provides `jaeger.version`, `ip` and `hostname`. You may want to overwrite `ip` or `hostname` if the tracer cannot auto-detect them.
+
+```ruby
+OpenTracing.global_tracer = Jaeger::Client.build(
+  service_name: 'service_name',
+  tags: {
+    'hostname' => 'custom-hostname',
+    'custom_tag' => 'custom-tag-value'
+  }
+)
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/jaeger-client.gemspec

@@ -20,12 +20,13 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.add_development_dependency 'bundler', '~> 1.14'
+  spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
   spec.add_development_dependency 'rubocop', '~> 0.54.0'
   spec.add_development_dependency 'rubocop-rspec', '~> 1.24.0'
   spec.add_development_dependency 'timecop', '~> 0.9'
+  spec.add_development_dependency 'webmock', '~> 3.4.2'
 
   spec.add_dependency 'opentracing', '~> 0.3'
   spec.add_dependency 'thrift'

data/lib/jaeger/client.rb

@@ -5,6 +5,10 @@ $LOAD_PATH.push(File.dirname(__FILE__) + '/../../thrift/gen-rb')
 require 'opentracing'
 require 'jaeger/thrift/agent'
 require 'logger'
+require 'time'
+require 'net/http'
+require 'cgi'
+require 'json'
 
 require_relative 'tracer'
 require_relative 'span'
@@ -21,6 +25,8 @@ require_relative 'encoders/thrift_encoder'
 require_relative 'injectors'
 require_relative 'extractors'
 require_relative 'rate_limiter'
+require_relative 'thrift_tag_builder'
+require_relative 'recurring_executor'
 
 module Jaeger
   module Client
@@ -46,8 +52,9 @@ module Jaeger
                    sender: nil,
                    reporter: nil,
                    injectors: {},
-                   extractors: {})
-      encoder = Encoders::ThriftEncoder.new(service_name: service_name)
+                   extractors: {},
+                   tags: {})
+      encoder = Encoders::ThriftEncoder.new(service_name: service_name, tags: tags)
 
       if sender
         warn '[DEPRECATION] Passing `sender` directly to Jaeger::Client.build is deprecated.' \

data/lib/jaeger/client/version.rb

@@ -2,6 +2,6 @@
 
 module Jaeger
   module Client
-    VERSION = '0.10.0'.freeze
+    VERSION = '1.0.0'.freeze
   end
 end

data/lib/jaeger/encoders/thrift_encoder.rb

@@ -3,49 +3,46 @@
 module Jaeger
   module Encoders
     class ThriftEncoder
-      def initialize(service_name:)
+      def initialize(service_name:, tags: {})
         @service_name = service_name
-        @tags = [
-          Jaeger::Thrift::Tag.new(
-            'key' => 'jaeger.version',
-            'vType' => Jaeger::Thrift::TagType::STRING,
-            'vStr' => 'Ruby-' + Jaeger::Client::VERSION
-          ),
-          Jaeger::Thrift::Tag.new(
-            'key' => 'hostname',
-            'vType' => Jaeger::Thrift::TagType::STRING,
-            'vStr' => Socket.gethostname
-          )
-        ]
-        ipv4 = Socket.ip_address_list.find { |ai| ai.ipv4? && !ai.ipv4_loopback? }
-        unless ipv4.nil? # rubocop:disable Style/GuardClause
-          @tags << Jaeger::Thrift::Tag.new(
-            'key' => 'ip',
-            'vType' => Jaeger::Thrift::TagType::STRING,
-            'vStr' => ipv4.ip_address
-          )
-        end
+        @tags = prepare_tags(tags)
+        @process = Jaeger::Thrift::Process.new('serviceName' => @service_name, 'tags' => @tags)
       end
 
       def encode(spans)
-        Jaeger::Thrift::Batch.new(
-          'process' => Jaeger::Thrift::Process.new(
-            'serviceName' => @service_name,
-            'tags' => @tags
-          ),
-          'spans' => spans.map(&method(:encode_span))
-        )
+        encode_batch(spans.map(&method(:encode_span)))
+      end
+
+      def encode_limited_size(spans, protocol_class, max_message_length)
+        batches = []
+        current_batch = []
+        transport.flush
+        spans.each do |span|
+          encoded_span = encode_span(span)
+          if aggregated_span_size(encoded_span, protocol_class) > max_message_length && !current_batch.empty?
+            batches << encode_batch(current_batch)
+            current_batch = []
+            transport.flush
+          end
+          current_batch << encoded_span
+        end
+        batches << encode_batch(current_batch) unless current_batch.empty?
+        batches
       end
 
       private
 
+      def encode_batch(encoded_spans)
+        Jaeger::Thrift::Batch.new('process' => @process, 'spans' => encoded_spans)
+      end
+
       def encode_span(span)
         context = span.context
         start_ts, duration = build_timestamps(span)
 
         Jaeger::Thrift::Span.new(
-          'traceIdLow' => TraceId.uint64_id_to_int64(context.trace_id),
-          'traceIdHigh' => 0,
+          'traceIdLow' => TraceId.uint64_id_to_int64(trace_id_to_low(context.trace_id)),
+          'traceIdHigh' => TraceId.uint64_id_to_int64(trace_id_to_high(context.trace_id)),
           'spanId' => TraceId.uint64_id_to_int64(context.span_id),
           'parentSpanId' => TraceId.uint64_id_to_int64(context.parent_id),
           'operationName' => span.operation_name,
@@ -87,6 +84,59 @@ module Jaeger
           nil
         end
       end
+
+      def prepare_tags(tags)
+        with_default_tags = tags.dup
+        with_default_tags['jaeger.version'] = 'Ruby-' + Jaeger::Client::VERSION
+        with_default_tags['hostname'] ||= Socket.gethostname
+
+        unless with_default_tags['ip']
+          ipv4 = Socket.ip_address_list.find { |ai| ai.ipv4? && !ai.ipv4_loopback? }
+          with_default_tags['ip'] = ipv4.ip_address unless ipv4.nil?
+        end
+
+        with_default_tags.map do |key, value|
+          ThriftTagBuilder.build(key, value)
+        end
+      end
+
+      # Returns the right most 64 bits of trace id
+      def trace_id_to_low(trace_id)
+        trace_id & TraceId::MAX_64BIT_UNSIGNED_INT
+      end
+
+      # Returns the left most 64 bits of trace id
+      def trace_id_to_high(trace_id)
+        (trace_id >> 64) & TraceId::MAX_64BIT_UNSIGNED_INT
+      end
+
+      class DummyTransport
+        attr_accessor :size
+
+        def initialize
+          @size = 0
+        end
+
+        def write(buf)
+          @size += buf.size
+        end
+
+        def flush
+          @size = 0
+        end
+
+        def close; end
+      end
+
+      def aggregated_span_size(span, protocol_class)
+        @protocol ||= protocol_class.new(transport)
+        span.write(@protocol)
+        transport.size
+      end
+
+      def transport
+        @transport ||= DummyTransport.new
+      end
     end
   end
 end

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,11 +65,39 @@ module Jaeger
     end
 
     class B3RackCodec
+      class Keys
+        TRACE_ID = 'HTTP_X_B3_TRACEID'.freeze
+        SPAN_ID = 'HTTP_X_B3_SPANID'.freeze
+        PARENT_SPAN_ID = 'HTTP_X_B3_PARENTSPANID'.freeze
+        FLAGS = 'HTTP_X_B3_FLAGS'.freeze
+        SAMPLED = 'HTTP_X_B3_SAMPLED'.freeze
+      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 B3TextMapCodec
+      class Keys
+        TRACE_ID = 'x-b3-traceid'.freeze
+        SPAN_ID = 'x-b3-spanid'.freeze
+        PARENT_SPAN_ID = 'x-b3-parentspanid'.freeze
+        FLAGS = 'x-b3-flags'.freeze
+        SAMPLED = 'x-b3-sampled'.freeze
+      end.freeze
+
+      def self.extract(carrier)
+        B3CodecCommon.extract(carrier, Keys)
+      end
+    end
+
+    class B3CodecCommon
+      def self.extract(carrier, keys)
+        trace_id = TraceId.base16_hex_id_to_uint64(carrier[keys::TRACE_ID])
+        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?
@@ -91,6 +121,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})-(.+)$/
+
+      # 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}))?$/
+
+      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/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 && @thread.alive?
+    end
+
+    def stop
+      @thread.kill
+      @thread = nil
+    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/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(*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)
+          @lower_bound_sampler.sample(*args)
 
           return [is_sampled, probabilistic_tags]
         end
 
-        is_sampled, _tags = @lower_bound_sampler.sample?(*args)
+        is_sampled, _tags = @lower_bound_sampler.sample(*args)
         [is_sampled, @lower_bound_tags]
       end
     end

data/lib/jaeger/samplers/per_operation.rb

@@ -10,37 +10,69 @@ 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
+
+        is_updated = update_operation_strategies(strategies) || is_updated
+
+        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,31 @@ 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(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.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/span.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'span/thrift_tag_builder'
 require_relative 'span/thrift_log_builder'
 
 module Jaeger

data/lib/jaeger/thrift_tag_builder.rb

@@ -0,0 +1,41 @@
+# 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)
+      if value.is_a?(Integer)
+        Jaeger::Thrift::Tag.new(
+          KEY => key.to_s,
+          VTYPE => Jaeger::Thrift::TagType::LONG,
+          VLONG => value
+        )
+      elsif value.is_a?(Float)
+        Jaeger::Thrift::Tag.new(
+          KEY => key.to_s,
+          VTYPE => Jaeger::Thrift::TagType::DOUBLE,
+          VDOUBLE => value
+        )
+      elsif value.is_a?(TrueClass) || value.is_a?(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

@@ -4,6 +4,7 @@ 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
@@ -12,10 +13,18 @@ module Jaeger
 
     def self.base16_hex_id_to_uint64(id)
       return nil unless id
+
       value = id.to_i(16)
       value > MAX_64BIT_UNSIGNED_INT || value < 0 ? 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 < 0 ? 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)

data/lib/jaeger/tracer.rb

@@ -41,7 +41,13 @@ module Jaeger
     # @param ignore_active_scope [Boolean] whether to create an implicit
     #   References#CHILD_OF reference to the ScopeManager#active.
     #
-    # @return [Span] The newly-started Span
+    # @yield [Span] If passed an optional block, start_span will yield the
+    #   newly-created span to the block. The span will be finished automatically
+    #   after the block is executed.
+    # @return [Span, Object] If passed an optional block, start_span will return
+    #  the block's return value, otherwise it returns the newly-started Span
+    #  instance, which has not been automatically registered via the
+    #  ScopeManager
     def start_span(operation_name,
                    child_of: nil,
                    references: nil,
@@ -55,7 +61,7 @@ module Jaeger
         references: references,
         ignore_active_scope: ignore_active_scope
       )
-      Span.new(
+      span = Span.new(
         context,
         operation_name,
         @reporter,
@@ -63,6 +69,16 @@ module Jaeger
         references: references,
         tags: tags.merge(sampler_tags)
       )
+
+      if block_given?
+        begin
+          yield(span)
+        ensure
+          span.finish
+        end
+      else
+        span
+      end
     end
 
     # Creates a newly started and activated Scope
@@ -87,10 +103,12 @@ module Jaeger
     #   References#CHILD_OF reference to the ScopeManager#active.
     # @param finish_on_close [Boolean] whether span should automatically be
     #   finished when Scope#close is called
-    # @yield [Scope] If an optional block is passed to start_active it will
-    #   yield the newly-started Scope. If `finish_on_close` is true then the
+    # @yield [Scope] If an optional block is passed to start_active_span it
+    #   will yield the newly-started Scope. If `finish_on_close` is true then the
     #   Span will be finished automatically after the block is executed.
-    # @return [Scope] The newly-started and activated Scope
+    # @return [Scope, Object] If passed an optional block, start_active_span
+    #   returns the block's return value, otherwise it returns the newly-started
+    #   and activated Scope
     def start_active_span(operation_name,
                           child_of: nil,
                           references: nil,
@@ -115,9 +133,9 @@ module Jaeger
         ensure
           scope.close
         end
+      else
+        scope
       end
-
-      scope
     end
 
     # Inject a SpanContext into the given carrier
@@ -157,7 +175,7 @@ module Jaeger
         [SpanContext.create_from_parent_context(context), {}]
       else
         trace_id = TraceId.generate
-        is_sampled, tags = @sampler.sample?(
+        is_sampled, tags = @sampler.sample(
           trace_id: trace_id,
           operation_name: operation_name
         )

data/lib/jaeger/udp_sender.rb

@@ -5,18 +5,20 @@ require 'socket'
 
 module Jaeger
   class UdpSender
-    def initialize(host:, port:, encoder:, logger:)
+    def initialize(host:, port:, encoder:, logger:, max_packet_size: 65_000)
       @encoder = encoder
       @logger = logger
 
       transport = Transport.new(host, port)
-      protocol = ::Thrift::CompactProtocol.new(transport)
+      @protocol_class = ::Thrift::CompactProtocol
+      protocol = @protocol_class.new(transport)
       @client = Jaeger::Thrift::Agent::Client.new(protocol)
+      @max_packet_size = max_packet_size
     end
 
     def send_spans(spans)
-      batch = @encoder.encode(spans)
-      @client.emitBatch(batch)
+      batches = @encoder.encode_limited_size(spans, @protocol_class, @max_packet_size)
+      batches.each { |batch| @client.emitBatch(batch) }
     rescue StandardError => error
       @logger.error("Failure while sending a batch of spans: #{error}")
     end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: jaeger-client
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 1.0.0
 platform: ruby
 authors:
 - SaleMove TechMovers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-25 00:00:00.000000000 Z
+date: 2019-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.14'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.14'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -94,6 +94,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.4.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.4.2
 - !ruby/object:Gem::Dependency
   name: opentracing
   requirement: !ruby/object:Gem::Requirement
@@ -156,6 +170,7 @@ files:
 - lib/jaeger/http_sender.rb
 - lib/jaeger/injectors.rb
 - lib/jaeger/rate_limiter.rb
+- lib/jaeger/recurring_executor.rb
 - lib/jaeger/reporters.rb
 - lib/jaeger/reporters/composite_reporter.rb
 - lib/jaeger/reporters/in_memory_reporter.rb
@@ -169,14 +184,16 @@ files:
 - lib/jaeger/samplers/per_operation.rb
 - lib/jaeger/samplers/probabilistic.rb
 - lib/jaeger/samplers/rate_limiting.rb
+- lib/jaeger/samplers/remote_controlled.rb
+- lib/jaeger/samplers/remote_controlled/instructions_fetcher.rb
 - lib/jaeger/scope.rb
 - lib/jaeger/scope_manager.rb
 - lib/jaeger/scope_manager/scope_identifier.rb
 - lib/jaeger/scope_manager/scope_stack.rb
 - lib/jaeger/span.rb
 - lib/jaeger/span/thrift_log_builder.rb
-- lib/jaeger/span/thrift_tag_builder.rb
 - lib/jaeger/span_context.rb
+- lib/jaeger/thrift_tag_builder.rb
 - lib/jaeger/trace_id.rb
 - lib/jaeger/tracer.rb
 - lib/jaeger/udp_sender.rb
@@ -217,8 +234,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: OpenTracing Tracer implementation for Jaeger in Ruby

data/lib/jaeger/span/thrift_tag_builder.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module Jaeger
-  class Span
-    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)
-        if value.is_a?(Integer)
-          Jaeger::Thrift::Tag.new(
-            KEY => key.to_s,
-            VTYPE => Jaeger::Thrift::TagType::LONG,
-            VLONG => value
-          )
-        elsif value.is_a?(Float)
-          Jaeger::Thrift::Tag.new(
-            KEY => key.to_s,
-            VTYPE => Jaeger::Thrift::TagType::DOUBLE,
-            VDOUBLE => value
-          )
-        elsif value.is_a?(TrueClass) || value.is_a?(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
-end