opentracing-instrumentation 0.1.12 → 0.1.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd919364755be5176b14065ad63391a3c174bbc89f4237f9ada6cebdf58708c8
-  data.tar.gz: e881a287f27ff64fa4f11964e8c64ecb400806d6b561d88121b774013d43fa9f
+  metadata.gz: 9ca5229070a9ceefdba01deafe855a8c506018111a073bc627f52b77e67ec07b
+  data.tar.gz: 7afb446993601e8fa9df04c0fca0537495b7125724449c6eab721a45c5e7e5cc
 SHA512:
-  metadata.gz: 2ddd454b05a2b5cb7328e71b2abb3a900c8c743b6cbae1ac2ba0f427635bb647e2bef205296f6019d0e3259f613d656a15f5e726fd4c3e347ade9c6640b4c44f
-  data.tar.gz: bbf9d987a30edd479213ce41aa732848b5df4c5ab50d6213d006fa2e0d5f797163cf67f076ef56631b67a29239afeb651f511d9dbb36557db7cfda1d812aa827
+  metadata.gz: 2ff9411175de0c6b489c05da90e068cc85c4ba177f17bea72658b51ec6258935fdc0b264e4577d64a0ecfc04cb670085ea438c0ff04485f4e97bd3de9008d902
+  data.tar.gz: 1058ed6b1b347a9a596a8e76e14a3822b51cf6b0911fe05f03933dee533db10cd3fd138f3d659523ee907c5cf8b394ef1251bb1332a6705ad306c3e50e3fb297

data/GEM_VERSION

@@ -1 +1 @@
-0.1.12
+0.1.17

data/Gemfile.lock

@@ -18,7 +18,7 @@ GIT
 PATH
   remote: .
   specs:
-    opentracing-instrumentation (0.1.12)
+    opentracing-instrumentation (0.1.17)
       json
       opentracing (~> 0.5.0)
 

data/lib/opentracing/instrumentation/common.rb

@@ -8,6 +8,8 @@ module OpenTracing
     module Common
       autoload :ErrorWriter,
                'opentracing/instrumentation/common/error_writer'
+      autoload :OperationNameBuilder,
+               'opentracing/instrumentation/common/operation_name_builder'
     end
   end
 end

data/lib/opentracing/instrumentation/common/error_writer.rb

@@ -32,6 +32,11 @@ module OpenTracing
           log_error(span, exception, event)
         end
 
+        def ==(other)
+          set_error_tag == other.set_error_tag &&
+            log_error_event == other.log_error_event
+        end
+
         private
 
         def tag_error(span)

data/lib/opentracing/instrumentation/common/operation_name_builder.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module OpenTracing
+  module Instrumentation
+    module Common
+      # Build operation name by template and tags
+      class OperationNameBuilder
+        def initialize(operation_name_template:)
+          @operation_name_template = operation_name_template
+        end
+
+        # build operation name with tags
+        def build(tags)
+          format(operation_name_template, **tags)
+        end
+
+        private
+
+        attr_reader :operation_name_template
+      end
+    end
+  end
+end

data/lib/opentracing/instrumentation/mongo/operation_name_builder.rb

@@ -18,7 +18,6 @@ module OpenTracing
         # @param event [Mongo::Monitoring::Event::CommandStarted]
         # @return [String] formated command name
         def build_operation_name(event)
-          p '-' * 100
           format_args = build_format_args(event)
           format(operation_name_pattern, **format_args)
         end

data/lib/opentracing/instrumentation/rack.rb

@@ -4,6 +4,8 @@ module OpenTracing
   module Instrumentation
     # Rack tracing middlewares
     module Rack
+      autoload :ExtractMiddleware,
+               'opentracing/instrumentation/rack/extract_middleware'
       autoload :HttpTagger, 'opentracing/instrumentation/rack/http_tagger'
       autoload :RegexpHostSanitazer,
                'opentracing/instrumentation/rack/regexp_host_sanitazer'

