opentracing-instrumentation 0.1.14 → 0.2.0

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

@@ -43,11 +43,11 @@ module OpenTracing
 
         private
 
-        attr_reader :tracer
-        attr_reader :scope_store
-        attr_reader :monitor
-        attr_reader :operation_name_builder
-        attr_reader :sanitazer
+        attr_reader :tracer,
+                    :scope_store,
+                    :monitor,
+                    :operation_name_builder,
+                    :sanitazer
 
         def build_operation_name(event)
           operation_name_builder.build_operation_name(event)

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/rack/http_tagger.rb

@@ -50,15 +50,15 @@ module OpenTracing
 
         def prepare_request_mapping(source_mapping)
           source_mapping.map do |key, header|
-            rack_header = 'HTTP_' + header.tr('-', '_').upcase
-            tag_name = 'http.request.' + key.to_s
+            rack_header = "HTTP_#{header.tr('-', '_').upcase}"
+            tag_name = "http.request.#{key}"
             [tag_name, rack_header]
           end.to_h
         end
 
         def prepare_response_mapping(source_mapping)
           source_mapping.map do |key, header|
-            tag_name = 'http.response.' + key.to_s
+            tag_name = "http.response.#{key}"
             header_regexp = /^#{header}$/i
             [tag_name, header_regexp]
           end.to_h

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

@@ -36,10 +36,10 @@ module OpenTracing
 
         private
 
-        attr_reader :app
-        attr_reader :http_tagger
-        attr_reader :tracer
-        attr_reader :logger
+        attr_reader :app,
+                    :http_tagger,
+                    :tracer,
+                    :logger
 
         def trace_request(env)
           extracted_ctx = tracer.extract(OpenTracing::FORMAT_RACK, env)
@@ -84,7 +84,7 @@ module OpenTracing
         def set_header_tags(span, headers)
           http_tagger
             .response_tags(headers)
-            .each(&span.method(:set_tag))
+            .each { |(key, value)| span.set_tag(key, value) }
         end
 
         def error_tag(span, error)

data/lib/opentracing/instrumentation/redis/config.rb

@@ -14,11 +14,11 @@ module OpenTracing
         DEFAULT_LOG_REPLY = false
         DEFAULT_COMPONENT = 'kv'
 
-        attr_accessor :tracer
-        attr_accessor :operation_name_pattern
-        attr_accessor :log_args
-        attr_accessor :log_reply
-        attr_accessor :component
+        attr_accessor :tracer,
+                      :operation_name_pattern,
+                      :log_args,
+                      :log_reply,
+                      :component
 
         def initialize(
           tracer: OpenTracing.global_tracer,

data/lib/opentracing/instrumentation/redis/tracing_driver_wrapper.rb

@@ -35,8 +35,8 @@ module OpenTracing
           end
         end
 
-        attr_reader :connection
-        attr_reader :span_builder
+        attr_reader :connection,
+                    :span_builder
 
         def initialize(
           connection:,
@@ -80,8 +80,8 @@ module OpenTracing
 
         private
 
-        attr_reader :pipeline_scope
-        attr_reader :error_writer
+        attr_reader :pipeline_scope,
+                    :error_writer
 
         def peer_addr
           "#{@host}:#{@port}"

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

@@ -7,41 +7,66 @@ module OpenTracing
       class ClientMiddleware
         extend Forwardable
 
-        DEFAULT_SPAN_NAME = 'sidekiq_enqueue'
         DEFAULT_SPAN_KIND = 'producer'
 
-        attr_reader :tracer
-        attr_reader :tagger
-        attr_reader :error_writter
-        attr_reader :span_kind
-        attr_reader :span_name
+        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,
+                    :tagger,
+                    :error_writter,
+                    :logger,
+                    :span_kind,
+                    :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))
+        def call(_worker_class, job, _queue, _redis_pool, &block)
+          scope = safe_start_scope(job)
           inject(scope.span.context, job)
-          log(scope.span, job) do
-            yield
-          end
+          log(scope.span, job, &block)
         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 +76,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

@@ -12,8 +12,8 @@ module OpenTracing
 
         DEFAULT_COMPONENT = 'sidekiq'
 
-        attr_accessor :component
-        attr_accessor :log_args
+        attr_accessor :component,
+                      :log_args
 
         # @param component [String] component name
         # @param log_args [TrueClass, FalseClass] enable attribute logging
@@ -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,66 @@ module OpenTracing
       class ServerMiddleware
         extend Forwardable
 
-        DEFAULT_SPAN_NAME = 'sidekiq_perform'
         DEFAULT_SPAN_KIND = 'consumer'
 
-        attr_reader :tracer
-        attr_reader :tagger
-        attr_reader :error_writter
-        attr_reader :span_kind
-        attr_reader :span_name
+        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,
+                    :tagger,
+                    :error_writter,
+                    :logger,
+                    :span_kind,
+                    :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))
+        def call(_worker, job, _queue, &block)
+          scope = safe_start_scope(job)
 
-          log(scope.span, job) do
-            yield
-          end
+          log(scope.span, job, &block)
         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 +81,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,16 +15,24 @@ 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'
+               "#{module_path}/traced_protocol"
       autoload :TracedProtocolConfig,
-               module_path + '/traced_protocol_config'
+               "#{module_path}/traced_protocol_config"
       autoload :TracedProtocolFactory,
-               module_path + '/traced_protocol_factory'
+               "#{module_path}/traced_protocol_factory"
       autoload :TracedProtocolOperationNameBuilder,
-               module_path + '/traced_protocol_operation_name_builder'
+               "#{module_path}/traced_protocol_operation_name_builder"
       autoload :TracedProtocolTagsBuilder,
-               module_path + '/traced_protocol_tags_builder'
+               "#{module_path}/traced_protocol_tags_builder"
     end
   end
 end

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,
+                    :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