opentracing-instrumentation 0.1.13 → 0.1.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6dd80093ca0c1a8cfc5b97e6c20e72440581970dee1941d97e77c9bb2c3ee449
-  data.tar.gz: ecf8fab0778ab5df7764a05495f84d2336a48c2ca382242727b26b9bd052e9dd
+  metadata.gz: 27eec95422a0be40785c0b5369e6a40a5de45399b263577824159b33fc681e1e
+  data.tar.gz: 8ad8c27eca4ba30b3995b771322904b9d11d034e2e07b4571d989042a51ef927
 SHA512:
-  metadata.gz: 03ca24d62c6c254e158bffabecc961dc7c945862f418f7324e6790538649d194c83a5373a9dacb28bcf4fc5153e0b298a3b65e04fbba69c3347297281e327a73
-  data.tar.gz: 5ec70cad41f48ab7f4c3f5875f8e743dd492d12fa13a583e1abfb5e1a64bd32278e0347b37d9844f4c0399a850037be235af63423983627e5fcfd461ef372622
+  metadata.gz: adbff7a43740935e4c5f6286f8ea1be501b6b6c9f8dce9b9cdc320da329b3c7bc29bb5697fed07ab178d28f2d8e85125474081dd8e1ecb0cf8562dc73fbfde58
+  data.tar.gz: 38618d53fc21fca58c21e9bee8b1fad7620f94604bab2470bb9d6df3dfdbdff56d89c335ab1b402f9ac8a3472dbf75b989548f07d2395a0e316ca04c0b537d6b

data/GEM_VERSION

@@ -1 +1 @@
-0.1.13
+0.1.18

data/Gemfile.lock

@@ -18,7 +18,7 @@ GIT
 PATH
   remote: .
   specs:
-    opentracing-instrumentation (0.1.13)
+    opentracing-instrumentation (0.1.18)
       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.rb

@@ -9,6 +9,8 @@ module OpenTracing
                'opentracing/instrumentation/mongo/operation_name_builder'
       autoload :TraceSubscriber, 'opentracing/instrumentation/mongo/trace_subscriber'
       autoload :QuerySanitazer, 'opentracing/instrumentation/mongo/query_sanitazer'
+      autoload :SampleSafetyArgumentChecker,
+               'opentracing/instrumentation/mongo/sample_safety_argument_checker'
     end
   end
 end

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

@@ -19,9 +19,11 @@ module OpenTracing
         DEFAULT_EXCLUDE_KEYS = %w[lsid].freeze
 
         def initialize(
+          safety_argument_checker: SampleSafetyArgumentChecker.new,
           safe_classes: DEFAULT_SAFE_CLASSES,
           exclude_keys: DEFAULT_EXCLUDE_KEYS
         )
+          @safety_argument_checker = safety_argument_checker
           @safe_classes = safe_classes
           @exclude_keys = exclude_keys
         end
@@ -38,6 +40,7 @@ module OpenTracing
 
         attr_reader :safe_classes
         attr_reader :exclude_keys
+        attr_reader :safety_argument_checker
 
         OBJECT_ID_PLACEHOLDER = '$oid'
         STRING_PLACEHOLDER = '$string'
@@ -68,9 +71,18 @@ module OpenTracing
         end
 
         def sanitaze_hash(hash)
-          hash.transform_values do |value|
-            sanitaze_value(value)
-          end
+          hash.map do |(key, value)|
+            # TODO: pass command name.
+            # TODO: recursive build path to key
+            safe_value =
+              if safety_argument_checker.argument_safe?(nil, key, value)
+                value
+              else
+                sanitaze_value(value)
+              end
+
+            [key, safe_value]
+          end.to_h
         end
 
         def sanitaze_array(array)

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module OpenTracing
+  module Instrumentation
+    module Mongo
+      # SampleSafetyArgumentChecker check argument to safety
+      # Draft implementation
+      class SampleSafetyArgumentChecker
+        DEFAULT_SAFE_ARGUMENTS = [
+          '$readPreference',
+          '$clusterTime',
+        ].freeze
+
+        attr_reader :safe_arguments
+
+        def initialize(safe_arguments: DEFAULT_SAFE_ARGUMENTS)
+          @safe_arguments = safe_arguments
+        end
+
+        # check
+        #
+        # @return (TrueClass, FalseClass) `true`, if argument safe and not
+        # not should be cleaned. Otherwise return `false``.
+        def argument_safe?(_command_name, argument_path, _argument_value)
+          safe_arguments.include?(argument_path)
+        end
+      end
+    end
+  end
+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.13
+  version: 0.1.18
 platform: ruby
 authors:
 - Fedorenko Dmitrij
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-04-01 00:00:00.000000000 Z
+date: 2020-09-17 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
@@ -298,9 +299,11 @@ files:
 - lib/opentracing/instrumentation/mongo/direct_sanitazer.rb
 - lib/opentracing/instrumentation/mongo/operation_name_builder.rb
 - lib/opentracing/instrumentation/mongo/query_sanitazer.rb
+- lib/opentracing/instrumentation/mongo/sample_safety_argument_checker.rb
 - 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 +322,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