data/lib/opentracing/instrumentation/rack/extract_middleware.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'rack'
+
+module OpenTracing
+  module Instrumentation
+    module Rack
+      # ExtractMiddleware extract trace context and push it to scope manager.
+      class ExtractMiddleware
+        # @private
+        class FakeSpan
+          attr_reader :context
+
+          def initialize(context)
+            @context = context
+          end
+        end
+
+        # @param app [RackApp] inner rack application
+        # @param tracer [OpenTracing::Tracer]
+        # @param logger [Logger]
+        def initialize(
+          app,
+          tracer: OpenTracing.global_tracer,
+          logger: nil
+        )
+          @app = app
+          @tracer = tracer
+          @logger = logger
+        end
+
+        # @param env [Hash<String, String>] rack env
+        def call(env)
+          span_context = @tracer.extract(OpenTracing::FORMAT_RACK, env)
+          return @app.call(env) unless span_context
+
+          with_scope(span_context) do
+            @app.call(env)
+          end
+        end
+
+        private
+
+        def with_scope(span_context)
+          scope = safe_create_scope(span_context)
+
+          yield
+        ensure
+          safe_close_scope(scope)
+        end
+
+        def safe_create_scope(span_context)
+          fake_span = FakeSpan.new(span_context)
+          @tracer.scope_manager.activate(fake_span, finish_on_close: false)
+        rescue StandardError => e
+          @logger&.error(e)
+          nil
+        end
+
+        def safe_close_scope(scope)
+          scope&.close
+        rescue StandardError => e
+          @logger&.error(e)
+        end
+      end
+    end
+  end
+end

data/lib/opentracing/instrumentation/sidekiq/client_middleware.rb

@@ -7,41 +7,68 @@ module OpenTracing
       class ClientMiddleware
         extend Forwardable
 
-        DEFAULT_SPAN_NAME = 'sidekiq_enqueue'
         DEFAULT_SPAN_KIND = 'producer'
 
+        DEFAULT_OPERATION_NAME_TEMPLATE = \
+          'sidekiq_enqueue(%<sidekiq.class>s)'
+        DEFAULT_OPERATION_NAME_BUILDER = \
+          Common::OperationNameBuilder.new(
+            operation_name_template: DEFAULT_OPERATION_NAME_TEMPLATE,
+          )
+
         attr_reader :tracer
         attr_reader :tagger
         attr_reader :error_writter
+        attr_reader :logger
         attr_reader :span_kind
-        attr_reader :span_name
+        attr_reader :operation_name_builder
 
+        # rubocop:disable Metrics/ParameterLists
         def initialize(
           tracer: OpenTracing.global_tracer,
           tagger: JobTagger.new,
           error_writter: Common::ErrorWriter.new,
+          logger: nil,
           span_kind: DEFAULT_SPAN_KIND,
-          span_name: DEFAULT_SPAN_NAME
+          operation_name_builder: DEFAULT_OPERATION_NAME_BUILDER
         )
           @tracer = tracer
           @tagger = tagger
           @error_writter = error_writter
+          @logger = logger
           @span_kind = span_kind
-          @span_name = span_name
+          @operation_name_builder = operation_name_builder
         end
+        # rubocop:enable Metrics/ParameterLists
 
         def call(_worker_class, job, _queue, _redis_pool)
-          scope = tracer.start_active_span(span_name, **build_span_args(job))
+          scope = safe_start_scope(job)
           inject(scope.span.context, job)
           log(scope.span, job) do
             yield
           end
         ensure
-          scope.close
+          safe_close_scope(scope)
         end
 
         private
 
+        def safe_start_scope(job)
+          tags = build_tags(job)
+          operation_name = operation_name_builder.build(tags)
+          tracer.start_active_span(operation_name, tags: tags)
+        rescue StandardError => e
+          logger&.error(e)
+        end
+
+        def safe_close_scope(scope)
+          return unless scope
+
+          scope.close
+        rescue StandardError => e
+          logger&.error(e)
+        end
+
         def log(span, job)
           tagger.write_args_log(span, job['jid'], job['args'])
 
@@ -51,10 +78,8 @@ module OpenTracing
           raise
         end
 
-        def build_span_args(job)
-          {
-            tags: tagger.build_tags(job, span_kind),
-          }
+        def build_tags(job)
+          tagger.build_tags(job, span_kind)
         end
 
         def inject(span_context, carrier)

data/lib/opentracing/instrumentation/sidekiq/job_tagger.rb

