zipkin 1.5.0 → 1.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: '08c97e0494e2aada96486d717d1cd8b645da89c2'
-  data.tar.gz: dc7681e5f0a7c4efe293f22ad496f9c352675137
+SHA256:
+  metadata.gz: d406755c3fae0a6ad07050d0bfa19a903ce5e5ca414ad0530d172061ef0e2a69
+  data.tar.gz: 8f377efd4748398e92dc6cf565f40819e25cf26ca0a0b2f9c119e21ed7ce36c6
 SHA512:
-  metadata.gz: 3f80229eec38c0f34c83276264b90073195b80e74f5389569ff5458957e9f90e85a02856684a169a116239cb5c804a9eef69161b32851ac38222545090a26306
-  data.tar.gz: b2ee56339a6e2eb7aa615becf7fd163fd86d66e165fb065a3f50e9cc89fd217a3be3628f7484491f90c866b8460b4f4eea0c487575de29693da928895307d059
+  metadata.gz: c94f44c0d12367b67bddef7c928fa27528a13eedddf4a1b99c4c3eec34553ee8a6c949dc43797e00ce13ba8a47f59b615f4779fd7375ea1d28e2dda1a1fc6058
+  data.tar.gz: 904580f268829d5699001cc260ed53c26def532e84e50bf6eb9b9e44c89daa5861482d77a24722b729d775c1b5dbb514812d4ff68ac0b242fbfbf873409baffc

data/.travis.yml

@@ -1,5 +1,5 @@
 sudo: false
 language: ruby
 rvm:
-  - 2.4.0
-before_install: gem install bundler -v 1.14.4
+  - 2.6.0
+before_install: gem install bundler

data/README.md

