jaeger-client 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46d05119eb9543907c6e1182a80346da57b634623425a4eeb74e06d637b73799
-  data.tar.gz: 171cdd21fd1872db8d1adef226e901dffd595ed7eab76f8c99f902363b638f9d
+  metadata.gz: c9af8a3a945af29ffe9f0045a2eff121fa519c689d04a680a41c7346a198cbf6
+  data.tar.gz: aad37d03df89f03707f91d3fd2f58b0af5b84122736b24f35edff791bb5f0b7a
 SHA512:
-  metadata.gz: 756a18ecf9e931670df3a9058613a5af99a2391eceabfc7c7fdeea5a1371c12757f818fd71e8616d96aa3a544dc0a0cb7728d22b9f4ae7dfb62863f7f37f1c4e
-  data.tar.gz: e89a5e9ff633cca38e030b31cd7a9df68bfa7bcbebfbd5f68ad61a663d04ade3c517465e2b8fcc707afe80696d2aad330ac51caf14a32551788b08322cd4ee4b
+  metadata.gz: 975e4605ee85e4e1b34b763233c16fe6ec3ec0ad88a01f8d1239b523e97bc8fde5844a2ca0d152c71a3b7f601be6237fd70303f31229cb995d896958180aaef7
+  data.tar.gz: 490214bc62f0a922e869b24ccbf5510538fa84365d50aafa1e892fe498aaa79e7bcb7d47da97445db8e07c4ebfb2481ecc6cb6aaeac7f81224e5a1ec90eb4616

data/README.md

@@ -28,18 +28,56 @@ OpenTracing.start_active_span('span name') do
 end
 ```
 
-The tracer can also take an externally configured sender. For example, the `HttpSender` can be configured with a different endpoint and headers for authentication.
+See [opentracing-ruby](https://github.com/opentracing/opentracing-ruby) for more examples.
+
+### Reporters
+
+#### RemoteReporter (default)
+
+RemoteReporter buffers spans in memory and sends them out of process using Sender.
+
+There are two senders: `UdpSender` (default) and `HttpSender`.
+
+To use `HttpSender`:
+
 ```ruby
