zipkin-tracer 0.9.1 → 0.10.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    M2EzMTQzN2NjZGEwNGNlOTY1ZTdjNDcxMDUyNjYzYzgwZDg1MmIwZQ==
+    YzUzN2QzOWMyMzczNmIxNGRhMzU0YWIzNzU4NWNkZWU3NjY0YTcxOA==
   data.tar.gz: !binary |-
-    YmM0ZDVjYWNmMDcwOGFlMjVkYjM3Yjk5MjgxY2IwYzhjMzA5OGUwNg==
+    MDBkMTNiNmU5N2E0NGIwY2ZiZmI1MTYzMTFiYTU5ODkxNmI5NDMxYQ==
 SHA512:
   metadata.gz: !binary |-
-    ZmRlY2Y2OWI5ZjBiMGY4N2RhMTNhMjQ0Nzk1NWQzY2FjZDc2MWFiNzE1MGY0
-    MTNkZTZlNGE5M2NjYjk3ZmM0ZTFlNmEyOTQxNmQ5MmZiZjIzMmQzMzJkNGVj
-    YWM0ODRmOWVjY2YzNjU3MDAzZTFmZDc3ZjRkNzJhNzQ2NWU4ODU=
+    MjY1NmFkODBiYzgyZWE4MTA5ZjQwOWU2MDRlZDIyYmZmYmMyZjA0MGNiOWE2
+    ZWQ4MTBiOGU4N2RmNGRhYmE0MjI3MGIyMjg0MjE1OWE4NzM5NWY1MDBlYmQ2
+    NzhlZTc1NGZiNjM3ZGQzYTg2ZDU5NmY1M2Q3YmZkNWNmZjgwODQ=
   data.tar.gz: !binary |-
-    ZjJiOWUyZTZhYmY5ZjQwNWNhZTg4NjM0OGZlNzE4MGZhNzgwNDZjOGFkMzEz
-    MWIzNDlkODE5YjMyZjM1Nzk2NjhkMjc5NzhmMWE4Y2NiODZkMGRiMTJiZGNh
-    YjhmNGVmYzM5NDkxNzQ4ZjEyZDQ4ZTdlNDYzZWQ5ZDQzNTA0NjQ=
+    NmRjYmYyZWM4OGEzYmMyMTUzYzE5MzNjOGQxZDkyZTRiYTgxYzkyYzg3MTIy
+    YWRiYzkwYmIxYmM3MmIzZmFkZmJlMmZmOTBiM2FjZWFjNjA0ZGMwY2ZhNmI4
+    ZjVmNzU4ZGUwYzczZmNkM2U0M2ZmNjQxZDRkZDI2YTY3MmVlOTU=

data/lib/zipkin-tracer/faraday/zipkin-tracer.rb

@@ -16,48 +16,46 @@ module ZipkinTracer
     def initialize(app, service_name = nil)
       @app = app
       @service_name = service_name
+      @tracer = Trace.tracer
     end
 
     def call(env)
       # handle either a URI object (passed by Faraday v0.8.x in testing), or something string-izable
       url = env[:url].respond_to?(:host) ? env[:url] : URI.parse(env[:url].to_s)
-      local_endpoint = ::Trace.default_endpoint # The rack middleware set this up for us.
+      local_endpoint = Trace.default_endpoint # The rack middleware set this up for us.
       remote_endpoint = callee_endpoint(url, local_endpoint.ip_format) # The endpoint we are calling.
-
       response = nil
-      begin
-        trace_id = ::Trace.id
-        ::Trace.push(trace_id.next_id)
+      trace_id = Trace.id.next_id
+      with_trace_id(trace_id) do
         B3_HEADERS.each do |method, header|
-          env[:request_headers][header] = ::Trace.id.send(method).to_s
+          env[:request_headers][header] = trace_id.send(method).to_s
         end
         # annotate with method (GET/POST/etc.) and uri path
