jaeger-client 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 569f7aab000d228eac45be1f7d5831251b886ea0372c83f26d6eee58cb4aebbc
-  data.tar.gz: ce36d49763c06f2fbad18d69587c1c66c9f047bcdc24bcbdb7c1b7bc99fdb803
+  metadata.gz: 8f0b04e0c6c305df9d1f5ec5c0b76ad40c60a5e8b27c5475b29e414ade9ef59b
+  data.tar.gz: 672aa006cb7ad30269615cda53b05eed141205689d37b472b0acdc91b257d074
 SHA512:
-  metadata.gz: 7c1e3bf462504c1f0b83dfe460d3001dcb45fb8dece53245f6b9d25a3065332f6a16bba3a425ffe34d74bef5ab0d67d5cd7caaafc36d9b930eab067040c88dbf
-  data.tar.gz: 0f9c0a1c60ccb748c3f50a63e01f28d2756f8485f35b4aa111544e596f19685f2200f0446962c56b17d2273c976f638ec7c00764fccd88fbbb73c5814dd8cee8
+  metadata.gz: 188e7434f62b4023b9a4d03ec1c18589c6d9b3a79810a2a000b6ef987b8532d1e5ec9f7d0e21ba2383b197b3f1bd6064c602839e49d185b3241365a664a7a5f2
+  data.tar.gz: 6335ba661fbfbd92ee543ba30d794fe9cffa4a7b30c36e300a63f48331bbcc81b33a5f2585ebe266f51faefddd3600d481f9a0326b6c5740e0fe95bf34b01cf5

data/.rubocop.yml

@@ -19,6 +19,9 @@ RSpec/ExampleLength:
 RSpec/MultipleExpectations:
   Enabled: no
 
+RSpec/MessageSpies:
+  Enabled: no
+
 Metrics/BlockLength:
   Enabled: no
 

data/README.md