-require 'jaeger/client'
-require 'jaeger/client/http_sender'
+OpenTracing.global_tracer = Jaeger::Client.build(
+  service_name: 'service_name',
+  reporter: Jaeger::Client::Reporter::RemoteReporter.new(
+    sender: Jaeger::Client::HttpSender.new(
+      url: 'http://localhost:14268/api/traces',
+      headers: { 'key' => 'value' }, # headers key is optional
+      encoder: Jaeger::Client::Encoders::ThriftEncoder.new(service_name: 'service_name')
+    ),
+    flush_interval: 10
+  )
+)
+```
+
+#### NullReporter
 
-headers = { "auth_token" => token }
-encoder = Jaeger::Client::Encoders::ThriftEncoder.new(service_name: "service_name")
-sender = Jaeger::Client::HttpSender.new(url: "http://localhost:14268/api/traces", headers: headers, encoder: encoder)
+NullReporter ignores all spans.
 
-OpenTracing.global_tracer = Jaeger::Client.build(service_name: "service_name", sender: sender)
+```ruby
+OpenTracing.global_tracer = Jaeger::Client.build(
+  service_name: 'service_name',
+  reporter: Jaeger::Client::Reporter::NullReporter.new
+)
 ```
 
+#### LoggingReporter
+
+LoggingReporter prints some details about the span using `logger`. This is meant only for debugging. Do not parse and use this information for anything critical. The implemenation can change at any time.
+
+```ruby
+OpenTracing.global_tracer = Jaeger::Client.build(
+  service_name: 'service_name',
+  reporter: Jaeger::Client::Reporter::LoggingReporter.new
+)
+```
+
+LoggingReporter can also use a custom logger. For this provide logger using `logger` keyword argument.
+
 See [opentracing-ruby](https://github.com/opentracing/opentracing-ruby) for more examples.
 
 ### Samplers
@@ -52,6 +90,37 @@ See [opentracing-ruby](https://github.com/opentracing/opentracing-ruby) for more
 
 `Probabilistic` sampler samples traces with probability equal to `rate` (must be between 0.0 and 1.0). This can be enabled by setting `Jaeger::Client::Samplers::Probabilistic.new(rate: 0.1)`
 
+#### RateLimiting sampler
+
+`RateLimiting` sampler 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.
+
+Set `sampler` to `Jaeger::Client::Samplers::RateLimiting.new(max_traces_per_second: 100)`
+
+#### GuaranteedThroughputProbabilistic sampler
+
+`GuaranteedThroughputProbabilistic` is a sampler that guarantees a throughput by using a Probabilistic sampler and RateLimiting sampler The RateLimiting sampler is used to establish a lower_bound so that every operation is sampled at least once in the time interval defined by the lower_bound.
+
+Set `sampler` to `Jaeger::Client::Samplers::GuaranteedThroughputProbabilistic.new(lower_bound: 10, rate: 0.001)`
+
+#### PerOperation sampler
+
+`PerOperation` sampler 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.
+
+Set `sampler` to
+```
+  Jaeger::Client::Samplers::PerOperation.new(
+    strategies: {
+      per_operation_strategies: [
+        { operation: 'GET /articles', probabilistic_sampling: 0.5 },
+        { operation: 'POST /articles', probabilistic_sampling: 1.0 }
+      ],
+      default_sampling_probability: 0.001,
+      default_lower_bound_traces_per_second: 1.0 / (10.0 * 60.0)
+    },
+    max_operations: 1000
+  )
+```
+
 ### 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.

data/jaeger-client.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
 
   spec.summary       = 'OpenTracing Tracer implementation for Jaeger in Ruby'
   spec.description   = ''
-  spec.homepage      = ''
+  spec.homepage      = 'https://github.com/salemove/jaeger-client-ruby'
   spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0").reject do |f|
@@ -25,6 +25,7 @@ Gem::Specification.new do |spec|
   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_dependency 'opentracing', '~> 0.3'
   spec.add_dependency 'thrift'

data/lib/jaeger/client.rb

@@ -14,12 +14,14 @@ require_relative 'client/scope_manager'
 require_relative 'client/carrier'
 require_relative 'client/trace_id'
 require_relative 'client/udp_sender'
-require_relative 'client/async_reporter'
+require_relative 'client/http_sender'
+require_relative 'client/reporters'
 require_relative 'client/version'
 require_relative 'client/samplers'
 require_relative 'client/encoders/thrift_encoder'
 require_relative 'client/injectors'
 require_relative 'client/extractors'
+require_relative 'client/rate_limiter'
 
 module Jaeger
   module Client
@@ -32,15 +34,20 @@ module Jaeger
                    sampler: Samplers::Const.new(true),
                    logger: Logger.new(STDOUT),
                    sender: nil,
+                   reporter: nil,
                    injectors: {},
                    extractors: {})
       encoder = Encoders::ThriftEncoder.new(service_name: service_name)
 
-      if sender.nil?
-        sender = UdpSender.new(host: host, port: port, encoder: encoder, logger: logger)
+      if sender
+        warn '[DEPRECATION] Passing `sender` directly to Jaeger::Client.build is deprecated.' \
+          'Please use `reporter` instead.'
       end
 
-      reporter = AsyncReporter.create(sender: sender, flush_interval: flush_interval)
+      reporter ||= Reporters::RemoteReporter.new(
+        sender: sender || UdpSender.new(host: host, port: port, encoder: encoder, logger: logger),
+        flush_interval: flush_interval
+      )
 
       Tracer.new(
         reporter: reporter,

data/lib/jaeger/client/extractors.rb

@@ -49,7 +49,7 @@ module Jaeger
             baggage_match = key.match(/\AHTTP_UBERCTX_(\w+)\Z/)
             if baggage_match
               key = baggage_match[1].downcase.tr('_', '-')
-              context.set_baggage_item(key, value)
+              context.set_baggage_item(key, CGI.unescape(value))
             end
           end
 

data/lib/jaeger/client/injectors.rb

@@ -26,7 +26,7 @@ module Jaeger
           carrier['uber-trace-id'] =
             CGI.escape(Injectors.context_as_jaeger_string(span_context))
           span_context.baggage.each do |key, value|
-            carrier["uberctx-#{key}"] = value
+            carrier["uberctx-#{key}"] = CGI.escape(value)
           end
         end
       end

data/lib/jaeger/client/rate_limiter.rb

@@ -0,0 +1,63 @@
+# 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.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative 'reporters/composite_reporter'
+require_relative 'reporters/in_memory_reporter'
+require_relative 'reporters/logging_reporter'
+require_relative 'reporters/null_reporter'
+require_relative 'reporters/remote_reporter'

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

@@ -0,0 +1,19 @@
+# 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/{async_reporter/buffer.rb → reporters/in_memory_reporter.rb}

@@ -2,25 +2,28 @@
 
 module Jaeger
   module Client
-    class AsyncReporter
-      class Buffer
+    module Reporters
+      class InMemoryReporter
         def initialize
-          @buffer = []
+          @spans = []
           @mutex = Mutex.new
         end
 
-        def <<(element)
+        def report(span)
           @mutex.synchronize do
-            @buffer << element
-            true
+            @spans << span
           end
         end
 
-        def retrieve
+        def spans
           @mutex.synchronize do
-            elements = @buffer.dup
-            @buffer.clear
-            elements
+            @spans
+          end
+        end
+
+        def clear
+          @mutex.synchronize do
+            @spans.clear
           end
         end
       end

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

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

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

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

@@ -0,0 +1,31 @@
+# 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.rb

@@ -1,4 +1,7 @@
 # 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'

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

@@ -11,18 +11,15 @@ module Jaeger
       class Const
         def initialize(decision)
           @decision = decision
-          @param = decision ? '1' : '0'
+          @tags = {
+            'sampler.type' => 'const',
+            'sampler.param' => @decision ? 1 : 0
+          }
         end
 
         def sample?(*)
-          @decision
+          [@decision, @tags]
         end
-
-        def type
-          'const'
-        end
-
-        attr_reader :param
       end
     end
   end

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

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

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

@@ -8,22 +8,20 @@ module Jaeger
       # Sample a portion of traces using trace_id as the random decision
       class Probabilistic
         def initialize(rate: 0.001)
-          @param = rate.to_s
           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
-        end
 
-        def sample?(trace_id)
-          @boundary >= trace_id
+          @boundary = TraceId::TRACE_ID_UPPER_BOUND * rate
+          @tags = {
+            'sampler.type' => 'probabilistic',
+            'sampler.param' => rate
+          }
         end
 
-        def type
-          'probabilistic'
+        def sample?(trace_id:, **)
+          [@boundary >= trace_id, @tags]
         end
-
-        attr_reader :param
       end
     end
   end

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

@@ -0,0 +1,35 @@
+# 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/span_context.rb

@@ -10,13 +10,6 @@ module Jaeger
         DEBUG = 0x02
       end
 
-      def self.create_parent_context(sampler = Samplers::Const.new(true))
-        trace_id = TraceId.generate
-        span_id = TraceId.generate
-        flags = sampler.sample?(trace_id) ? Flags::SAMPLED : Flags::NONE
-        new(trace_id: trace_id, span_id: span_id, flags: flags)
-      end
-
       def self.create_from_parent_context(span_context)
         new(
           trace_id: span_context.trace_id,

data/lib/jaeger/client/tracer.rb

@@ -50,7 +50,8 @@ module Jaeger
                      tags: {},
                      ignore_active_scope: false,
                      **)
-        context = prepare_span_context(
+        context, sampler_tags = prepare_span_context(
+          operation_name: operation_name,
           child_of: child_of,
           references: references,
           ignore_active_scope: ignore_active_scope
@@ -61,10 +62,7 @@ module Jaeger
           @reporter,
           start_time: start_time,
           references: references,
-          tags: tags.merge(
-            :'sampler.type' => @sampler.type,
-            :'sampler.param' => @sampler.param
-          )
+          tags: tags.merge(sampler_tags)
         )
       end
 
@@ -150,16 +148,26 @@ module Jaeger
 
       private
 
-      def prepare_span_context(child_of:, references:, ignore_active_scope:)
+      def prepare_span_context(operation_name:, child_of:, references:, ignore_active_scope:)
         context =
           context_from_child_of(child_of) ||
           context_from_references(references) ||
           context_from_active_scope(ignore_active_scope)
 
         if context
-          SpanContext.create_from_parent_context(context)
+          [SpanContext.create_from_parent_context(context), {}]
         else
-          SpanContext.create_parent_context(@sampler)
+          trace_id = TraceId.generate
+          is_sampled, tags = @sampler.sample?(
+            trace_id: trace_id,
+            operation_name: operation_name
+          )
+          span_context = SpanContext.new(
+            trace_id: trace_id,
+            span_id: trace_id,
+            flags: is_sampled ? SpanContext::Flags::SAMPLED : SpanContext::Flags::NONE
+          )
+          [span_context, tags]
         end
       end
 

data/lib/jaeger/client/version.rb

@@ -2,6 +2,6 @@
 
 module Jaeger
   module Client
-    VERSION = '0.8.0'.freeze
+    VERSION = '0.9.0'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jaeger-client
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - SaleMove TechMovers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-21 00:00:00.000000000 Z
+date: 2018-12-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.24.0
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
 - !ruby/object:Gem::Dependency
   name: opentracing
   requirement: !ruby/object:Gem::Requirement
@@ -136,16 +150,25 @@ files:
 - crossdock/server
 - jaeger-client.gemspec
 - lib/jaeger/client.rb
-- lib/jaeger/client/async_reporter.rb
-- lib/jaeger/client/async_reporter/buffer.rb
 - lib/jaeger/client/carrier.rb
 - lib/jaeger/client/encoders/thrift_encoder.rb
 - lib/jaeger/client/extractors.rb
 - lib/jaeger/client/http_sender.rb
 - lib/jaeger/client/injectors.rb
+- lib/jaeger/client/rate_limiter.rb
+- lib/jaeger/client/reporters.rb
+- lib/jaeger/client/reporters/composite_reporter.rb
+- lib/jaeger/client/reporters/in_memory_reporter.rb
+- lib/jaeger/client/reporters/logging_reporter.rb
+- lib/jaeger/client/reporters/null_reporter.rb
+- lib/jaeger/client/reporters/remote_reporter.rb
+- lib/jaeger/client/reporters/remote_reporter/buffer.rb
 - lib/jaeger/client/samplers.rb
 - lib/jaeger/client/samplers/const.rb
+- lib/jaeger/client/samplers/guaranteed_throughput_probabilistic.rb
+- lib/jaeger/client/samplers/per_operation.rb
 - lib/jaeger/client/samplers/probabilistic.rb
+- lib/jaeger/client/samplers/rate_limiting.rb
 - lib/jaeger/client/scope.rb
 - lib/jaeger/client/scope_manager.rb
 - lib/jaeger/client/scope_manager/scope_identifier.rb
@@ -176,7 +199,7 @@ files:
 - thrift/gen-rb/jaeger/thrift/zipkin/zipkincore_types.rb
 - thrift/jaeger.thrift
 - thrift/zipkincore.thrift
-homepage: ''
+homepage: https://github.com/salemove/jaeger-client-ruby
 licenses:
 - MIT
 metadata: {}

data/lib/jaeger/client/async_reporter.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require 'thread'
-
-require_relative './async_reporter/buffer'
-
-module Jaeger
-  module Client
-    class AsyncReporter
-      def self.create(sender:, flush_interval:)
-        new(sender, flush_interval)
-      end
-
-      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