@@ -30,11 +30,11 @@ module OpenTracing
         # build tags from job data and static attributes
         def build_tags(job, span_kind)
           {
-            'component' => component,
-            'span.kind' => span_kind,
-            'sidekiq.queue' => job['queue'],
-            'sidekiq.class' => job['class'],
-            'sidekiq.retry' => job['retry'],
+            component: component,
+            'span.kind': span_kind,
+            'sidekiq.queue': job['queue'],
+            'sidekiq.class': job['class'],
+            'sidekiq.retry': job['retry'],
           }
         end
 

data/lib/opentracing/instrumentation/sidekiq/server_middleware.rb

@@ -9,41 +9,68 @@ module OpenTracing
       class ServerMiddleware
         extend Forwardable
 
-        DEFAULT_SPAN_NAME = 'sidekiq_perform'
         DEFAULT_SPAN_KIND = 'consumer'
 
+        DEFAULT_OPERATION_NAME_TEMPLATE = \
+          'sidekiq_perform(%<sidekiq.class>s)'
+        DEFAULT_OPERATION_NAME_BUILDER = \
+          Common::OperationNameBuilder.new(
+            operation_name_template: DEFAULT_OPERATION_NAME_TEMPLATE,
+          )
+
         attr_reader :tracer
         attr_reader :tagger
         attr_reader :error_writter
+        attr_reader :logger
         attr_reader :span_kind
-        attr_reader :span_name
+        attr_reader :operation_name_builder
 
+        # rubocop:disable Metrics/ParameterLists
         def initialize(
           tracer: OpenTracing.global_tracer,
           tagger: JobTagger.new,
           error_writter: Common::ErrorWriter.new,
+          logger: nil,
           span_kind: DEFAULT_SPAN_KIND,
-          span_name: DEFAULT_SPAN_NAME
+          operation_name_builder: DEFAULT_OPERATION_NAME_BUILDER
         )
           @tracer = tracer
           @tagger = tagger
           @error_writter = error_writter
+          @logger = logger
           @span_kind = span_kind
-          @span_name = span_name
+          @operation_name_builder = operation_name_builder
         end
+        # rubocop:enable Metrics/ParameterLists
 
         def call(_worker, job, _queue)
-          scope = tracer.start_active_span(span_name, **build_span_args(job))
+          scope = safe_start_scope(job)
 
           log(scope.span, job) do
             yield
           end
         ensure
-          scope.close
+          scope&.close
         end
 
         private
 
+        def safe_start_scope(job)
+          tags =  tagger.build_tags(job, span_kind)
+          operation_name = operation_name_builder.build(tags)
+          tracer.start_active_span(operation_name, tags: tags, **build_span_args(job))
+        rescue StandardError => e
+          logger&.error(e)
+        end
+
+        def safe_close_scope(scope)
+          return unless socpe
+
+          scope.close
+        rescue StandardError => e
+          logger&.error(e)
+        end
+
         def log(span, job)
           tagger.write_args_log(span, job['jid'], job['args'])
 
@@ -56,12 +83,13 @@ module OpenTracing
         def build_span_args(job)
           {
             references: extract_references(job),
-            tags: tagger.build_tags(job, span_kind),
           }
         end
 
         def extract_references(job)
           span_context = tracer.extract(OpenTracing::FORMAT_TEXT_MAP, job)
+          return unless span_context
+
           [OpenTracing::Reference.follows_from(span_context)]
         end
       end

data/lib/opentracing/instrumentation/thrift.rb

@@ -15,6 +15,14 @@ module OpenTracing
         ::Thrift::MessageTypes::ONEWAY => 'ONEWAY',
       }.freeze
 
+      autoload :TracedProcessor,
+               module_path + '/traced_processor'
+      autoload :TracedProcessorConfig,
+               module_path + '/traced_processor_config'
+      autoload :TracedProcessorOperationNameBuilder,
+               module_path + '/traced_processor_operation_name_builder'
+      autoload :TracedProcessorTagsBuilder,
+               module_path + '/traced_processor_tags_builder'
       autoload :TracedProtocol,
                module_path + '/traced_protocol'
       autoload :TracedProtocolConfig,

