opentracing-instrumentation 0.1.15 → 0.2.1

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/faraday/response_logger.rb

@@ -20,10 +20,10 @@ module OpenTracing
           content_type: 'Content-Type',
         }.freeze
 
-        attr_reader :request_tag_headers
-        attr_reader :request_log_headers
-        attr_reader :response_tag_headers
-        attr_reader :response_log_headers
+        attr_reader :request_tag_headers,
+                    :request_log_headers,
+                    :response_tag_headers,
+                    :response_log_headers
 
         def initialize(
           request_log_headers: DEFAULT_REQUEST_LOG_HEADERS,

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

@@ -193,7 +193,7 @@ module OpenTracing
             event: 'error',
             message: error.message,
             'error.kind': error.class.to_s,
-            'stack': error.backtrace,
+            stack: error.backtrace,
           )
         end
       end

data/lib/opentracing/instrumentation/hutch.rb

@@ -12,17 +12,17 @@ module OpenTracing
       module_path = 'opentracing/instrumentation/hutch'
 
       autoload :ConsumeOperationNameBuilder,
-               module_path + '/consume_operation_name_builder'
+               "#{module_path}/consume_operation_name_builder"
       autoload :ConsumeTagsBuilder,
-               module_path + '/consume_tags_builder'
+               "#{module_path}/consume_tags_builder"
       autoload :ConsumeTracer,
-               module_path + '/consume_tracer'
+               "#{module_path}/consume_tracer"
       autoload :ConsumeTracerBuilder,
-               module_path + '/consume_tracer_builder'
+               "#{module_path}/consume_tracer_builder"
       autoload :ConsumeTracerConfig,
-               module_path + '/consume_tracer_config'
+               "#{module_path}/consume_tracer_config"
       autoload :GlobalPropertiesBuilder,
-               module_path + '/global_properties_builder'
+               "#{module_path}/global_properties_builder"
     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,10 +19,15 @@ module OpenTracing
         DEFAULT_EXCLUDE_KEYS = %w[lsid].freeze
 
         def initialize(
+          safety_argument_checker: SampleSafetyArgumentChecker.new,
           safe_classes: DEFAULT_SAFE_CLASSES,
+          max_array_size: 4,
           exclude_keys: DEFAULT_EXCLUDE_KEYS
         )
+          super()
+          @safety_argument_checker = safety_argument_checker
           @safe_classes = safe_classes
+          @max_array_size = max_array_size
           @exclude_keys = exclude_keys
         end
 
@@ -36,8 +41,10 @@ module OpenTracing
 
         private
 
-        attr_reader :safe_classes
-        attr_reader :exclude_keys
+        attr_reader :safe_classes,
+                    :exclude_keys,
+                    :max_array_size,
+                    :safety_argument_checker
 
         OBJECT_ID_PLACEHOLDER = '$oid'
         STRING_PLACEHOLDER = '$string'
@@ -54,30 +61,66 @@ module OpenTracing
           end
         end
 
+        # rubocop:disable Metrics/MethodLength
         def sanitaze_simple(value)
           case value
           when BSON::ObjectId
             OBJECT_ID_PLACEHOLDER
           when String
             STRING_PLACEHOLDER
+          when ArrayItemPlaceholder
+            value.to_s
           when *safe_classes
             value
           else
             PLACEHOLDER
           end
         end
+        # rubocop:enable Metrics/MethodLength
 
         def sanitaze_hash(hash)
-          hash.transform_values do |value|
-            sanitaze_value(value)
+          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
+
+        # Placehoder for skipped array items
+        class ArrayItemPlaceholder
+          def initialize(skipped_items)
+            @skipped_items = skipped_items
+          end
+
+          def to_s
+            "SKIPPED #{@skipped_items} ITEMS"
           end
         end
 
         def sanitaze_array(array)
-          array.map do |value|
+          if max_array_size&.positive? && array.size > max_array_size
+            array_with_placeholder(array)
+          else
+            array
+          end.map do |value|
             sanitaze_value(value)
           end
         end
+
+        def array_with_placeholder(array)
+          prefix_size = (max_array_size / 2).ceil
+          suffix_size = max_array_size - prefix_size
+          array[0...prefix_size] \
+            + [ArrayItemPlaceholder.new(array.size - max_array_size)] \
+            + array[-suffix_size..-1]
+        end
       end
     end
   end

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/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