-        ::Trace.set_rpc_name(env[:method].to_s.downcase)
-        record(::Trace::BinaryAnnotation.new('http.uri', url.path, 'STRING', local_endpoint))
-        record(::Trace::BinaryAnnotation.new('sa', '1', 'BOOL', remote_endpoint))
-        record(::Trace::Annotation.new(::Trace::Annotation::CLIENT_SEND, local_endpoint))
+        @tracer.set_rpc_name(trace_id, env[:method].to_s.downcase)
+        @tracer.record(trace_id, Trace::BinaryAnnotation.new('http.uri', url.path, 'STRING', local_endpoint))
+        @tracer.record(trace_id, Trace::BinaryAnnotation.new('sa', '1', 'BOOL', remote_endpoint))
+        @tracer.record(trace_id, Trace::Annotation.new(Trace::Annotation::CLIENT_SEND, local_endpoint))
         response = @app.call(env).on_complete do |renv|
           # record HTTP status code on response
-          record(::Trace::BinaryAnnotation.new('http.status', renv[:status].to_s, 'STRING', local_endpoint))
+          @tracer.record(trace_id, Trace::BinaryAnnotation.new('http.status', renv[:status].to_s, 'STRING', local_endpoint))
         end
-        record(::Trace::Annotation.new(::Trace::Annotation::CLIENT_RECV, local_endpoint))
-      ensure
-        ::Trace.pop
+        @tracer.record(trace_id, Trace::Annotation.new(Trace::Annotation::CLIENT_RECV, local_endpoint))
       end
       response
     end
 
     private
 
-    def record(annotation)
-      ::Trace.record(annotation)
-    rescue Exception # Sockets errors inherit from Exception, not from StandardError
-      #TODO: if this class some day accepts a config hash, add a logger
+    def with_trace_id(trace_id, &block)
+      Trace.push(trace_id)
+      yield
+    ensure
+      Trace.pop
     end
 
     def callee_endpoint(url, ip_format)
       service_name = @service_name || url.host.split('.').first || 'unknown' # default to url-derived service name
-      ::Trace::Endpoint.make_endpoint(url.host, url.port, service_name, ip_format)
+      Trace::Endpoint.make_endpoint(url.host, url.port, service_name, ip_format)
     end
   end
 end

data/lib/zipkin-tracer/rack/zipkin-tracer.rb

@@ -13,11 +13,13 @@
 # limitations under the License.
 require 'finagle-thrift'
 require 'finagle-thrift/trace'
-require 'sucker_punch'
 require 'zipkin-tracer/config'
+require 'zipkin-tracer/tracer_factory'
 
 module ZipkinTracer
 
+  # This middleware reads Zipkin headers from the request and sets/creates a Trace.id usable by the rest of the app
+  # It will also send the trace to the Zipkin service using one of the methods configured.
   class RackHandler
     B3_REQUIRED_HEADERS = %w[HTTP_X_B3_TRACEID HTTP_X_B3_PARENTSPANID HTTP_X_B3_SPANID HTTP_X_B3_SAMPLED]
     B3_OPT_HEADERS = %w[HTTP_X_B3_FLAGS]
@@ -25,53 +27,33 @@ module ZipkinTracer
     def initialize(app, config = nil)
       @app = app
       @lock = Mutex.new
+      @config = Config.new(app, config).freeze
+      @tracer = TracerFactory.new.tracer(@config)
+    end
 
-      config = Config.new(app, config)
-      SuckerPunch.logger = config.logger
-      adapter = config.adapter
-
-      ::Trace.tracer = case adapter
-        when :json
-          require 'zipkin-tracer/zipkin_json_tracer'
-          ::Trace::ZipkinJsonTracer.new(config.json_api_host, config.traces_buffer)
-        when :scribe
-          require 'zipkin-tracer/careless_scribe'
-          ::Trace::ZipkinTracer.new(CarelessScribe.new(config.scribe_server), config.scribe_max_buffer)
-        when :kafka
-          require 'zipkin-tracer/zipkin_kafka_tracer'
-          kafkaTracer = ::Trace::ZipkinKafkaTracer.new
-          kafkaTracer.connect(config.zookeeper)
-          kafkaTracer
+    def call(env)
+      zipkin_env = ZipkinEnv.new(env, @config)
+      trace_id = zipkin_env.trace_id
+      with_trace_id(trace_id) do
+        if !trace_id.sampled? || !routable_request?(env)
+          @app.call(env)
         else
-          ::Trace::NullTracer.new
+          trace!(trace_id, zipkin_env) { @app.call(env) }
+        end
       end
