opentracing-instrumentation 0.1.11 → 0.1.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 20f3950f2e40465d4758cd48491a59cd3b6bd46371cbd53f4f4b3b2fa6d58ffe
-  data.tar.gz: d1fce50ac04f282113711fa3dc6658309df23b1f572ecc423bdf64e6b56ff0b6
+  metadata.gz: f70d5c2d46c230465ea78fc83db7690a40647f16bc22e4290838993828247cd9
+  data.tar.gz: '097e36d147eca7b17a44bcd7ba1e427fc472af82f3a276a93f92e4c9bfd3592f'
 SHA512:
-  metadata.gz: a55c3242806bae23d495ffbe5b90b2f54383214350824a3a059e7d2c0f2eef0960b754c9926ba07c6d5603a4686416404e242c882cd8dfa0cb8671588b14e0f7
-  data.tar.gz: 0ea4451a818e76213759257778a6ceee3538a08a8b5b2be8cf560eb18cacf6371b124eb8e96edea2b7d889d7b154b0d6a300d8bc36a42ba6ac95ff5255a58717
+  metadata.gz: b77c0678115a4ef11986fb2596ea844315474b0c4301d53c33aae33d30f35b02a55658089ecd46a9b8be060681c5f5dbe7bcffeec8cffcfd360f8b2d2624ebcf
+  data.tar.gz: acf108f2e70b483cb313aa5c0b2780b765fcf9896c4c4f7a80042322bca9e7695d6045c8fbd9a84df686525141be9dcd872baae55e540557cdf4650006a6f1ad

data/GEM_VERSION

@@ -1 +1 @@
-0.1.11
+0.1.16

data/Gemfile.lock

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

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/mongo/trace_subscriber.rb

@@ -10,19 +10,16 @@ module OpenTracing
       class TraceSubscriber
         include Forwardable
 
-        DEFAULT_OPERATION_NAME_PATTERN = \
-          'mongo(collection=%<database>s.%<collection>s, command=%<command>s)'
-
         def initialize(
           tracer: OpenTracing.global_tracer,
           scope_store: {},
-          operation_name_pattern: DEFAULT_OPERATION_NAME_PATTERN,
+          operation_name_builder: OperationNameBuilder.new,
           sanitazer: QuerySanitazer.new
         )
           @tracer = tracer
           @monitor = Monitor.new
           @scope_store = scope_store
-          @operation_name_pattern = operation_name_pattern
+          @operation_name_builder = operation_name_builder
           @sanitazer = sanitazer
         end
 
@@ -49,18 +46,11 @@ module OpenTracing
         attr_reader :tracer
         attr_reader :scope_store
         attr_reader :monitor
-        attr_reader :operation_name_pattern
+        attr_reader :operation_name_builder
         attr_reader :sanitazer
 
         def build_operation_name(event)
-          command_name = event.command_name
-          collection_name = event.command[command_name]
-          format(
-            operation_name_pattern,
-            database: event.database_name,
-            collection: collection_name,
-            command: command_name,
-          )
+          operation_name_builder.build_operation_name(event)
         end
 
         def base_tags(event)

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

@@ -62,6 +62,8 @@ module OpenTracing
 
         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.11
+  version: 0.1.16
 platform: ruby
 authors:
 - Fedorenko Dmitrij
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-04-01 00:00:00.000000000 Z
+date: 2020-04-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -301,6 +301,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 +320,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