data/lib/opentracing/instrumentation/thrift/traced_processor.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module OpenTracing
+  module Instrumentation
+    module Thrift
+      # Trace thrift processor
+      #
+      # Usage:
+      #   processor =
+      #     OrderService::Processor.new(orders_handler)
+      #   traced_processor =
+      #     OpenTracing::Instrumentation::Thrift::TracedProcessor.new(processor)
+      class TracedProcessor
+        extend Forwardable
+
+        # @private
+        class ReadCachedProtocol
+          include ::Thrift::ProtocolDecorator
+
+          def read_message_begin
+            @read_message_begin ||= @protocol.read_message_begin
+          end
+
+          def ==(other)
+            @protocol == other.protocol
+          end
+
+          protected
+
+          attr_reader :protocol
+        end
+
+        # @parama processor [Thrift::Processor] traced processor
+        # @param config [TracedProcessorConfig]
+        # @yieldparam [TracedProcessorConfig]
+        def initialize(processor, config: TracedProcessorConfig.new)
+          @processor = processor
+          yield config if block_given?
+          @config = config.dup
+        end
+
+        # @param iproto [Thrift::Protocol] input protocol
+        # @param oproto [Thrift::Protocol] output protocol
+        def process(iproto, oproto)
+          trace_process(iproto) do |cached_iproto|
+            processor.process(
+              wrap_protocol(cached_iproto),
+              wrap_protocol(oproto),
+            )
+          end
+        end
+
+        private
+
+        attr_reader :processor
+        attr_reader :config
+
+        def_delegators :config,
+                       :tracer,
+                       :trace_protocol,
+                       :error_writer,
+                       :operation_name_builder,
+                       :tags_builder,
+                       :logger
+
+        def trace_process(iproto)
+          cached_iproto = ReadCachedProtocol.new(iproto)
+
+          start_time = Time.now
+
+          name, type, seq_id = cached_iproto.read_message_begin
+
+          scope = safe_start_scope(iproto, name, type, seq_id, start_time)
+
+          yield cached_iproto
+        rescue StandardError => e
+          error_writer.write_error(scope.span, e) if scope&.span
+          raise e
+        ensure
+          safe_close_scope(scope)
+        end
+
+        def safe_start_scope(protocol, name, type, seq_id, start_time)
+          operation_name = operation_name_builder.build(name, type, seq_id)
+          tags = tags_builder.build_tags(protocol, name, type)
+          tracer.start_active_span(
+            operation_name,
+            start_time: start_time,
+            tags: tags,
+          )
+        rescue StandardError => e
+          logger&.error(e)
+        end
+
+        def safe_close_scope(scope)
+          scope&.close
+        rescue StandardError => e
+          logger&.error(e)
+        end
+
+        def wrap_protocol(protocol)
+          return protocol unless trace_protocol
+
+          TracedProtocol.new(protocol) do |config|
+            config.tracer = tracer
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opentracing/instrumentation/thrift/traced_processor_config.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module OpenTracing
+  module Instrumentation
+    module Thrift
+      # Config of ThriftProcessor
+      class TracedProcessorConfig
+        # @return [OpenTracing::Tracer]
+        attr_accessor :tracer
+
+        # @return [Boolean] enabled wrap protocol into TracedProtocol
+        attr_accessor :trace_protocol
+
+        # @return [TracedProcessorOperationNameBuilder]
+        attr_accessor :operation_name_builder
+
+        # @return [TracedProcessorTagsBuilder]
+        attr_accessor :tags_builder
+
+        # @return [Common::ErrorWriter]
+        attr_accessor :error_writer
+
+        # @return [Logger] used for log errors. If nil (by default), then logging disabled,
+        attr_accessor :logger
+
+        def initialize
+          @tracer = OpenTracing.global_tracer
+          @trace_protocol = true
+          @operation_name_builder = TracedProcessorOperationNameBuilder.new
+          @tags_builder = TracedProcessorTagsBuilder.new
+          @error_writer = Common::ErrorWriter.new
+          @logger = nil
+        end
+      end
+    end
+  end
+end