-
-      ip_format = config.adapter == :json ? :string : :i32
-      ::Trace.default_endpoint = ::Trace::Endpoint.make_endpoint(
-        nil, # auto detect hostname
-        config.service_port,
-        service_name(config.service_name),
-        ip_format
-      )
-      ::Trace.sample_rate = config.sample_rate
-
-      @config = config
     end
 
-    def call(env)
-      # skip certain requests
-      return @app.call(env) if filtered?(env) || !routable_request?(env)
+    private
 
-      whitelisted = force_sample?(env)
-      id = get_or_create_trace_id(env, whitelisted) # note that this depends on the sample rate being set
-      tracing_filter(id, env, whitelisted) { @app.call(env) }
+    def with_trace_id(trace_id, &block)
+      Trace.push(trace_id)
+      yield
+    ensure
+      Trace.pop
     end
 
-    private
-
-    # Use the Domain environment variable to extract the service name, otherwise use the default config name
-    def service_name(default_name)
-      ENV["DOMAIN"].to_s.empty? ? default_name : ENV["DOMAIN"].split('.').first
+    def record(annotation)
+      @tracer.record(@trace_id, annotation)
     end
 
     # If the request is not valid for this service, we do not what to trace it.
@@ -83,68 +65,87 @@ module ZipkinTracer
       false
     end
 
-    def annotate(env, status, response_headers, response_body)
+    def annotate_plugin(env, status, response_headers, response_body)
       @config.annotate_plugin.call(env, status, response_headers, response_body) if @config.annotate_plugin
     end
 
-    def filtered?(env)
-      @config.filter_plugin && !@config.filter_plugin.call(env)
-    end
-
-    def force_sample?(env)
-      @config.whitelist_plugin && @config.whitelist_plugin.call(env)
-    end
-
-    def tracing_filter(trace_id, env, whitelisted = false)
+    def trace!(trace_id, zipkin_env, &block)
       synchronize do
-        ::Trace.push(trace_id)
         #if called by a service, the caller already added the information
-        add_request_information(env) unless called_with_zipkin_headers?(env)
-        ::Trace.record(::Trace::Annotation.new(::Trace::Annotation::SERVER_RECV, ::Trace.default_endpoint))
-        ::Trace.record(::Trace::Annotation.new('whitelisted', ::Trace.default_endpoint)) if whitelisted
+        trace_request_information(trace_id, zipkin_env.env) unless zipkin_env.called_with_zipkin_headers?
+        @tracer.record(trace_id, Trace::Annotation.new(Trace::Annotation::SERVER_RECV, Trace.default_endpoint))
+        @tracer.record(trace_id, Trace::Annotation.new('whitelisted', Trace.default_endpoint)) if zipkin_env.force_sample?
       end
-      status, headers, body = yield if block_given?
+      status, headers, body = yield
     ensure
       synchronize do
-        annotate(env, status, headers, body)
-        ::Trace.record(::Trace::Annotation.new(::Trace::Annotation::SERVER_SEND, ::Trace.default_endpoint))
-        ::Trace.pop
+        annotate_plugin(zipkin_env.env, status, headers, body)
+        @tracer.record(trace_id, Trace::Annotation.new(Trace::Annotation::SERVER_SEND, Trace.default_endpoint))
       end
-      [status, headers, body]
-    end
-
-    def add_request_information(env)
-      ::Trace.set_rpc_name(env['REQUEST_METHOD'].to_s.downcase) # get/post and all that jazz
-      ::Trace.record(::Trace::BinaryAnnotation.new('http.uri', env['PATH_INFO'], 'STRING', ::Trace.default_endpoint))
     end
 
-    def called_with_zipkin_headers?(env)
-      B3_REQUIRED_HEADERS.all? { |key| env.has_key?(key) }
+    def trace_request_information(trace_id, env)
+      @tracer.set_rpc_name(trace_id, env['REQUEST_METHOD'].to_s.downcase) # get/post and all that jazz
+      @tracer.record(trace_id, Trace::BinaryAnnotation.new('http.uri', env['PATH_INFO'], 'STRING', Trace.default_endpoint))
     end
 
     def synchronize(&block)
       @lock.synchronize do
         yield
       end
