opentracing-instrumentation 0.1.14 → 0.1.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0deff013f5e114188fd45e5babe206deb828806074e5d5cdb64d2d0bd12039b9
-  data.tar.gz: b9db37bc148a276e95f6b9b843c8524ac0fcb81b9a136aa9e95532f7d18f9d25
+  metadata.gz: b1d6a7f7070f79e0d57f243777fa02a2b8ac6d289b1f5bf54a3c47c171f86603
+  data.tar.gz: fb4a1c4b4260c32be8e5b12b6cc48eec27cdf7bf220cb6bb82fba9fd7ed45b3d
 SHA512:
-  metadata.gz: 7dac1db7d02ba70d447d2db46f28b31a2549e2d9636a9ead1013940af8e9338d5d75dfa6ce86a6d71b8eabbc26f17119be80b1110a9b0ccc3be8013f237b78a9
-  data.tar.gz: c604dfdd5b4f0e77f7bb5c29cc3a2c11e77540e6d8c69b901509af2f89c48575d6ff57cdc44d97e4f52ad4815a842684a16a723bfa874daa4ec9735fbc043e11
+  metadata.gz: 11b622db2d6df23aaa474cb5ad37a34c5a2bcd9136e92c0d966b9c36bc8cbea7ee5c3d85d31e47ceb44010dbc487b94042dedb23cf505d51ee2c1a9b8e5e700c
+  data.tar.gz: 1623f9d0ca9a70ce161db8c9350cc3228932aa24e1367b0e2beb069b920747eeffd406c34b9949c08ab0f11371a033d0202e593aa2b0c12d72c18f06bb593032

data/GEM_VERSION

@@ -1 +1 @@
-0.1.14
+0.1.15

data/Gemfile.lock

@@ -18,7 +18,7 @@ GIT
 PATH
   remote: .
   specs:
-    opentracing-instrumentation (0.1.14)
+    opentracing-instrumentation (0.1.15)
       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/rack/extract_middleware.rb

@@ -18,15 +18,21 @@ module OpenTracing
 
         # @param app [RackApp] inner rack application
         # @param tracer [OpenTracing::Tracer]
-        def initialize(app, tracer: OpenTracing.global_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 unless span_context
+          return @app.call(env) unless span_context
 
           with_scope(span_context) do
             @app.call(env)
@@ -36,12 +42,25 @@ module OpenTracing
         private
 
         def with_scope(span_context)
-          fake_span = FakeSpan.new(span_context)
-          scope = @tracer.scope_manager.activate(fake_span, finish_on_close: false)
+          scope = safe_create_scope(span_context)
 
           yield
         ensure
-          scope.close
+          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

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_reader :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.14
+  version: 0.1.15
 platform: ruby
 authors:
 - Fedorenko Dmitrij
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-04-02 00:00:00.000000000 Z
+date: 2020-04-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -320,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