@@ -28,6 +28,18 @@ 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.
+```ruby
+require 'jaeger/client'
+require 'jaeger/client/http_sender'
+
+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)
+
+OpenTracing.global_tracer = Jaeger::Client.build(service_name: "service_name", sender: sender)
+```
+
 See [opentracing-ruby](https://github.com/opentracing/opentracing-ruby) for more examples.
 
 ### Samplers
@@ -40,6 +52,28 @@ 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)`
 
+### 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.
+
+To set it up you need to change FORMAT_RACK injector and extractor.
+
+```
+OpenTracing.global_tracer = Jaeger::Client.build(
+  service_name: 'service_name',
+  injectors: {
+    OpenTracing::FORMAT_RACK => [Jaeger::Client::Injectors::B3RackCodec]
+  },
+  extractors: {
+    OpenTracing::FORMAT_RACK => [Jaeger::Client::Extractors::B3RackCodec]
+  }
+)
+```
+
+It's also possible to set up multiple injectors and extractors. Each injector will be called in sequence. Note that if multiple injectors are using the same keys then the values will be overwritten.
+
+If multiple extractors is used then the span context from the first match will be returned.
+
 ## 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/lib/jaeger/client.rb

@@ -14,9 +14,12 @@ require_relative 'client/scope_manager'
 require_relative 'client/carrier'
 require_relative 'client/trace_id'
 require_relative 'client/udp_sender'
-require_relative 'client/collector'
+require_relative 'client/async_reporter'
 require_relative 'client/version'
 require_relative 'client/samplers'
+require_relative 'client/encoders/thrift_encoder'
+require_relative 'client/injectors'
+require_relative 'client/extractors'
 
 module Jaeger
   module Client
@@ -27,18 +30,24 @@ module Jaeger
                    service_name:,
                    flush_interval: DEFAULT_FLUSH_INTERVAL,
                    sampler: Samplers::Const.new(true),
-                   logger: Logger.new(STDOUT))
-      collector = Collector.new
-      sender = UdpSender.new(
-        service_name: service_name,
-        host: host,
-        port: port,
-        collector: collector,
-        flush_interval: flush_interval,
-        logger: logger
+                   logger: Logger.new(STDOUT),
+                   sender: 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)
+      end
+
+      reporter = AsyncReporter.create(sender: sender, flush_interval: flush_interval)
+
+      Tracer.new(
+        reporter: reporter,
+        sampler: sampler,
+        injectors: Injectors.prepare(injectors),
+        extractors: Extractors.prepare(extractors)
       )
-      sender.start
-      Tracer.new(collector, sender, sampler)
     end
   end
 end

data/lib/jaeger/client/async_reporter.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'thread'
+
+require_relative './async_reporter/buffer'
+
+module Jaeger
+  module Client
+    class AsyncReporter
+      def self.create(sender:, flush_interval:)
+        reporter = new(sender)
+
+        # start flush thread
+        Thread.new do
+          loop do
+            reporter.flush
+            sleep(flush_interval)
+          end
+        end
+
+        reporter
+      end
+
+      def initialize(sender)
+        @sender = sender
+        @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?
+        @buffer << span
+      end
+    end
+  end
+end

data/lib/jaeger/client/async_reporter/buffer.rb

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

data/lib/jaeger/client/encoders/thrift_encoder.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Jaeger
+  module Client
+    module Encoders
+      class ThriftEncoder
+        def initialize(service_name:)
+          @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
+        end
+
+        def encode(spans)
+          Jaeger::Thrift::Batch.new(
+            'process' => Jaeger::Thrift::Process.new(
+              'serviceName' => @service_name,
+              'tags' => @tags
+            ),
+            'spans' => spans.map(&method(:encode_span))
+          )
+        end
+
+        private
+
+        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,
+            'spanId' => TraceId.uint64_id_to_int64(context.span_id),
+            'parentSpanId' => TraceId.uint64_id_to_int64(context.parent_id),
+            'operationName' => span.operation_name,
+            'references' => build_references(span.references || []),
+            'flags' => context.flags,
+            'startTime' => start_ts,
+            'duration' => duration,
+            'tags' => span.tags,
+            'logs' => span.logs
+          )
+        end
+
+        def build_references(references)
+          references.map do |ref|
+            Jaeger::Thrift::SpanRef.new(
+              'refType' => span_ref_type(ref.type),
+              'traceIdLow' => ref.context.trace_id,
+              'traceIdHigh' => 0,
+              'spanId' => ref.context.span_id
+            )
+          end
+        end
+
+        def build_timestamps(span)
+          start_ts = (span.start_time.to_f * 1_000_000).to_i
+          end_ts = (span.end_time.to_f * 1_000_000).to_i
+          duration = end_ts - start_ts
+          [start_ts, duration]
+        end
+
+        def span_ref_type(type)
+          case type
+          when OpenTracing::Reference::CHILD_OF
+            Jaeger::Thrift::SpanRefType::CHILD_OF
+          when OpenTracing::Reference::FOLLOWS_FROM
+            Jaeger::Thrift::SpanRefType::FOLLOWS_FROM
+          else
+            warn "Jaeger::Client with format #{type} is not supported yet"
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jaeger/client/extractors.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Jaeger
+  module Client
+    module Extractors
+      class SerializedJaegerTrace
+        def self.parse(trace)
+          return nil if !trace || trace == ''
+
+          trace_arguments = trace.split(':').map(&TraceId.method(:base16_hex_id_to_uint64))
+          return nil if trace_arguments.size != 4
+
+          trace_id, span_id, parent_id, flags = trace_arguments
+          return nil if trace_id.zero? || span_id.zero?
+
+          SpanContext.new(
+            trace_id: trace_id,
+            parent_id: parent_id,
+            span_id: span_id,
+            flags: flags
+          )
+        end
+      end
+
+      class JaegerTextMapCodec
+        def self.extract(carrier)
+          SerializedJaegerTrace.parse(carrier['uber-trace-id'])
+        end
+      end
+
+      class JaegerRackCodec
+        def self.extract(carrier)
+          SerializedJaegerTrace.parse(carrier['HTTP_UBER_TRACE_ID'])
+        end
+      end
+
+      class JaegerBinaryCodec
+        def self.extract(_carrier)
+          warn 'Jaeger::Client with binary format is not supported yet'
+        end
+      end
+
+      class B3RackCodec
+        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'])
+
+          return nil if span_id.nil? || trace_id.nil?
+          return nil if span_id.zero? || trace_id.zero?
+
+          SpanContext.new(
+            trace_id: trace_id,
+            parent_id: parent_id,
+            span_id: span_id,
+            flags: flags
+          )
+        end
+
+        # if the flags header is '1' then the sampled header should not be present
+        def self.parse_flags(flags_header, sampled_header)
+          if flags_header == '1'
+            Jaeger::Client::SpanContext::Flags::DEBUG
+          else
+            TraceId.base16_hex_id_to_uint64(sampled_header)
+          end
+        end
+        private_class_method :parse_flags
+      end
+
+      DEFAULT_EXTRACTORS = {
+        OpenTracing::FORMAT_TEXT_MAP => JaegerTextMapCodec,
+        OpenTracing::FORMAT_BINARY => JaegerBinaryCodec,
+        OpenTracing::FORMAT_RACK => JaegerRackCodec
+      }.freeze
+
+      def self.prepare(extractors)
+        DEFAULT_EXTRACTORS.reduce(extractors) do |acc, (format, default)|
+          provided_extractors = Array(extractors[format])
+          provided_extractors += [default] if provided_extractors.empty?
+
+          acc.merge(format => provided_extractors)
+        end
+      end
+    end
+  end
+end

data/lib/jaeger/client/http_sender.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Jaeger
+  module Client
+    class HttpSender
+      def initialize(url:, headers: {}, encoder:, logger: Logger.new(STDOUT))
+        @encoder = encoder
+        @logger = logger
+
+        @uri = URI(url)
+        @uri.query = 'format=jaeger.thrift'
+
+        @transport = ::Thrift::HTTPClientTransport.new(@uri.to_s)
+        @transport.add_headers(headers)
+
+        @serializer = ::Thrift::Serializer.new
+      end
+
+      def send_spans(spans)
+        batch = @encoder.encode(spans)
+        @transport.write(@serializer.serialize(batch))
+        @transport.flush
+      rescue StandardError => error
+        @logger.error("Failure while sending a batch of spans: #{error}")
+      end
+    end
+  end
+end

data/lib/jaeger/client/injectors.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Jaeger
+  module Client
+    module Injectors
+      class JaegerTextMapCodec
+        def self.inject(span_context, carrier)
+          carrier['uber-trace-id'] = [
+            span_context.trace_id.to_s(16),
+            span_context.span_id.to_s(16),
+            span_context.parent_id.to_s(16),
+            span_context.flags.to_s(16)
+          ].join(':')
+        end
+      end
+
+      class JaegerBinaryCodec
+        def self.inject(_span_context, _carrier)
+          warn 'Jaeger::Client with binary format is not supported yet'
+        end
+      end
+
+      class B3RackCodec
+        def self.inject(span_context, carrier)
+          carrier['x-b3-traceid'] = TraceId.to_hex(span_context.trace_id)
+          carrier['x-b3-spanid'] = TraceId.to_hex(span_context.span_id)
+          carrier['x-b3-parentspanid'] = TraceId.to_hex(span_context.parent_id)
+
+          # flags (for debug) and sampled headers are mutually exclusive
+          if span_context.flags == Jaeger::Client::SpanContext::Flags::DEBUG
+            carrier['x-b3-flags'] = '1'
+          else
+            carrier['x-b3-sampled'] = span_context.flags.to_s(16)
+          end
+        end
+      end
+
+      DEFAULT_INJECTORS = {
+        OpenTracing::FORMAT_TEXT_MAP => JaegerTextMapCodec,
+        OpenTracing::FORMAT_BINARY => JaegerBinaryCodec,
+        OpenTracing::FORMAT_RACK => JaegerTextMapCodec
+      }.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?
+
+          acc.merge(format => provided_extractors)
+        end
+      end
+    end
+  end
+end

data/lib/jaeger/client/span.rb

@@ -8,19 +8,19 @@ module Jaeger
     class Span
       attr_accessor :operation_name
 
-      attr_reader :context, :start_time, :references, :tags, :logs
+      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 collector [Collector] span collector
+      # @param reporter [#report] span reporter
       #
       # @return [Span] a new Span
-      def initialize(context, operation_name, collector, start_time: Time.now, references: [], tags: {})
+      def initialize(context, operation_name, reporter, start_time: Time.now, references: [], tags: {})
         @context = context
         @operation_name = operation_name
-        @collector = collector
+        @reporter = reporter
         @start_time = start_time
         @references = references
         @tags = tags.map { |key, value| ThriftTagBuilder.build(key, value) }
@@ -76,7 +76,8 @@ module Jaeger
       #
       # @param end_time [Time] custom end time, if not now
       def finish(end_time: Time.now)
-        @collector.send_span(self, end_time)
+        @end_time = end_time
+        @reporter.report(self)
       end
     end
   end

data/lib/jaeger/client/trace_id.rb

@@ -22,6 +22,20 @@ module Jaeger
       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
 end

data/lib/jaeger/client/tracer.rb

@@ -3,17 +3,14 @@
 module Jaeger
   module Client
     class Tracer
-      def initialize(collector, sender, sampler)
-        @collector = collector
-        @sender = sender
+      def initialize(reporter:, sampler:, injectors:, extractors:)
+        @reporter = reporter
         @sampler = sampler
+        @injectors = injectors
+        @extractors = extractors
         @scope_manager = ScopeManager.new
       end
 
-      def stop
-        @sender.stop
-      end
-
       # @return [ScopeManager] the current ScopeManager, which may be a no-op
       #   but may not be nil.
       attr_reader :scope_manager
@@ -61,7 +58,7 @@ module Jaeger
         Span.new(
           context,
           operation_name,
-          @collector,
+          @reporter,
           start_time: start_time,
           references: references,
           tags: tags.merge(
@@ -132,16 +129,8 @@ module Jaeger
       # @param format [OpenTracing::FORMAT_TEXT_MAP, OpenTracing::FORMAT_BINARY, OpenTracing::FORMAT_RACK]
       # @param carrier [Carrier] A carrier object of the type dictated by the specified `format`
       def inject(span_context, format, carrier)
-        case format
-        when OpenTracing::FORMAT_TEXT_MAP, OpenTracing::FORMAT_RACK
-          carrier['uber-trace-id'] = [
-            span_context.trace_id.to_s(16),
-            span_context.span_id.to_s(16),
-            span_context.parent_id.to_s(16),
-            span_context.flags.to_s(16)
-          ].join(':')
-        else
-          warn "Jaeger::Client with format #{format} is not supported yet"
+        @injectors.fetch(format).each do |injector|
+          injector.inject(span_context, carrier)
         end
       end
 
@@ -151,36 +140,16 @@ module Jaeger
       # @param carrier [Carrier] A carrier object of the type dictated by the specified `format`
       # @return [SpanContext] the extracted SpanContext or nil if none could be found
       def extract(format, carrier)
-        case format
-        when OpenTracing::FORMAT_TEXT_MAP
-          parse_context(carrier['uber-trace-id'])
-        when OpenTracing::FORMAT_RACK
-          parse_context(carrier['HTTP_UBER_TRACE_ID'])
-        else
-          warn "Jaeger::Client with format #{format} is not supported yet"
-          nil
-        end
+        @extractors
+          .fetch(format)
+          .lazy
+          .map { |extractor| extractor.extract(carrier) }
+          .reject(&:nil?)
+          .first
       end
 
       private
 
-      def parse_context(trace)
-        return nil if !trace || trace == ''
-
-        trace_arguments = trace.split(':').map(&TraceId.method(:base16_hex_id_to_uint64))
-        return nil if trace_arguments.size != 4
-
-        trace_id, span_id, parent_id, flags = trace_arguments
-        return nil if trace_id.zero? || span_id.zero?
-
-        SpanContext.new(
-          trace_id: trace_id,
-          parent_id: parent_id,
-          span_id: span_id,
-          flags: flags
-        )
-      end
-
       def prepare_span_context(child_of:, references:, ignore_active_scope:)
         context =
           context_from_child_of(child_of) ||

data/lib/jaeger/client/udp_sender.rb

@@ -7,66 +7,17 @@ require 'thread'
 module Jaeger
   module Client
     class UdpSender
-      def initialize(service_name:, host:, port:, collector:, flush_interval:, logger:)
-        @service_name = service_name
-        @collector = collector
-        @flush_interval = flush_interval
+      def initialize(host:, port:, encoder:, logger:)
+        @encoder = encoder
         @logger = logger
 
-        @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?
-          @tags << Jaeger::Thrift::Tag.new(
-            'key' => 'ip',
-            'vType' => Jaeger::Thrift::TagType::STRING,
-            'vStr' => ipv4.ip_address
-          )
-        end
-
         transport = Transport.new(host, port)
         protocol = ::Thrift::CompactProtocol.new(transport)
         @client = Jaeger::Thrift::Agent::Client.new(protocol)
       end
 
-      def start
-        # Sending spans in a separate thread to avoid blocking the main thread.
-        @thread = Thread.new do
-          loop do
-            emit_batch(@collector.retrieve)
-            sleep @flush_interval
-          end
-        end
-      end
-
-      def stop
-        @thread.terminate if @thread
-        emit_batch(@collector.retrieve)
-      end
-
-      private
-
-      def emit_batch(thrift_spans)
-        return if thrift_spans.empty?
-
-        batch = Jaeger::Thrift::Batch.new(
-          'process' => Jaeger::Thrift::Process.new(
-            'serviceName' => @service_name,
-            'tags' => @tags
-          ),
-          'spans' => thrift_spans
-        )
-
+      def send_spans(spans)
+        batch = @encoder.encode(spans)
         @client.emitBatch(batch)
       rescue StandardError => error
         @logger.error("Failure while sending a batch of spans: #{error}")

data/lib/jaeger/client/version.rb

@@ -2,6 +2,6 @@
 
 module Jaeger
   module Client
-    VERSION = '0.6.1'.freeze
+    VERSION = '0.7.0'.freeze
   end
 end

data/script/create_follows_from_trace

@@ -46,7 +46,6 @@ async_span = tracer2.start_span(
 sleep 0.3 # emulate network delay
 async_span.finish
 
-tracer1.stop
-tracer2.stop
+sleep 2
 
 puts 'Finished'

data/script/create_trace

@@ -47,7 +47,6 @@ inner_span.finish
 sleep 0.1 # doing something with fetched info
 outer_span.finish
 
-tracer1.stop
-tracer2.stop
+sleep 2
 
 puts 'Finished'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jaeger-client
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.7.0
 platform: ruby
 authors:
 - SaleMove TechMovers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-22 00:00:00.000000000 Z
+date: 2018-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -127,8 +127,13 @@ files:
 - bin/setup
 - 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/collector.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/samplers.rb
 - lib/jaeger/client/samplers/const.rb
 - lib/jaeger/client/samplers/probabilistic.rb
@@ -182,7 +187,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: OpenTracing Tracer implementation for Jaeger in Ruby

data/lib/jaeger/client/collector.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-require 'thread'
-
-module Jaeger
-  module Client
-    class Collector
-      def initialize
-        @buffer = Buffer.new
-      end
-
-      def send_span(span, end_time)
-        context = span.context
-        start_ts, duration = build_timestamps(span, end_time)
-        return if !context.sampled? && !context.debug?
-
-        @buffer << Jaeger::Thrift::Span.new(
-          'traceIdLow' => TraceId.uint64_id_to_int64(context.trace_id),
-          'traceIdHigh' => 0,
-          'spanId' => TraceId.uint64_id_to_int64(context.span_id),
-          'parentSpanId' => TraceId.uint64_id_to_int64(context.parent_id),
-          'operationName' => span.operation_name,
-          'references' => build_references(span.references || []),
-          'flags' => context.flags,
-          'startTime' => start_ts,
-          'duration' => duration,
-          'tags' => span.tags,
-          'logs' => span.logs
-        )
-      end
-
-      def retrieve
-        @buffer.retrieve
-      end
-
-      private
-
-      def build_references(references)
-        references.map do |ref|
-          Jaeger::Thrift::SpanRef.new(
-            'refType' => span_ref_type(ref.type),
-            'traceIdLow' => ref.context.trace_id,
-            'traceIdHigh' => 0,
-            'spanId' => ref.context.span_id
-          )
-        end
-      end
-
-      def build_timestamps(span, end_time)
-        start_ts = (span.start_time.to_f * 1_000_000).to_i
-        end_ts = (end_time.to_f * 1_000_000).to_i
-        duration = end_ts - start_ts
-        [start_ts, duration]
-      end
-
-      def span_ref_type(type)
-        case type
-        when OpenTracing::Reference::CHILD_OF
-          Jaeger::Thrift::SpanRefType::CHILD_OF
-        when OpenTracing::Reference::FOLLOWS_FROM
-          Jaeger::Thrift::SpanRefType::FOLLOWS_FROM
-        else
-          warn "Jaeger::Client with format #{type} is not supported yet"
-          nil
-        end
-      end
-
-      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