-      # Nothing wonky that the tracer does should stop us from using the app!!!
-      # Usually is better to rescue StandardError but the socket layer can launch Errno kind of exceptions
-    rescue Exception => e
+    rescue => e
       @config.logger.error("Exception #{e.message} while sending Zipkin traces. #{e.backtrace}")
     end
 
-    def get_or_create_trace_id(env, whitelisted, default_flags = ::Trace::Flags::EMPTY)
-      trace_parameters = if called_with_zipkin_headers?(env)
-                           env.values_at(*B3_REQUIRED_HEADERS)
-                         else
-                           new_id = Trace.generate_id
-                           [new_id, nil, new_id, ('true' if whitelisted || Trace.should_sample?)]
-                         end
-      trace_parameters[3] = (trace_parameters[3] == 'true')
+    # Environment with Zipkin information in it
+    class ZipkinEnv
+      attr_reader :env
 
-      trace_parameters += env.values_at(*B3_OPT_HEADERS) # always check flags
-      trace_parameters[4] = (trace_parameters[4] || default_flags).to_i
+      def initialize(env, config)
+        @env    = env
+        @config = config
+      end
+
+      def trace_id(default_flags = Trace::Flags::EMPTY)
+        trace_parameters = if called_with_zipkin_headers?
+                             @env.values_at(*B3_REQUIRED_HEADERS)
+                           else
+                             new_id = Trace.generate_id
+                             [new_id, nil, new_id]
+                           end
+        trace_parameters[3] = should_trace?(trace_parameters[3])
+        trace_parameters += @env.values_at(*B3_OPT_HEADERS) # always check flags
+        trace_parameters[4] = (trace_parameters[4] || default_flags).to_i
+
+        Trace::TraceId.new(*trace_parameters)
+      end
+
+      def called_with_zipkin_headers?
+        @called_with_zipkin_headers ||= B3_REQUIRED_HEADERS.all? { |key| @env.has_key?(key) }
+      end
+
+      def force_sample?
+        @force_sample ||= @config.whitelist_plugin && @config.whitelist_plugin.call(@env)
+      end
+
+      private
 
-      Trace::TraceId.new(*trace_parameters)
+      def current_trace_sampled?
+        rand < @config.sample_rate
+      end
+
+      def should_trace?(parent_trace_sampled)
+        if parent_trace_sampled  # A service upstream decided this goes in all the way
+          parent_trace_sampled == 'true'
+        else
+          force_sample? || current_trace_sampled? && !filtered?
+        end
+      end
+
+      def filtered?
+        @config.filter_plugin && !@config.filter_plugin.call(@env)
+      end
     end
+
   end
 end

data/lib/zipkin-tracer/trace.rb

@@ -1,7 +1,14 @@
 require 'finagle-thrift'
 require 'finagle-thrift/trace'
+require 'zipkin-tracer/zipkin_tracer_base'
 
 module Trace