@@ -31,6 +31,16 @@ end
 
 See [opentracing-ruby](https://github.com/opentracing/opentracing-ruby) for more examples.
 
+### Samplers
+
+#### Const sampler
+
+`Const` sampler always makes the same decision for new traces depending on the initialization value. Set `sampler` to: `Zipkin::Samplers::Const.new(true)` to mark all new traces as sampled.
+
+#### Probabilistic sampler
+
+`Probabilistic` sampler samples traces with probability equal to `rate` (must be between 0.0 and 1.0). Set `sampler` to `Zipkin::Samplers::Probabilistic.new(rate: 0.1)` to mark 10% of new traces as sampled.
+
 ## 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/zipkin/async_reporter.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'thread'
+
+require_relative './async_reporter/buffer'
+
+module Zipkin
+  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 unless span.context.sampled?
+      @buffer << span
+    end
+  end
+end

data/lib/zipkin/async_reporter/buffer.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Zipkin
+  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

data/lib/zipkin/encoders.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'encoders/json_encoder'

data/lib/zipkin/encoders/json_encoder.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'json'
+
+require_relative 'json_encoder/timestamp'
+require_relative 'json_encoder/log_annotations'
+
+module Zipkin
+  module Encoders
+    class JsonEncoder
+      OT_KIND_TO_ZIPKIN_KIND = {
+        'server' => 'SERVER',
+        'client' => 'CLIENT',
+        'producer' => 'PRODUCER',
+        'consumer' => 'CONSUMER'
+      }.freeze
+
+      CONTENT_TYPE = 'application/json'.freeze
+
+      module Fields
+        TRACE_ID = 'traceId'.freeze
+        SPAN_ID = 'id'.freeze
+        PARENT_ID = 'parentId'.freeze
+        OPERATION_NAME = 'name'.freeze
+        KIND = 'kind'.freeze
+        TIMESTAMP = 'timestamp'.freeze
+        DURATION = 'duration'.freeze
+        DEBUG = 'debug'.freeze
+        SHARED = 'shared'.freeze
+        LOCAL_ENDPOINT = 'localEndpoint'.freeze
+        REMOTE_ENDPOINT = 'remoteEndpoint'.freeze
+        ANNOTATIONS = 'annotations'.freeze
+        TAGS = 'tags'.freeze
+
+        module Endpoint
+          SERVICE_NAME = 'serviceName'.freeze
+          IPV4 = 'ipv4'.freeze
+          IPV6 = 'ipv6'.freeze
+          PORT = 'port'.freeze
+        end
+      end
+
+      def initialize(local_endpoint)
+        @adapter = defined?(Oj) ? OjAdapter : JsonAdapter
+        @local_endpoint = serialize_endpoint(local_endpoint)
+      end
+
+      def content_type
+        CONTENT_TYPE
+      end
+
+      def encode(spans)
+        @adapter.dump(spans.map(&method(:serialize)))
+      end
+
+      private
+
+      def serialize(span)
+        finish_ts = Timestamp.create(span.end_time)
+        start_ts = Timestamp.create(span.start_time)
+        duration = finish_ts - start_ts
+
+        {
+          Fields::TRACE_ID => span.context.trace_id,
+          Fields::SPAN_ID => span.context.span_id,
+          Fields::PARENT_ID => span.context.parent_id,
+          Fields::OPERATION_NAME => span.operation_name,
+          Fields::KIND => OT_KIND_TO_ZIPKIN_KIND[span.tags[:'span.kind'] || 'server'],
+          Fields::TIMESTAMP => start_ts,
+          Fields::DURATION => duration,
+          Fields::DEBUG => false,
+          Fields::SHARED => false,
+          Fields::LOCAL_ENDPOINT => @local_endpoint,
+          Fields::REMOTE_ENDPOINT => serialize_endpoint(Endpoint.remote_endpoint(span)),
+          Fields::ANNOTATIONS => LogAnnotations.build(span),
+          Fields::TAGS => span.tags
+        }
+      end
+
+      def serialize_endpoint(endpoint)
+        return nil unless endpoint
+
+        {
+          Fields::Endpoint::SERVICE_NAME => endpoint.service_name,
+          Fields::Endpoint::IPV4 => endpoint.ipv4,
+          Fields::Endpoint::IPV6 => endpoint.ipv6,
+          Fields::Endpoint::PORT => endpoint.port
+        }
+      end
+
+      module OjAdapter
+        def self.dump(payload)
+          Oj.dump(payload, mode: :object)
+        end
+      end
+
+      module JsonAdapter
+        def self.dump(payload)
+          JSON.dump(payload)
+        end
+      end
+    end
+  end
+end

data/lib/zipkin/encoders/json_encoder/log_annotations.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Zipkin
+  module Encoders
+    class JsonEncoder
+      module LogAnnotations
+        module Fields
+          TIMESTAMP = 'timestamp'.freeze
+          VALUE = 'value'.freeze
+        end
+
+        def self.build(span)
+          span.logs.map do |log|
+            {
+              Fields::TIMESTAMP => Timestamp.create(log.fetch(:timestamp)),
+              Fields::VALUE => format_log_value(log)
+            }
+          end
+        end
+
+        def self.format_log_value(log)
+          if log.keys == %i[event timestamp]
+            log.fetch(:event)
+          else
+            log
+              .reject { |key, _value| key == :timestamp }
+              .map { |key, value| "#{key}=#{value}" }
+              .join(' ')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/zipkin/encoders/json_encoder/timestamp.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Zipkin
+  module Encoders
+    class JsonEncoder
+      module Timestamp
+        def self.create(time)
+          (time.to_f * 1_000_000).to_i
+        end
+      end
+    end
+  end
+end

data/lib/zipkin/endpoint.rb

@@ -17,10 +17,10 @@ module Zipkin
     end
 
     module PeerInfo
-      SERVICE = :'peer.service'
-      IPV4 = :'peer.ipv4'
-      IPV6 = :'peer.ipv6'
-      PORT = :'peer.port'
+      SERVICE = 'peer.service'.freeze
+      IPV4 = 'peer.ipv4'.freeze
+      IPV6 = 'peer.ipv6'.freeze
+      PORT = 'peer.port'.freeze
 
       def self.keys
         [SERVICE, IPV4, IPV6, PORT]
@@ -28,34 +28,38 @@ module Zipkin
     end
 
     def self.local_endpoint(service_name)
-      {
-        serviceName: service_name,
-        ipv4: LOCAL_IP
-      }
+      new(service_name: service_name, ipv4: LOCAL_IP)
     end
 
     def self.remote_endpoint(span)
       tags = span.tags
-      kind = tags[:'span.kind'] || SpanKind::SERVER
+      kind = tags['span.kind'] || SpanKind::SERVER
 
       case kind
       when SpanKind::SERVER, SpanKind::CLIENT
         return nil if (tags.keys & PeerInfo.keys).empty?
 
-        {
-          serviceName: tags[PeerInfo::SERVICE],
+        new(
+          service_name: tags[PeerInfo::SERVICE],
           ipv4: tags[PeerInfo::IPV4],
           ipv6: tags[PeerInfo::IPV6],
           port: tags[PeerInfo::PORT]
-        }
+        )
       when SpanKind::PRODUCER, SpanKind::CONSUMER
-        {
-          serviceName: 'broker'
-        }
+        new(service_name: 'broker')
       else
         warn "Unkown span kind: #{kind}"
         nil
       end
     end
+
+    def initialize(service_name: nil, ipv4: nil, ipv6: nil, port: nil)
+      @service_name = service_name
+      @ipv4 = ipv4
+      @ipv6 = ipv6
+      @port = port
+    end
+
+    attr_reader :service_name, :ipv4, :ipv6, :port
   end
 end

data/lib/zipkin/{json_client.rb → http_client.rb}

@@ -2,43 +2,23 @@
 
 require 'net/http'
 require 'uri'
-require 'json'
 
 module Zipkin
-  class JsonClient
-    def initialize(url:, collector:, flush_interval:, logger: Logger.new(STDOUT))
-      @collector = collector
-      @flush_interval = flush_interval
+  class HTTPClient
+    def initialize(url:, encoder:, logger:)
+      @encoder = encoder
       @spans_uri = URI.parse("#{url}/api/v2/spans")
       @logger = logger
     end
 
-    def start
-      @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(spans)
-      return if spans.empty?
-
+    def send_spans(spans)
       http = Net::HTTP.new(@spans_uri.host, @spans_uri.port)
       http.use_ssl = @spans_uri.scheme == 'https'
       request = Net::HTTP::Post.new(
         @spans_uri.request_uri,
-        'Content-Type' => 'application/json'
+        'Content-Type' => @encoder.content_type
       )
-      request.body = JSON.dump(spans)
+      request.body = @encoder.encode(spans)
       response = http.request(request)
 
       if response.code != '202'

data/lib/zipkin/samplers.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative 'samplers/const'
+require_relative 'samplers/probabilistic'

data/lib/zipkin/samplers/const.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Zipkin
+  module Samplers
+    # Const sampler
+    #
+    # A sampler that always makes the same decision for new traces depending
+    # on the initialization value. Use `Zipkin::Samplers::Const.new(true)`
+    # to mark all new traces as sampled.
+    class Const
+      def initialize(decision)
+        @decision = decision
+      end
+
+      def sample?(*)
+        @decision
+      end
+    end
+  end
+end

data/lib/zipkin/samplers/probabilistic.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Zipkin
+  module Samplers
+    # Probabilistic sampler
+    #
+    # Sample a portion of traces using trace_id as the random decision
+    class Probabilistic
+      def initialize(rate: 0.001)
+        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.to_i(16)
+      end
+    end
+  end
+end

data/lib/zipkin/span.rb

@@ -4,30 +4,32 @@ module Zipkin
   class Span
     attr_accessor :operation_name
 
-    attr_reader :context, :start_time, :tags, :logs, :references
+    attr_reader :context, :start_time, :end_time, :tags, :logs, :references
 
     # Creates a new {Span}
     #
     # @param context [SpanContext] the context of the span
     # @param operation_name [String] the operation name
-    # @param collector [Collector] the span collector
+    # @param reporter [#report] the span reporter
     #
     # @return [Span] a new Span
     def initialize(
       context,
       operation_name,
-      collector,
+      reporter,
       start_time: Time.now,
       tags: {},
       references: nil
     )
       @context = context
       @operation_name = operation_name
-      @collector = collector
+      @reporter = reporter
       @start_time = start_time
-      @tags = tags
+      @tags = {}
       @logs = []
       @references = references
+
+      tags.each(&method(:set_tag))
     end
 
     # Set a tag value on this span
@@ -37,7 +39,7 @@ module Zipkin
     # a String, Numeric, or Boolean it will be encoded with to_s
     def set_tag(key, value)
       sanitized_value = valid_tag_value?(value) ? value : value.to_s
-      @tags = @tags.merge(key.to_sym => sanitized_value)
+      @tags = @tags.merge(key.to_s => sanitized_value)
     end
 
     # Set a baggage item on the span
@@ -78,16 +80,15 @@ module Zipkin
     #
     # @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
 
     private
 
+    # Zipkin supports only strings and numbers
     def valid_tag_value?(value)
-      value.is_a?(String) ||
-        value.is_a?(Numeric) ||
-        value.is_a?(TrueClass) ||
-        value.is_a?(FalseClass)
+      value.is_a?(String) || value.is_a?(Numeric)
     end
   end
 end

data/lib/zipkin/span_context.rb

@@ -3,9 +3,10 @@
 module Zipkin
   # SpanContext holds the data for a span that gets inherited to child spans
   class SpanContext
-    def self.create_parent_context
+    def self.create_parent_context(sampler = Samplers::Const.new(true))
       trace_id = TraceId.generate
-      new(trace_id: trace_id, span_id: trace_id, sampled: true)
+      sampled = sampler.sample?(trace_id: trace_id)
+      new(trace_id: trace_id, span_id: trace_id, sampled: sampled)
     end
 
     def self.create_from_parent_context(span_context)

data/lib/zipkin/trace_id.rb

@@ -4,8 +4,28 @@ module Zipkin
   module TraceId
     TRACE_ID_UPPER_BOUND = 2**64
 
+    # Random number generator for generating IDs. This is an object that can
+    # respond to `#bytes` and uses the system PRNG. The current logic is
+    # compatible with Ruby 2.5 (which does not implement the `Random.bytes`
+    # class method) and with Ruby 3.0+ (which deprecates `Random::DEFAULT`).
+    # When we drop support for Ruby 2.5, this can simply be replaced with
+    # the class `Random`.
+    #
+    # @return [#bytes]
+    RANDOM = Random.respond_to?(:bytes) ? Random : Random::DEFAULT
+
+    # An invalid trace identifier, an 8-byte string with all zero bytes.
+    INVALID_TRACE_ID = ("\0" * 8).b
+
+    # Generates a valid trace identifier, an 8-byte string with at least one
+    # non-zero byte.
+    #
+    # @return [String] a valid trace ID.
     def self.generate
-      rand(TRACE_ID_UPPER_BOUND).to_s(16)
+      loop do
+        id = RANDOM.bytes(8)
+        return id.unpack1('H*') if id != INVALID_TRACE_ID
+      end
     end
   end
 end

data/lib/zipkin/tracer.rb

@@ -7,37 +7,36 @@ require_relative 'span'
 require_relative 'span_context'
 require_relative 'carrier'
 require_relative 'trace_id'
-require_relative 'json_client'
+require_relative 'http_client'
 require_relative 'endpoint'
-require_relative 'collector'
+require_relative 'async_reporter'
 require_relative 'scope_manager'
 require_relative 'scope'
+require_relative 'samplers'
+require_relative 'encoders'
 
 module Zipkin
   class Tracer
     DEFAULT_FLUSH_INTERVAL = 10
 
-    def self.build(url:, service_name:, flush_interval: DEFAULT_FLUSH_INTERVAL, logger: Logger.new(STDOUT))
-      collector = Collector.new(Endpoint.local_endpoint(service_name))
-      sender = JsonClient.new(
-        url: url,
-        collector: collector,
-        flush_interval: flush_interval,
-        logger: logger
-      )
-      sender.start
-      new(collector, sender, logger: logger)
+    def self.build(url:,
+                   service_name:,
+                   flush_interval: DEFAULT_FLUSH_INTERVAL,
+                   logger: Logger.new(STDOUT),
+                   sampler: Samplers::Const.new(true),
+                   encoder: Encoders::JsonEncoder)
+      encoder = encoder.new(Endpoint.local_endpoint(service_name))
+      sender = HTTPClient.new(url: url, encoder: encoder, logger: logger)
+      reporter = AsyncReporter.create(sender: sender, flush_interval: flush_interval)
+      new(reporter, sender, logger: logger, sampler: sampler)
     end
 
-    def initialize(collector, sender, logger: Logger.new(STDOUT))
-      @collector = collector
+    def initialize(reporter, sender, logger: Logger.new(STDOUT), sampler:)
+      @reporter = reporter
       @sender = sender
       @logger = logger
       @scope_manager = ScopeManager.new
-    end
-
-    def stop
-      @sender.stop
+      @sampler = sampler
     end
 
     # @return [ScopeManager] the current ScopeManager, which may be a no-op but
@@ -75,7 +74,7 @@ module Zipkin
     def start_span(operation_name,
                    child_of: nil,
                    start_time: Time.now,
-                   tags: {},
+                   tags: nil,
                    references: nil,
                    ignore_active_scope: false,
                    **)
@@ -87,10 +86,10 @@ module Zipkin
       Span.new(
         context,
         operation_name,
-        @collector,
+        @reporter,
         start_time: start_time,
         references: references,
-        tags: tags
+        tags: tags || {}
       )
     end
 
@@ -220,7 +219,7 @@ module Zipkin
       if context
         SpanContext.create_from_parent_context(context)
       else
-        SpanContext.create_parent_context
+        SpanContext.create_parent_context(@sampler)
       end
     end
 

data/script/create_follows_from_trace

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'bundler'
 Bundler.setup
@@ -7,8 +8,8 @@ require 'zipkin/tracer'
 
 url = ENV['ZIPKIN_URL'] || 'http://localhost:9411'
 
-tracer1 = Zipkin::Tracer.build(url: url, service_name: 'test-service')
-tracer2 = Zipkin::Tracer.build(url: url, service_name: 'downstream-service')
+tracer1 = Zipkin::Tracer.build(url: url, service_name: 'test-service', flush_interval: 1)
+tracer2 = Zipkin::Tracer.build(url: url, service_name: 'downstream-service', flush_interval: 1)
 
 rpc_span = tracer1.start_span(
   'receive request',
@@ -45,7 +46,4 @@ async_span = tracer2.start_span(
 sleep 0.3 # emulate network delay
 async_span.finish
 
-tracer1.stop
-tracer2.stop
-
 puts 'Finished'

data/script/create_http_trace

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler'
+Bundler.setup
+
+require 'zipkin/tracer'
+
+url = ENV['ZIPKIN_URL'] || 'http://localhost:9411'
+
+tracer1 = Zipkin::Tracer.build(url: url, service_name: 'user-service', flush_interval: 1)
+tracer2 = Zipkin::Tracer.build(url: url, service_name: 'name-service', flush_interval: 1)
+
+root_span = tracer1.start_span(
+  'GET /users/:id',
+  tags: {
+    'span.kind' => 'server',
+    'http.method' => 'get',
+    'http.url' => 'http://example.com/users/5'
+  }
+)
+sleep 1
+
+fetch_name_span = tracer1.start_span(
+  'get',
+  child_of: root_span,
+  tags: {
+    'span.kind' => 'client',
+    'http.method' => 'get',
+    'http.url' => 'GET /users/5/name'
+  }
+)
+sleep 0.3 # emulate network delay
+
+name_service_span = tracer2.start_span(
+  'GET /users/:id/name',
+  child_of: fetch_name_span,
+  tags: {
+    'span.kind' => 'server',
+    'http.method' => 'get',
+    'http.url' => 'http://example.com/users/5/name'
+  }
+)
+sleep 0.5
+name_service_span.finish
+
+sleep 0.2 # emulate network delay
+fetch_name_span.finish
+
+sleep 0.1 # doing something with fetched info
+root_span.finish
+
+puts 'Finishing...'
+sleep 3
+
+puts 'Finished'

data/script/create_trace

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'bundler'
 Bundler.setup
@@ -7,10 +8,10 @@ require 'zipkin/tracer'
 
 url = ENV['ZIPKIN_URL'] || 'http://localhost:9411'
 
-tracer1 = Zipkin::Tracer.build(url: url, service_name: 'test-service')
-tracer2 = Zipkin::Tracer.build(url: url, service_name: 'downstream-service')
+tracer1 = Zipkin::Tracer.build(url: url, service_name: 'test-service', flush_interval: 1)
+tracer2 = Zipkin::Tracer.build(url: url, service_name: 'downstream-service-1', flush_interval: 1)
 
-outer_span = tracer1.start_span(
+root_span = tracer1.start_span(
   'receive request',
   tags: {
     'span.kind' => 'server'
@@ -18,39 +19,52 @@ outer_span = tracer1.start_span(
 )
 sleep 1
 
-inner_span = tracer1.start_span(
-  'fetch info from downstream',
-  child_of: outer_span,
+fetch_info_from_service1_span = tracer1.start_span(
+  'fetch info from service 1',
+  child_of: root_span,
   tags: {
     'span.kind' => 'client',
-    'peer.service' => 'downstream-service',
-    'peer.ipv4' => '6.6.6.6',
+    'peer.ipv4' => '2.2.2.2',
     'peer.port' => 443
   }
 )
 sleep 0.3 # emulate network delay
 
-downstream_span = tracer2.start_span(
-  'downstream operation',
-  child_of: inner_span,
-  tags: { 'span.kind' => 'server' }
+service1_span = tracer2.start_span(
+  'service 1 operation',
+  child_of: fetch_info_from_service1_span,
+  tags: {
+    'span.kind' => 'server',
+    'peer.ipv4' => '1.1.1.1',
+    'peer.port' => 443
+  }
 )
-downstream_span.log_kv(event: 'custom-event')
-downstream_span.log_kv(foo: 'bar', baz: 'buz')
+service1_span.log_kv(event: 'custom-event')
+service1_span.log_kv(foo: 'bar', baz: 'buz')
 sleep 0.5
-downstream_span.finish
+service1_span.finish
 
 sleep 0.2 # emulate network delay
 
-inner_span.finish
+fetch_info_from_service1_span.finish
+
+fetch_info_from_service2_span = tracer1.start_span(
+  'fetch info from service 2 which does not have tracing',
+  child_of: root_span,
+  tags: {
+    'span.kind' => 'client',
+    'peer.service' => 'downstream-service-2',
+    'peer.ipv4' => '3.3.3.3',
+    'peer.port' => 443
+  }
+)
+sleep 0.3 # emulate network delay
+fetch_info_from_service2_span.finish
 
 sleep 0.1 # doing something with fetched info
-outer_span.finish
+root_span.finish
 
 puts 'Finishing...'
 sleep 3
 
-tracer1.stop
-tracer2.stop
-
 puts 'Finished'

data/zipkin.gemspec

@@ -3,13 +3,13 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = 'zipkin'
-  spec.version       = '1.5.0'
+  spec.version       = '1.6.2'
   spec.authors       = ['SaleMove TechMovers']
   spec.email         = ['techmovers@salemove.com']
 
   spec.summary       = 'OpenTracing Tracer implementation for Zipkin in Ruby'
   spec.description   = ''
-  spec.homepage      = ''
+  spec.homepage      = 'https://github.com/salemove/zipkin-ruby-opentracing'
   spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0").reject do |f|
@@ -18,7 +18,7 @@ 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', '~> 2.0'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
   spec.add_development_dependency 'rubocop', '~> 0.54.0'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zipkin
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.6.2
 platform: ruby
 authors:
 - SaleMove TechMovers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-01 00:00:00.000000000 Z
+date: 2021-01-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.14'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.14'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -126,12 +126,18 @@ files:
 - bin/console
 - bin/setup
 - lib/zipkin.rb
+- lib/zipkin/async_reporter.rb
+- lib/zipkin/async_reporter/buffer.rb
 - lib/zipkin/carrier.rb
-- lib/zipkin/collector.rb
-- lib/zipkin/collector/log_annotations.rb
-- lib/zipkin/collector/timestamp.rb
+- lib/zipkin/encoders.rb
+- lib/zipkin/encoders/json_encoder.rb
+- lib/zipkin/encoders/json_encoder/log_annotations.rb
+- lib/zipkin/encoders/json_encoder/timestamp.rb
 - lib/zipkin/endpoint.rb
-- lib/zipkin/json_client.rb
+- lib/zipkin/http_client.rb
+- lib/zipkin/samplers.rb
+- lib/zipkin/samplers/const.rb
+- lib/zipkin/samplers/probabilistic.rb
 - lib/zipkin/scope.rb
 - lib/zipkin/scope_manager.rb
 - lib/zipkin/scope_manager/scope_identifier.rb
@@ -141,9 +147,10 @@ files:
 - lib/zipkin/trace_id.rb
 - lib/zipkin/tracer.rb
 - script/create_follows_from_trace
+- script/create_http_trace
 - script/create_trace
 - zipkin.gemspec
-homepage: ''
+homepage: https://github.com/salemove/zipkin-ruby-opentracing
 licenses:
 - MIT
 metadata: {}
@@ -162,8 +169,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: OpenTracing Tracer implementation for Zipkin in Ruby

data/lib/zipkin/collector.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-require 'thread'
-
-require_relative './collector/timestamp'
-require_relative './collector/log_annotations'
-
-module Zipkin
-  class Collector
-    OT_KIND_TO_ZIPKIN_KIND = {
-      'server' => 'SERVER',
-      'client' => 'CLIENT',
-      'producer' => 'PRODUCER',
-      'consumer' => 'CONSUMER'
-    }.freeze
-
-    def initialize(local_endpoint)
-      @buffer = Buffer.new
-      @local_endpoint = local_endpoint
-    end
-
-    def retrieve
-      @buffer.retrieve
-    end
-
-    def send_span(span, end_time)
-      finish_ts = Timestamp.create(end_time)
-      start_ts = Timestamp.create(span.start_time)
-      duration = finish_ts - start_ts
-      return unless span.context.sampled?
-
-      @buffer << {
-        traceId: span.context.trace_id,
-        id: span.context.span_id,
-        parentId: span.context.parent_id,
-        name: span.operation_name,
-        kind: OT_KIND_TO_ZIPKIN_KIND[span.tags[:'span.kind'] || 'server'],
-        timestamp: start_ts,
-        duration: duration,
-        debug: false,
-        shared: false,
-        localEndpoint: @local_endpoint,
-        remoteEndpoint: Endpoint.remote_endpoint(span),
-        annotations: LogAnnotations.build(span),
-        tags: span.tags
-      }
-    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

data/lib/zipkin/collector/log_annotations.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Zipkin
-  class Collector
-    module LogAnnotations
-      def self.build(span)
-        span.logs.map do |log|
-          {
-            timestamp: Timestamp.create(log.fetch(:timestamp)),
-            value: format_log_value(log)
-          }
-        end
-      end
-
-      def self.format_log_value(log)
-        if log.keys == %i[event timestamp]
-          log.fetch(:event)
-        else
-          log
-            .reject { |key, _value| key == :timestamp }
-            .map { |key, value| "#{key}=#{value}" }
-            .join(' ')
-        end
-      end
-    end
-  end
-end

data/lib/zipkin/collector/timestamp.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Zipkin
-  class Collector
-    module Timestamp
-      def self.create(time)
-        (time.to_f * 1_000_000).to_i
-      end
-    end
-  end
-end