zipkin 1.6.0 → 1.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: edcdbbb5c2b3a3c8336007ad27cca00fa18e506c
-  data.tar.gz: e53e657b504bfed502e210cb4ece872f5d719391
+SHA256:
+  metadata.gz: 3b88fff10737cc10e0da917018436f4e0085e2f8bf384605fec56e84450595d3
+  data.tar.gz: 51ca7b5a0e4b1fca2a9eeeb02f73c9d139fe8cfaf78165850951cbb4d59bab09
 SHA512:
-  metadata.gz: 8815bc72662edeaed1773112b382134fa7b113290d6d8b1eeb62650ce18f54204048a3bfef69ae674fbbd6278af6bbc2f4603505691805eb0a260f45c9147475
-  data.tar.gz: c28399023b46377b0f3adc267e7b2b242a2e7998302f1ca3739acc8b2411b459af4d6eeef94061640051e4eadd38cb7181e76efe10bf11d2801dab1e93a4d2b7
+  metadata.gz: 1c68750c7f6758f4d81d9efd045e040b30afcc36e0679c5f0f12b8623a69f2bdc7fec0ca58ee56bbd1080f710e6449e601b3a5e486e45ea6892aaf1fce942f51
+  data.tar.gz: 52a89cb097adfa8ff282ae95d10a22c2c799782ad13fb356769ef2e8f66830390c2e7e18280dc8bb1de969490d090fb98a2542721a11c8d9901f910b8a5e0bae

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/span.rb

@@ -4,26 +4,26 @@ 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 = {}
       @logs = []
@@ -39,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
@@ -80,7 +80,8 @@ 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

data/lib/zipkin/tracer.rb

@@ -7,12 +7,13 @@ 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
@@ -22,30 +23,22 @@ module Zipkin
                    service_name:,
                    flush_interval: DEFAULT_FLUSH_INTERVAL,
                    logger: Logger.new(STDOUT),
-                   sampler: Samplers::Const.new(true))
-      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, sampler: sampler)
+                   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), sampler:)
-      @collector = collector
+    def initialize(reporter, sender, logger: Logger.new(STDOUT), sampler:)
+      @reporter = reporter
       @sender = sender
       @logger = logger
       @scope_manager = ScopeManager.new
       @sampler = sampler
     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
@@ -93,7 +86,7 @@ module Zipkin
       Span.new(
         context,
         operation_name,
-        @collector,
+        @reporter,
         start_time: start_time,
         references: references,
         tags: tags || {}

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,7 +3,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = 'zipkin'
-  spec.version       = '1.6.0'
+  spec.version       = '1.6.1'
   spec.authors       = ['SaleMove TechMovers']
   spec.email         = ['techmovers@salemove.com']
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zipkin
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.6.1
 platform: ruby
 authors:
 - SaleMove TechMovers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-10 00:00:00.000000000 Z
+date: 2018-08-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -126,12 +126,15 @@ 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
@@ -144,6 +147,7 @@ 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: ''
@@ -166,7 +170,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.7.6
 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