+
+  # We need this to access the tracer from the Faraday middleware.
+  def self.tracer
+    @tracer
+  end
+
   class Span
     def to_h
       {

data/lib/zipkin-tracer/tracer_factory.rb

@@ -0,0 +1,40 @@
+
+module ZipkinTracer
+  class TracerFactory
+    def tracer(config)
+      adapter = config.adapter
+
+      tracer = case adapter
+        when :json
+          require 'zipkin-tracer/zipkin_json_tracer'
+          options = { json_api_host: config.json_api_host, traces_buffer: config.traces_buffer, logger: config.logger }
+          Trace::ZipkinJsonTracer.new(options)
+        when :scribe
+          require 'zipkin-tracer/careless_scribe'
+          Trace::ZipkinTracer.new(CarelessScribe.new(config.scribe_server), config.scribe_max_buffer)
+        when :kafka
+          require 'zipkin-tracer/zipkin_kafka_tracer'
+          Trace::ZipkinKafkaTracer.new(zookeepers: config.zookeeper)
+        else
+          Trace::NullTracer.new
+      end
+      Trace.tracer = tracer
+
+      # TODO: move this to the TracerBase and kill scribe tracer
+      ip_format = config.adapter == :json ? :string : :i32
+      Trace.default_endpoint = Trace::Endpoint.make_endpoint(
+        nil, # auto detect hostname
+        config.service_port,
+        service_name(config.service_name),
+        ip_format
+      )
+      tracer
+    end
+
+    # Use the Domain environment variable to extract the service name, otherwise use the default config name
+    # TODO: move to the config object
+    def service_name(default_name)
+      ENV["DOMAIN"].to_s.empty? ? default_name : ENV["DOMAIN"].split('.').first
+    end
+  end
+end

data/lib/zipkin-tracer/version.rb

@@ -12,5 +12,5 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 module ZipkinTracer
-  VERSION = "0.9.1"
+  VERSION = "0.10.0"
 end

data/lib/zipkin-tracer/zipkin_json_tracer.rb

@@ -1,7 +1,7 @@
 require 'json'
-require 'faraday'
 require 'sucker_punch'
-require 'finagle-thrift/tracer'
+require 'zipkin-tracer/zipkin_tracer_base'
+
 
 class AsyncJsonApiClient
   include SuckerPunch::Job
@@ -19,55 +19,18 @@ class AsyncJsonApiClient
 end
 
 module Trace
-  class ZipkinJsonTracer < Tracer
-    TRACER_CATEGORY = "zipkin".freeze
-
-    def initialize(json_api_host, traces_buffer)
-      @json_api_host = json_api_host
-      @traces_buffer = traces_buffer
-      reset
-    end
-
-    def record(id, annotation)
-      return unless id.sampled?
-      span = get_span_for_id(id)
-
-      case annotation
-      when BinaryAnnotation
-        span.binary_annotations << annotation
-      when Annotation
-        span.annotations << annotation
-      end
-
-      @count += 1
-      if @count >= @traces_buffer || (annotation.is_a?(Annotation) && annotation.value == Annotation::SERVER_SEND)
-        flush!
-      end
-    end
-
-    def set_rpc_name(id, name)
-      return unless id.sampled?
-      span = get_span_for_id(id)
-      span.name = name.to_s
-    end
-
-    private
-
-    def get_span_for_id(id)
-      key = id.span_id.to_s
-      @spans[key] ||= begin
-        Span.new("", id)
-      end
-    end
-
-    def reset
-      @count = 0
-      @spans = {}
+  # This class sends information to the Zipkin API.
+  # The API accepts a JSON representation of a list of spans
+  class ZipkinJsonTracer < ZipkinTracerBase
+
+    def initialize(options)
+      SuckerPunch.logger = options[:logger]
+      @json_api_host = options[:json_api_host]
+      super(options)
     end
 
     def flush!
-      AsyncJsonApiClient.new.async.perform(@json_api_host, @spans.values.dup)
-      reset
+      AsyncJsonApiClient.new.async.perform(@json_api_host, spans.values.dup)
     end
   end
 end

data/lib/zipkin-tracer/zipkin_kafka_tracer.rb

@@ -2,64 +2,32 @@ require 'finagle-thrift'
 require 'finagle-thrift/tracer'
 require 'hermann/producer'
 require 'hermann/discovery/zookeeper'
+require 'zipkin-tracer/zipkin_tracer_base'
 
 module Trace
-  class ZipkinKafkaTracer < Tracer
-    TRACER_CATEGORY     = "zipkin".freeze
+  # This class sends information to Zipkin through Kafka.
+  # Spans are encoded using Thrift
+  class ZipkinKafkaTracer < ZipkinTracerBase
     DEFAULT_KAFKA_TOPIC = "zipkin_kafka".freeze
 
-    def initialize(opts={})
-      @logger = opts[:logger]
-      @topic  = opts[:topic] || DEFAULT_KAFKA_TOPIC
-      reset
-    end
-
-    # need to connect after initialization
-    def connect(zookeepers)
-      broker_ids = Hermann::Discovery::Zookeeper.new(zookeepers).get_brokers
+    def initialize(options = {})
+      @topic  = options[:topic] || DEFAULT_KAFKA_TOPIC
+      broker_ids = Hermann::Discovery::Zookeeper.new(options[:zookeepers]).get_brokers
       @producer  = Hermann::Producer.new(nil, broker_ids)
+      options[:traces_buffer] ||= 1  # Default in Kafka is sending as soon as possible. No buffer.
+      super(options)
     end
 
-    def record(id, annotation)
-      return unless id.sampled?
-      span = get_span_for_id(id)
-
-      case annotation
-      when BinaryAnnotation
-        span.binary_annotations << annotation
-      when Annotation
-        span.annotations << annotation
+    def flush!
+      messages = spans.values.map do |span|
+        buf = ''
+        trans = Thrift::MemoryBufferTransport.new(buf)
+        oprot = Thrift::BinaryProtocol.new(trans)
+        span.to_thrift.write(oprot)
+        @producer.push(buf, topic: @topic).value!
       end
-
-      flush!
-    end
-
-    def set_rpc_name(id, name)
-      return unless id.sampled?
-      span = get_span_for_id(id)
-      span.name = name.to_s
+    rescue Exception
+      # Ignore socket errors, etc
     end
-
-    private
-      def reset
-        @spans = {}
-      end
-
-      def get_span_for_id(id)
-        key = id.span_id.to_s
-        @spans[key] ||= begin
-          Span.new("", id)
-        end
-      end
-
-      def flush!
-        messages = @spans.values.map do |span|
-          buf = ''
-          trans = Thrift::MemoryBufferTransport.new(buf)
-          oprot = Thrift::BinaryProtocol.new(trans)
-          span.to_thrift.write(oprot)
-          @producer.push(buf, :topic => @topic).value!
-        end
-      end
   end
-end
+end

data/lib/zipkin-tracer/zipkin_tracer_base.rb

@@ -0,0 +1,71 @@
+require 'faraday'
+require 'finagle-thrift'
+require 'finagle-thrift/tracer'
+
+module Trace
+  # This class is a base for tracers sending information to Zipkin.
+  # It knows about zipkin types of annotations and send traces when the server
+  # is done with its request
+  # Traces dealing with zipkin should inherit from this class and implement the
+  # flush! method which actually sends the information
+  class ZipkinTracerBase < Tracer
+    TRACER_CATEGORY = "zipkin".freeze
+
+    def initialize(options={})
+      @options = options
+      @traces_buffer = options[:traces_buffer] || raise(ArgumentError, 'A proper buffer must be setup for the Zipkin tracer')
+      reset
+    end
+
+    def record(id, annotation)
+      span = get_span_for_id(id)
+
+      case annotation
+      when BinaryAnnotation
+        span.binary_annotations << annotation
+      when Annotation
+        span.annotations << annotation
+      end
+      count = current_count
+      set_current_count(count + 1)
+
+      if current_count >= @traces_buffer || (annotation.is_a?(Annotation) && annotation.value == Annotation::SERVER_SEND)
+        flush!
+        reset
+      end
+    end
+
+    def set_rpc_name(id, name)
+      span = get_span_for_id(id)
+      span.name = name.to_s
+    end
+
+    def flush!
+      raise "not implemented"
+    end
+
+    private
+
+    def spans
+      Thread.current[:zipkin_spans] ||= {}
+    end
+
+    def current_count
+      Thread.current[:zipkin_spans_count] ||= 0
+    end
+
+    def set_current_count(count)
+      Thread.current[:zipkin_spans_count] = count
+    end
+
+    def get_span_for_id(id)
+      key = id.span_id.to_s
+      spans[key] ||= Span.new("", id)
+    end
+
+    def reset
+      Thread.current[:zipkin_spans] = {}
+      set_current_count(0)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zipkin-tracer
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.10.0
 platform: ruby
 authors:
 - Franklin Hu
@@ -13,7 +13,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-16 00:00:00.000000000 Z
+date: 2015-12-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: finagle-thrift
@@ -99,20 +99,6 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '10.0'
-- !ruby/object:Gem::Dependency
-  name: pry
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '0.10'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '0.10'
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
@@ -201,9 +187,11 @@ files:
 - lib/zipkin-tracer/faraday/zipkin-tracer.rb
 - lib/zipkin-tracer/rack/zipkin-tracer.rb
 - lib/zipkin-tracer/trace.rb
+- lib/zipkin-tracer/tracer_factory.rb
 - lib/zipkin-tracer/version.rb
 - lib/zipkin-tracer/zipkin_json_tracer.rb
 - lib/zipkin-tracer/zipkin_kafka_tracer.rb
+- lib/zipkin-tracer/zipkin_tracer_base.rb
 homepage: https://github.com/openzipkin/zipkin-tracer
 licenses: []
 metadata: {}