data/lib/opentracing/instrumentation/thrift/traced_processor_operation_name_builder.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module OpenTracing
+  module Instrumentation
+    module Thrift
+      # Thrift processor trace operation name builder
+      class TracedProcessorOperationNameBuilder
+        DEFAULT_OPERATION_NAME_TEMPALTE = \
+          'thrift_processor(%<name>s)'
+
+        # @param operation_name_tempalte [String]
+        def initialize(
+          operation_name_template: DEFAULT_OPERATION_NAME_TEMPALTE
+        )
+          @operation_name_template = operation_name_template
+        end
+
+        # @param name [String] method name
+        # @param type [Integer] type of message
+        # @param seq_id [Integer] numberr of message
+        # @return [String] operation name
+        def build(name, type, seq_id)
+          format_args = build_format_args(name, type, seq_id)
+          format(operation_name_template, **format_args)
+        end
+
+        private
+
+        attr_reader :operation_name_template
+
+        def build_format_args(name, type, seq_id)
+          {
+            name: name,
+            type: MESSAGE_TYPES[type],
+            seq_id: seq_id,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/opentracing/instrumentation/thrift/traced_processor_tags_builder.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module OpenTracing
+  module Instrumentation
+    module Thrift
+      # Tags builder for TracedProcessor
+      class TracedProcessorTagsBuilder < TracedProtocolTagsBuilder
+        DEFAULT_STATIC_TAGS = {
+          'span.kind' => 'server',
+          'component' => 'thrift',
+        }.freeze
+
+        def initialize(static_tags: DEFAULT_STATIC_TAGS)
+          @static_tags = static_tags
+        end
+
+        def build_tags(protocol, name, type)
+          static_tags
+            .merge(build_protocol_tags(protocol))
+            .merge(build_message_tags(name, type))
+        end
+
+        private
+
+        attr_reader :static_tags
+      end
+    end
+  end
+end

data/lib/opentracing/instrumentation/thrift/traced_protocol.rb

@@ -33,26 +33,32 @@ module OpenTracing
           super(protocol)
           @config = config.dup
           yield @config if block_given?
-          @static_tags = config.tags_builder.build_static_tags(protocol)
+          @protocol_tags = config.tags_builder.build_protocol_tags(protocol)
+        end
+
+        def ==(other)
+          protocol == other.protocol &&
+            config == other.config &&
+            protocol_tags == other.protocol_tags
         end
 
         def write_message_begin(name, type, seqid)
-          self.write_scope = \
-            safe_start_active_span(WRITE_DIRECTION, name, type)
+          self.write_span = \
+            safe_start_span(WRITE_DIRECTION, name, type)
 
           # Call protocol instaed super, beacaus ProtocolDecorator do not
           # pass arguments to protocol.write_message_begin
           protocol.write_message_begin(name, type, seqid)
         rescue StandardError => e
-          write_error(write_scope&.span, e)
-          safe_close_span(write_scope)
+          write_error(write_span, e)
+          safe_close_span(write_span)
           raise e
         end
 
         def write_message_end
           super
         ensure
-          safe_close_span(write_scope)
+          safe_close_span(write_span)
         end
 
         def read_message_begin
@@ -60,9 +66,9 @@ module OpenTracing
 
           name, type, rseqid = super
 
-          self.read_scope = \
-            safe_start_active_span(READ_DIRECTION, name, type,
-                                   start_time: start_time)
+          self.read_span = \
+            safe_start_span(READ_DIRECTION, name, type,
+                            start_time: start_time)
 
           [name, type, rseqid]
         end
@@ -70,25 +76,28 @@ module OpenTracing
         def read_message_end
           super
         ensure
-          safe_close_span(read_scope)
+          safe_close_span(read_span)
         end
 
-        private
+        protected
 
-        attr_reader :static_tags
+        attr_reader :protocol_tags
         attr_reader :protocol
+        attr_reader :config
 
-        def_delegators :@config,
+        private
+
+        def_delegators :config,
                        :tracer,
                        :tags_builder,
                        :operation_name_builder,
                        :error_writer,
                        :logger
 
-        attr_accessor :write_scope,
-                      :read_scope
+        attr_accessor :write_span,
+                      :read_span
 
-        def safe_start_active_span(
+        def safe_start_span(
           direction,
           name,
           type,
@@ -97,7 +106,7 @@ module OpenTracing
           operation_name = build_operation_name(direction, name, type)
           request_tags = build_tags(name, type)
 
-          tracer.start_active_span(
+          tracer.start_span(
             operation_name,
             tags: request_tags,
             start_time: start_time,
@@ -106,10 +115,10 @@ module OpenTracing
           logger&.error(e)
         end
 
-        def safe_close_span(scope)
-          return if scope.nil?
+        def safe_close_span(span)
+          return if span.nil?
 
-          scope.close
+          span.finish
         rescue StandardError => e
           logger&.error(e)
         end
@@ -131,7 +140,7 @@ module OpenTracing
         end
 
         def build_tags(name, type)
-          static_tags
+          protocol_tags
             .merge(tags_builder.build_message_tags(name, type))
             .compact
         end

data/lib/opentracing/instrumentation/thrift/traced_protocol_config.rb

@@ -24,6 +24,13 @@ module OpenTracing
           @error_writer = error_writer
           @logger = logger
         end
+
+        def ==(other)
+          tracer == other.tracer &&
+            tags_builder == other.tags_builder &&
+            operation_name_builder == other.operation_name_builder &&
+            error_writer == other.error_writer
+        end
       end
     end
   end

data/lib/opentracing/instrumentation/thrift/traced_protocol_operation_name_builder.rb

@@ -10,8 +10,6 @@ module OpenTracing
         DEFAULT_OPERATION_NAME_PATTERN = \
           'thrift(direction=%<direction>s, name=%<name>s, type=%<type>s)'
 
-        attr_reader :operation_name_pattern
-
         # @param operation_name_pattern [String]
         def initialize(
           operation_name_pattern: DEFAULT_OPERATION_NAME_PATTERN
@@ -28,6 +26,14 @@ module OpenTracing
           format(operation_name_pattern, **format_args)
         end
 
+        def ==(other)
+          operation_name_pattern == other.operation_name_pattern
+        end
+
+        protected
+
+        attr_reader :operation_name_pattern
+
         private
 
         def build_format_args(direction, name, type)

data/lib/opentracing/instrumentation/thrift/traced_protocol_tags_builder.rb

@@ -17,7 +17,7 @@ module OpenTracing
           }.merge(error_tags(type))
         end
 
-        def build_static_tags(protocol)
+        def build_protocol_tags(protocol)
           transport = protocol.trans
           {
             'thrift.protocol' => build_protocol_name(protocol),
@@ -25,6 +25,10 @@ module OpenTracing
           }
         end
 
+        def ==(other)
+          self.class == other.class
+        end
+
         private
 
         NAME_PATTER = /((?<service_name>\w+):)?(?<method>\w+)/.freeze

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opentracing-instrumentation
 version: !ruby/object:Gem::Version
-  version: 0.1.12
+  version: 0.1.17
 platform: ruby
 authors:
 - Fedorenko Dmitrij
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-04-01 00:00:00.000000000 Z
+date: 2020-04-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -284,6 +284,7 @@ files:
 - lib/opentracing/instrumentation/bunny/regexp_routing_key_sanitazer.rb
 - lib/opentracing/instrumentation/common.rb
 - lib/opentracing/instrumentation/common/error_writer.rb
+- lib/opentracing/instrumentation/common/operation_name_builder.rb
 - lib/opentracing/instrumentation/faraday.rb
 - lib/opentracing/instrumentation/faraday/response_logger.rb
 - lib/opentracing/instrumentation/faraday/trace_middleware.rb
@@ -301,6 +302,7 @@ files:
 - lib/opentracing/instrumentation/mongo/trace_subscriber.rb
 - lib/opentracing/instrumentation/object_wrapper.rb
 - lib/opentracing/instrumentation/rack.rb
+- lib/opentracing/instrumentation/rack/extract_middleware.rb
 - lib/opentracing/instrumentation/rack/http_tagger.rb
 - lib/opentracing/instrumentation/rack/regexp_host_sanitazer.rb
 - lib/opentracing/instrumentation/rack/regexp_path_sanitazer.rb
@@ -319,6 +321,10 @@ files:
 - lib/opentracing/instrumentation/sinatra.rb
 - lib/opentracing/instrumentation/sinatra/trace_middleware.rb
 - lib/opentracing/instrumentation/thrift.rb
+- lib/opentracing/instrumentation/thrift/traced_processor.rb
+- lib/opentracing/instrumentation/thrift/traced_processor_config.rb
+- lib/opentracing/instrumentation/thrift/traced_processor_operation_name_builder.rb
+- lib/opentracing/instrumentation/thrift/traced_processor_tags_builder.rb
 - lib/opentracing/instrumentation/thrift/traced_protocol.rb
 - lib/opentracing/instrumentation/thrift/traced_protocol_config.rb
 - lib/opentracing/instrumentation/thrift/traced_protocol_factory.rb