opentracing-instrumentation 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: acb5d0dd01cab906babfd39d9ad99949eefcfa7f586c00883c0c9a606e66f642
-  data.tar.gz: 7051aa44a11889a29f33f853805734dc06efdc548e979fe83f8725a84d5f8b79
+  metadata.gz: 106a9dbe45448a23d7f3ae81c6088e48eeb3e5758b9092315d1c2e81ed3e27de
+  data.tar.gz: '0268cc6d0f0db99d52b447bda20115ea1fd04820ec14e2a59d8e941d29782797'
 SHA512:
-  metadata.gz: 784b8bb87a3a7e1b2ae054b32e3c3313d55809efcf567af1d72bd1d5a7f88e671450ea188e4d862bd5fd8bdc8cc8a8d29bcd4bcfd3ca6db41ee3aade85429a23
-  data.tar.gz: aff530e01d925b4dd77d587a37b48af25d57e51982ed25748621842b7c121422d7d3fe2cc35ebc2c5bd396708901c51927bc793dfaaa4fe2d0622a15dea33014
+  metadata.gz: 9292a2dd9483d8c34138eb68d5d4a8cd94cedc5d666d1df55a06af4acf7b1d4508deab4dc83436db798cd879cab1f6f9f014be0611b2efddf7a0990896a7ffaf
+  data.tar.gz: deb16198328e487a0d3200e6f5083c5c78ede07e3aaa75be1b25828ae2b817904cc39c268d39559f9518adc2c02108eb371a481bfc31ca7c48d0c357ac2be4ae

data/GEM_VERSION

@@ -1 +1 @@
-0.1.2
+0.1.3

data/Gemfile.lock

@@ -18,23 +18,43 @@ GIT
 PATH
   remote: .
   specs:
-    opentracing-instrumentation (0.1.1)
+    opentracing-instrumentation (0.1.3)
       json
       opentracing (~> 0.5.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    activesupport (5.2.4.2)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    amq-protocol (2.3.0)
     ast (2.4.0)
     bson (4.8.0)
+    bunny (2.14.4)
+      amq-protocol (~> 2.3, >= 2.3.0)
     byebug (11.1.1)
+    carrot-top (0.0.7)
+      json
     coderay (1.1.2)
+    concurrent-ruby (1.1.6)
     diff-lcs (1.3)
     faraday (0.9.2)
       multipart-post (>= 1.2, < 3)
+    hutch (0.26.0)
+      activesupport (>= 4.2, < 6)
+      bunny (>= 2.12, < 2.15)
+      carrot-top (~> 0.0.7)
+      multi_json (~> 1.12)
+    i18n (1.8.2)
+      concurrent-ruby (~> 1.0)
     jaro_winkler (1.5.4)
     json (2.3.0)
     method_source (0.9.2)
+    minitest (5.14.0)
+    multi_json (1.14.1)
     multipart-post (2.1.1)
     opentracing (0.5.0)
     parallel (1.19.1)
@@ -75,7 +95,10 @@ GEM
     rubocop-rspec (1.38.1)
       rubocop (>= 0.68.1)
     ruby-progressbar (1.10.1)
+    thread_safe (0.3.6)
     thrift (0.11.0.0)
+    tzinfo (1.2.6)
+      thread_safe (~> 0.1)
     unicode-display_width (1.6.1)
 
 PLATFORMS
@@ -84,7 +107,9 @@ PLATFORMS
 DEPENDENCIES
   bson (~> 4.0)
   bundler (= 2.1.4)
+  bunny (~> 2.0)
   faraday (~> 0.9.2)
+  hutch (~> 0.26.0)
   opentracing-instrumentation!
   pry-byebug (~> 3.8)
   rack (~> 2.2.2)

data/lib/opentracing/instrumentation.rb

@@ -19,5 +19,7 @@ module OpenTracing
     autoload :Thrift, 'opentracing/instrumentation/thrift'
     autoload :Redis, 'opentracing/instrumentation/redis'
     autoload :Sidekiq, 'opentracing/instrumentation/sidekiq'
+    autoload :Hutch, 'opentracing/instrumentation/hutch'
+    autoload :Bunny, 'opentracing/instrumentation/bunny'
   end
 end

data/lib/opentracing/instrumentation/bunny.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module OpenTracing
+  module Instrumentation
+    # Bunny tracing instrumentation
+    #
+    # @see ConsumeTracer
+    # @see PublishTracer
+    module Bunny
+      module_path = 'opentracing/instrumentation/bunny'
+
+      autoload :ConsumeOperationNameBuilder,
+               module_path + '/consume_operation_name_builder'
+      autoload :ConsumeTagsBuilder,
+               module_path + '/consume_tags_builder'
+      autoload :ConsumeTracer,
+               module_path + '/consume_tracer'
+      autoload :ConsumeTracerConfig,
+               module_path + '/consume_tracer_config'
+      autoload :HeadersBuilder,
+               module_path + '/headers_builder'
+      autoload :HeadersInjector,
+               module_path + '/headers_injector'
+      autoload :PublishOperationNameBuilder,
+               module_path + '/publish_operation_name_builder'
+      autoload :PublishTagsBuilder,
+               module_path + '/publish_tags_builder'
+      autoload :PublishTracer,
+               module_path + '/publish_tracer'
+      autoload :PublishTracerConfig,
+               module_path + '/publish_tracer_config'
+      autoload :RegexpRoutingKeySanitazer,
+               module_path + '/regexp_routing_key_sanitazer'
+    end
+  end
+end

data/lib/opentracing/instrumentation/bunny/consume_operation_name_builder.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module OpenTracing
+  module Instrumentation
+    module Bunny
+      # ConsumeOperationNameBuilder build consume command name from
+      # queue and delivery_info
+      class ConsumeOperationNameBuilder
+        DEFAULT_OPERATION_NAME_PATTERN = \
+          'bunny_consume(' \
+            'routing_key=%<routing_key>s, ' \
+            'exchange=%<exchange>s, ' \
+            'queue=%<queue>s' \
+          ')'
+
+        # @param routing_key_sanitazer [RegexpRoutingKeySanitazer]
+        # @param operation_name_pattern [String]
+        def initialize(
+          routing_key_sanitazer: RegexpRoutingKeySanitazer.new,
+          operation_name_pattern: DEFAULT_OPERATION_NAME_PATTERN
+        )
+          @routing_key_sanitazer = routing_key_sanitazer
+          @operation_name_pattern = operation_name_pattern
+        end
+
+        # @param delivery_info [Bunny::DeliveryInfo]
+        # @return [String] bunny consume operation name
+        def build_operation_name(delivery_info)
+          format_args = build_format_args(delivery_info)
+          format(@operation_name_pattern, format_args)
+        end
+
+        private
+
+        def build_format_args(delivery_info)
+          queue = delivery_info[:consumer].queue
+          routing_key = \
+            sanitaze_routing_key(delivery_info[:routing_key])
+          delivery_info.to_h.merge(
+            routing_key: routing_key,
+            queue: queue.name,
+          )
+        end
+
+        def sanitaze_routing_key(routing_key)
+          return if routing_key.nil?
+
+          @routing_key_sanitazer.sanitaze_routing_key(routing_key)
+        end
+      end
+    end
+  end
+end

data/lib/opentracing/instrumentation/bunny/consume_tags_builder.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module OpenTracing
+  module Instrumentation
+    module Bunny
+      # ConsumeTagsBuidler build consume tags from delivery_info and
+      # properties
+      class ConsumeTagsBuilder
+        DEFAULT_STATIC_TAGS = {
+          'span.kind' => 'consumer',
+          'component' => 'bunny',
+        }.freeze
+
+        # @param static_tags [Hash<String, String>]
+        def initialize(static_tags: DEFAULT_STATIC_TAGS)
+          @static_tags = static_tags
+        end
+
+        # @param delivery_info [Bunny::DeliveryInfo]
+        # @param properties [Bunny::MessageProperties]
+        # @return [Hash] consume span tags
+        def build_tags(delivery_info, properties)
+          @static_tags
+            .merge(build_properties_tags(properties))
+            .merge(build_delivery_info_tags(delivery_info))
+            .merge(build_consumer_tags(delivery_info[:consumer]))
+        end
+
+        private
+
+        def build_properties_tags(properties)
+          {
+            'amqp.content_type' => properties[:content_type],
+          }
+        end
+
+        def build_delivery_info_tags(delivery_info)
+          {
+            'amqp.redelivered' => delivery_info[:redelivered],
+            'amqp.exchange' => delivery_info[:exchange],
+            'amqp.routing_key' => delivery_info[:routing_key],
+          }
+        end
+
+        def build_consumer_tags(consumer)
+          {
+            'amqp.queue' => consumer.queue.name,
+            'amqp.no_ack' => consumer.no_ack,
+            'amqp.exclusive' => consumer.exclusive,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/opentracing/instrumentation/bunny/consume_tracer.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module OpenTracing
+  module Instrumentation
+    module Bunny
+      # ConsumeTracer extract parent span from message headers and
+      # create span around passed block
+      #
+      # Usage:
+      #   consumer_tracer = \
+      #     OpenTracing::Instrumentation::Bunny::ConsumeTracer.new
+      #
+      #   consumer_tracer = \
+      #     OpenTracing::Instrumentation::Bunny::ConsumeTracer.new do |config|
+      #       config.tracer = custom_tracer
+      #     end
+      #
+      #   queue.subscribe(block: true) do |delivery_info, properties, payload|
+      #     consume_tracer.consume(delivery_info, properties) do
+      #     end
+      #   end
+      class ConsumeTracer
+        extend Forwardable
+
+        # @param config [ConsumeTracerConfig]
+        def initialize(config: ConsumeTracerConfig.new)
+          yield config if block_given?
+          @config = config
+        end
+
+        # Extract tracing parent from headers. Create span with tags.
+        # If block passed, then span closed after block exit, otherwise
+        # return active scope.
+        #
+        # @param delivery_info [Bunny::DeliveryInfo]
+        # @param properties [Bunny::MessageProperties]
+        # @yield if block passed, then it called and after scope closed
+        # @yieldparam scope [OpenTracing::Scope]
+        # @return [OpenTracing::Scope, nil] return active scope if called
+        # without block, otherwise return block result
+        def consume(delivery_info, properties)
+          span_scope = safe_start_active_span(delivery_info, properties)
+          return span_scope unless block_given?
+
+          handle_error(span_scope) do
+            yield span_scope
+          end
+        end
+
+        private
+
+        def_delegators(
+          :@config,
+          :tracer,
+          :operation_name_builder,
+          :tags_builder,
+          :error_writer,
+          :logger,
+        )
+
+        def handle_error(span_scope)
+          yield
+        rescue StandardError => e
+          error_writer.write_error(span_scope.span, e)
+          raise e
+        ensure
+          # Close span if exists
+          span_scope&.close
+        end
+
+        def safe_start_active_span(delivery_info, properties)
+          start_active_span(delivery_info, properties)
+        rescue StandardError => e
+          logger&.error(e)
+          nil
+        end
+
+        def start_active_span(delivery_info, properties)
+          operation_name = build_operation_name(delivery_info)
+          tags = build_tags(delivery_info, properties)
+          references = build_references(properties[:headers])
+          tracer.start_active_span(
+            operation_name,
+            tags: tags,
+            references: references,
+          )
+        end
+
+        def build_operation_name(delivery_info)
+          operation_name_builder.build_operation_name(delivery_info)
+        end
+
+        def build_tags(delivery_info, properties)
+          tags_builder.build_tags(delivery_info, properties)
+        end
+
+        def build_references(headers)
+          span_context = tracer.extract(
+            OpenTracing::FORMAT_TEXT_MAP,
+            headers,
+          )
+          [OpenTracing::Reference.follows_from(span_context)]
+        end
+      end
+    end
+  end
+end

data/lib/opentracing/instrumentation/bunny/consume_tracer_config.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module OpenTracing
+  module Instrumentation
+    module Bunny
+      # ConsumeTracerConfig for ConsumeTracer
+      class ConsumeTracerConfig
+        # @return [ConsumeOperationNameBuilder]
+        attr_accessor :operation_name_builder
+        # @return [ConsumeTagsBuilder]
+        attr_accessor :tags_builder
+        # @return [OpenTracing::Tracer]
+        attr_accessor :tracer
+        # @return [Common::ErrorWriter]
+        attr_accessor :error_writer
+        # @return [::Logger]
+        attr_accessor :logger
+
+        def initialize
+          @operation_name_builder = ConsumeOperationNameBuilder.new
+          @tags_builder = ConsumeTagsBuilder.new
+          @tracer = OpenTracing.global_tracer
+          @error_writer = Common::ErrorWriter.new
+          @logger = nil
+        end
+      end
+    end
+  end
+end

data/lib/opentracing/instrumentation/bunny/headers_builder.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module OpenTracing
+  module Instrumentation
+    module Bunny
+      # HeadersBuilder build AMQP headers
+      class HeadersBuilder
+        # @param tracer [OpenTracing::Tracer]
+        # @param injector [HeadersInjector]
+        def initialize(
+          tracer: OpenTracing.global_tracer,
+          injector: HeadersInjector.new(tracer: tracer)
+        )
+          @tracer = tracer
+          @injector = injector
+        end
+
+        # @param active_span [OpenTracing::Span]
+        # @return [Hash<String, String>] return injected headers
+        def build(active_span: @tracer.active_span)
+          headers = {}
+          @injector.inject(headers, active_span: active_span)
+          headers
+        end
+      end
+    end
+  end
+end

data/lib/opentracing/instrumentation/bunny/headers_injector.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module OpenTracing
+  module Instrumentation
+    module Bunny
+      # HeadersInjector inject tracing headers into bunny message headers
+      class HeadersInjector
+        # @param trace [OpenTracing::Tracer]
+        def initialize(tracer: OpenTracing.global_tracer)
+          @tracer = tracer
+        end
+
+        # inject tracing headers
+        # @param headers [Hash<String,String>]
+        # @param active_span [OpenTracing::Span]
+        def inject(
+          headers,
+          active_span: @tracer.active_span
+        )
+          @tracer.inject(
+            active_span.context,
+            OpenTracing::FORMAT_TEXT_MAP,
+            headers,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/opentracing/instrumentation/bunny/publish_operation_name_builder.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module OpenTracing
+  module Instrumentation
+    module Bunny
+      # PublishOperationNameBuilder build publish command name from
+      # exchange and publish options
+      class PublishOperationNameBuilder
+        DEFAULT_OPERATION_NAME_PATTERN = \
+          'bunny_publish(' \
+            'routing_key=%<routing_key>s, ' \
+            'exchange=%<exchange>s' \
+          ')'
+
+        # @param routing_key_sanitazer [RegexpRoutingKeySanitazer]
+        # @param operation_name_pattern [String]
+        def initialize(
+          routing_key_sanitazer: RegexpRoutingKeySanitazer.new,
+          operation_name_pattern: DEFAULT_OPERATION_NAME_PATTERN
+        )
+          @routing_key_sanitazer = routing_key_sanitazer
+          @operation_name_pattern = operation_name_pattern
+        end
+
+        # @param exchange [Bunny::Exchange]
+        # @param opts [Hash<Symbol, Object>]
+        # @option opts [String] :routing_key
+        # @return [String]
+        def build_operation_name(exchange, opts)
+          format_args = build_format_args(exchange, opts)
+          format(@operation_name_pattern, **format_args)
+        end
+
+        private
+
+        def build_format_args(exchange, opts)
+          opts
+            .merge(exchange: exchange.name)
+            .merge(routing_key: sanitaze_routing_key(opts[:routing_key]))
+        end
+
+        def sanitaze_routing_key(routing_key)
+          return if routing_key.nil?
+
+          @routing_key_sanitazer.sanitaze_routing_key(routing_key)
+        end
+      end
+    end
+  end
+end

data/lib/opentracing/instrumentation/bunny/publish_tags_builder.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'bunny'
+
+module OpenTracing
+  module Instrumentation
+    module Bunny
+      # PublishTagsBuilder build span tags for Bunny::PublishTracer
+      class PublishTagsBuilder
+        DEFAULT_STATIC_TAGS = {
+          'span.kind' => 'publiser',
+          'component' => 'bunny',
+        }.freeze
+
+        DEFAULT_CONTENT_TYPE = ::Bunny::Channel::DEFAULT_CONTENT_TYPE
+        DEFAULT_PERSISTENT = true
+        DEFAAUL_PRIORITY = 0
+
+        # @param static_tags [Hash<String, String>]
+        def initialize(static_tags: DEFAULT_STATIC_TAGS)
+          @static_tags = static_tags
+        end
+
+        # @param exchange [Bunny::Exchange]
+        # @param opts [Hash<>]
+        # @option opts [String, nil] :routing_key
+        # @option opts [String, nil] :content_type
+        # @option opts [String, nil] :message_id
+        # @option opts [Integer, nil] :expiration
+        # @option opts [String, nil] :content_encoding
+        # @option opts [Boolean, nil] :persistent
+        # @option opts [Boolean, nil] :mandatory
+        # @option opts [Integer, nil] :priority
+        # @option opts [String, nil] :app_id
+        # @return [Hash<String, String>]
+        def build_tags(exchange, opts)
+          @static_tags
+            .merge(exchange_tags(exchange))
+            .merge(meta_tags(opts))
+            .merge(extended_tags(opts))
+            .compact
+        end
+
+        private
+
+        def exchange_tags(exchange)
+          {
+            'amqp.exchange' => exchange.name,
+            'amqp.exchange_type' => exchange.type,
+          }
+        end
+
+        def meta_tags(opts)
+          content_type = opts.fetch(:content_type, DEFAULT_CONTENT_TYPE)
+          {
+            'amqp.routing_key' => opts[:routing_key],
+            'amqp.content_type' => content_type,
+            'amqp.message_id' => opts[:message_id],
+            'amqp.expiration' => opts[:expiration],
+            'amqp.content_encoding' => opts[:content_encoding],
+          }
+        end
+
+        def extended_tags(opts)
+          persistent = opts.fetch(:persistent, DEFAULT_PERSISTENT)
+          priority = opts.fetch(:priority, DEFAAUL_PRIORITY)
+
+          {
+            'amqp.persistent' => persistent,
+            'amqp.mandatory' => opts[:mandatory],
+            'amqp.priority' => priority,
+            'amqp.app_id' => opts[:app_id],
+          }
+        end
+      end
+    end
+  end
+end

data/lib/opentracing/instrumentation/bunny/publish_tracer.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module OpenTracing
+  module Instrumentation
+    module Bunny
+      # PublishTracer trace publishing and inject trace headers into
+      # AMQP message
+      #
+      # Usage:
+      #   exchange = channel.topic(BUNNY_EXCHANGE_NAME)
+      #   default_publisher \
+      #     = OpenTracing::Instrumentation::Bunny::PublishTracer.new(exchange)
+      #   configured_publisher = \
+      #     OpenTracing::Instrumentation::Bunny::PublishTracer.new(exchange) do |c|
+      #       c.tracer = custom_tracer
+      #     end
+      #   publisher.publish(
+      #     '{"message": 123}',
+      #     routing_key: 'key',
+      #   )
+      class PublishTracer
+        extend Forwardable
+
+        # @param exchange [Bunny::Exchange]
+        def initialize(exchange, config: PublishTracerConfig.new)
+          @exchange = exchange
+          yield config if block_given?
+          @config = config.dup
+        end
+
+        # Publish message via call `exchange.publish`, with injecting tracing
+        # into headers and create span around publising call.
+        #
+        # For deatils see:
+        # https://www.rubydoc.info/gems/bunny/Bunny/Exchange#publish-instance_method
+        #
+        # @param active [OpenTracing::Span] allow overide span
+        # @return [Bunny::Exchange]
+        def publish(
+          payload,
+          active_span: tracer.active_span,
+          **opts
+        )
+          trace_publish(span: active_span, **opts) do |scope|
+            publish_with_headers(
+              payload,
+              span: scope&.span || active_span,
+              **opts,
+            )
+          end
+        end
+
+        private
+
+        attr_reader :exchange
+
+        def_delegators(
+          :@config,
+          :tracer,
+          :operation_name_builder,
+          :tags_builder,
+          :injector,
+          :error_writer,
+          :logger,
+        )
+
+        def safe_inject_headers(span:, headers:)
+          injector.inject(headers, active_span: span)
+        end
+
+        def publish_with_headers(
+          payload,
+          span:,
+          headers: {},
+          **opts
+        )
+          safe_inject_headers(span: span, headers: headers)
+          exchange.publish(
+            payload,
+            headers: headers,
+            **opts,
+          )
+        end
+
+        def trace_publish(span:, **opts)
+          scope = safe_start_active_span(span: span, **opts)
+          yield scope
+        rescue StandardError => e
+          error_writer.write_error(scope.span, e) if scope
+          logger&.error(e)
+          raise e
+        ensure
+          scope&.close
+        end
+
+        def safe_start_active_span(span:, **opts)
+          start_active_span(span: span, **opts)
+        rescue StandardError
+          nil
+        end
+
+        def start_active_span(span:, **opts)
+          operation_name = build_operation_name(opts)
+          tags = build_tags(opts)
+          tracer.start_active_span(
+            operation_name,
+            tags: tags,
+            child_of: span,
+          )
+        end
+
+        def build_operation_name(opts)
+          operation_name_builder.build_operation_name(exchange, opts)
+        end
+
+        def build_tags(opts)
+          tags_builder.build_tags(exchange, opts)
+        end
+      end
+    end
+  end
+end

data/lib/opentracing/instrumentation/bunny/publish_tracer_config.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module OpenTracing
+  module Instrumentation
+    module Bunny
+      # PublishTracerConfig for PublishTracer
+      class PublishTracerConfig
+        # @return [OpenTracing::Tracer]
+        attr_accessor :tracer
+        # @return [PublishOperationNameBuilder]
+        attr_accessor :operation_name_builder
+        # @return [PublishTagsBuilder]
+        attr_accessor :tags_builder
+        # @return [HeadersInjector]
+        attr_accessor :injector
+        # @return [Common::ErrorWriter]
+        attr_accessor :error_writer
+        # @return [::Logger]
+        attr_accessor :logger
+
+        def initialize
+          @tracer = OpenTracing.global_tracer
+          @operation_name_builder = PublishOperationNameBuilder.new
+          @tags_builder = PublishTagsBuilder.new
+          @injector = HeadersInjector.new
+          @error_writer = Common::ErrorWriter.new
+        end
+      end
+    end
+  end
+end

data/lib/opentracing/instrumentation/bunny/regexp_routing_key_sanitazer.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module OpenTracing
+  module Instrumentation
+    module Bunny
+      # Replace id into routing key with placeholder
+      #
+      # Example:
+      #    sanitazer = RegexpRoutingKeySanitazer.new
+      #    sanitazer.sanitaze_routing_key('prefix.1234567890abcdef12345678')
+      #
+      #    # 'prefix.:object_id'
+      #
+      #
+      #    sanitazer.sanitaze_routing_key('prefix.123.suffix')
+      #
+      #    # 'prefix.:sequence_id.suffis'
+      class RegexpRoutingKeySanitazer
+        ROUTING_KEY_SEPARATOR = '.'
+        DEFAULT_REPLCE_REGEXP_MAP = {
+          ':sequence_id' => /^\d+$/,
+          ':object_id' => /^[0-9a-f]{24}$/,
+        }.freeze
+
+        # @param replace_regexp_map [Hash<String, String>]
+        def initialize(replace_regexp_map: DEFAULT_REPLCE_REGEXP_MAP)
+          @replace_regexp_map = replace_regexp_map
+        end
+
+        # @param routing_key [String] souce routing key
+        # @return [String] sanitazed routing key
+        def sanitaze_routing_key(routing_key)
+          routing_key
+            .split(ROUTING_KEY_SEPARATOR)
+            .map(&method(:filter_part))
+            .join(ROUTING_KEY_SEPARATOR)
+        end
+
+        private
+
+        attr_reader :replace_regexp_map
+
+        def filter_part(routing_key_part)
+          replace_regexp_map.each do |placeholder, regexp|
+            return placeholder if regexp =~ routing_key_part
+          end
+          routing_key_part
+        end
+      end
+    end
+  end
+end

data/lib/opentracing/instrumentation/hutch.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module OpenTracing
+  module Instrumentation
+    # Module Hutch allow tracing Hutch consuming and inject
+    # tracing headers on publishing
+    #
+    # @see ConsumeTracer
+    # @see ConsumeTracerBuilder
+    # @see GlobalPropertiesBuilder
+    module Hutch
+      module_path = 'opentracing/instrumentation/hutch'
+
+      autoload :ConsumeOperationNameBuilder,
+               module_path + '/consume_operation_name_builder'
+      autoload :ConsumeTagsBuilder,
+               module_path + '/consume_tags_builder'
+      autoload :ConsumeTracer,
+               module_path + '/consume_tracer'
+      autoload :ConsumeTracerBuilder,
+               module_path + '/consume_tracer_builder'
+      autoload :ConsumeTracerConfig,
+               module_path + '/consume_tracer_config'
+      autoload :GlobalPropertiesBuilder,
+               module_path + '/global_properties_builder'
+    end
+  end
+end

data/lib/opentracing/instrumentation/hutch/consume_operation_name_builder.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module OpenTracing
+  module Instrumentation
+    module Hutch
+      # ConsumeOperationNameBuilder build span operation name of
+      # Hutch ConsumeTracer
+      class ConsumeOperationNameBuilder
+        DEFAULT_OPERATION_NAME_PATTERN = \
+          'hutch_consume(consumer_class=%<consumer_class>s)'
+
+        # @param routing_key_sanitazer [Bunny::RegexpRoutingKeySanitazer]
+        # @param operation_name_pattern [String]
+        def initialize(
+          routing_key_sanitazer: Bunny::RegexpRoutingKeySanitazer.new,
+          operation_name_pattern: DEFAULT_OPERATION_NAME_PATTERN
+        )
+          @routing_key_sanitazer = routing_key_sanitazer
+          @operation_name_pattern = operation_name_pattern
+        end
+
+        # @param consume [Object] instance of consumer
+        # @param message [Hutch::Message]
+        # @return [String] operation_name
+        def build_operation_name(consumer, message)
+          format_args = build_format_args(consumer, message)
+          format(@operation_name_pattern, format_args)
+        end
+
+        private
+
+        def build_format_args(consumer, message)
+          consumer_format_args(consumer)
+            .merge(delivery_info_format_args(message.delivery_info))
+            .merge(message.properties.to_h)
+        end
+
+        def delivery_info_format_args(delivery_info)
+          routing_key = delivery_info[:routing_key]
+          sanitazed_routing_key = sanitaze_routing_key(routing_key)
+          delivery_info
+            .to_h
+            .merge(routing_key: sanitazed_routing_key)
+        end
+
+        def sanitaze_routing_key(routing_key)
+          return if routing_key.nil?
+
+          @routing_key_sanitazer.sanitaze_routing_key(routing_key)
+        end
+
+        def consumer_format_args(consumer)
+          {
+            consumer_class: consumer.class.to_s,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/opentracing/instrumentation/hutch/consume_tags_builder.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module OpenTracing
+  module Instrumentation
+    module Hutch
+      # ConsumeTagsBuilder build span tags for Hutch ConsumerTrace.
+      # Its use Bunny::ComsumerTagsBuilde for common tags and add
+      # hutch specific tags
+      class ConsumeTagsBuilder
+        DEFAULT_STATIC_TAGS = {
+          'component' => 'hutch',
+        }.freeze
+
+        # @param bunny_consume_tags_builder [Bunny::ConsumeTagsBuilder]
+        # @param static_tags [Hash<String, String>]
+        def initialize(
+          bunny_consume_tags_builder: Bunny::ConsumeTagsBuilder.new,
+          static_tags: DEFAULT_STATIC_TAGS
+        )
+          @bunny_consume_tags_builder = bunny_consume_tags_builder
+          @static_tags = static_tags
+        end
+
+        # @param consumer [Object] instance of consumer
+        # @param message [Hutch::Message]
+        # @return [Hash<String, String>] tags
+        def build_tags(consumer, message)
+          build_bunny_tags(message)
+            .merge(hutch_tags(consumer))
+            .merge(@static_tags)
+        end
+
+        private
+
+        attr_reader :static_tags
+
+        def build_bunny_tags(message)
+          @bunny_consume_tags_builder.build_tags(
+            message.delivery_info,
+            message.properties,
+          )
+        end
+
+        def hutch_tags(consumer)
+          {
+            'hutch.consumer_class' => consumer.class.to_s,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/opentracing/instrumentation/hutch/consume_tracer.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module OpenTracing
+  module Instrumentation
+    module Hutch
+      # ConsumeTracer trace Hutch consumer. Cannot be configured,
+      # Use ConsumeTracerBuilder for configuration.
+      #
+      # Usage:
+      #   Hutch::Config.set(
+      #     :tracer,
+      #     OpenTracing::Instrumentation::Hutch::ConsumeTracer,
+      #   )
+      class ConsumeTracer
+        extend Forwardable
+
+        def initialize(consumer, config: ConsumeTracerConfig.new)
+          @consumer = consumer
+          @config = config
+        end
+
+        # Method handle called by Hutch on message. This method
+        # start active span, process consumer and close span.
+        def handle(message)
+          scope = safe_start_active_span(message)
+          consumer.process(message)
+        rescue StandardError => e
+          error_writer.write_error(scope.span, e) if scope
+          raise e
+        ensure
+          # Close scope if exists
+          scope&.close
+        end
+
+        private
+
+        attr_reader :consumer
+
+        def_delegators(
+          :@config,
+          :tracer,
+          :error_writer,
+          :operation_name_builder,
+          :tags_builder,
+          :logger,
+        )
+
+        def safe_start_active_span(message)
+          start_active_span(message)
+        rescue StandardError => e
+          logger.error(e)
+          nil
+        end
+
+        def start_active_span(message)
+          operation_name = build_operation_name(message)
+          tags = tags_builder.build_tags(consumer, message)
+          references = build_references(message.properties[:headers])
+
+          tracer.start_active_span(
+            operation_name,
+            tags: tags,
+            references: references,
+          )
+        end
+
+        def build_operation_name(message)
+          operation_name_builder.build_operation_name(
+            consumer,
+            message,
+          )
+        end
+
+        def build_references(headers)
+          span_context = tracer.extract(
+            OpenTracing::FORMAT_TEXT_MAP,
+            headers,
+          )
+          [OpenTracing::Reference.follows_from(span_context)]
+        end
+      end
+    end
+  end
+end

data/lib/opentracing/instrumentation/hutch/consume_tracer_builder.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module OpenTracing
+  module Instrumentation
+    module Hutch
+      # ConsumeTracerBuilder build and configure ConsumeTracer.
+      # Should be used for configuration of ConsumeTracer.
+      #
+      # Usage:
+      #   hutch_tracer_builder = \
+      #     OpenTracing::Instrumentation::Hutch::ConsumeTracerBuilder.new do |config|
+      #       config.tracer = CustomTracer.new
+      #     end
+      #   Hutch::Config.set(:tracer, hutch_tracer_builder)
+      #
+      # @param config [ConsumeTracerConfig]
+      # @yield [ConsumeTracerConfig]
+      class ConsumeTracerBuilder
+        def initialize(config: ConsumeTracerConfig.new)
+          yield config if block_given?
+          @config = config.dup
+        end
+
+        # Build conifgured ConsumeTracer
+        #
+        # ! Its not constructor
+        #
+        # @return ConsumeTracer
+        def new(consumer)
+          ConsumeTracer.new(
+            consumer,
+            config: @config,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/opentracing/instrumentation/hutch/consume_tracer_config.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module OpenTracing
+  module Instrumentation
+    module Hutch
+      # Config for ConsumeTracer
+      class ConsumeTracerConfig
+        # @return [ConsumeOperationNameBuilder]
+        attr_accessor :operation_name_builder
+
+        # @return [ConsumeTagsBuilder]
+        attr_accessor :tags_builder
+
+        # @return [OpenTracing::Tracer]
+        attr_accessor :tracer
+
+        # @return [Common::ErrorWriter]
+        attr_accessor :error_writer
+
+        # @return [::Logger]
+        attr_accessor :logger
+
+        def initialize
+          @operation_name_builder = ConsumeOperationNameBuilder.new
+          @tags_builder = ConsumeTagsBuilder.new
+          @tracer = OpenTracing.global_tracer
+          @error_writer = Common::ErrorWriter.new
+          @logger = ::Hutch::Logging.logger
+        end
+      end
+    end
+  end
+end

data/lib/opentracing/instrumentation/hutch/global_properties_builder.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module OpenTracing
+  module Instrumentation
+    module Hutch
+      # GlobalPropertiesBuilder build hutch global properties with
+      # tracing headers
+      #
+      # Can extend other global properties builders.
+      # Usage:
+      #   Hutch.global_properties = \
+      #     OpenTracing::Instrumentation::Hutch::GlobalPropertiesBuilder.new
+      #
+      class GlobalPropertiesBuilder
+        # EmptyPropertiesBuilder is deafult properties build. It return
+        # empty properties.
+        class EmptyPropertiesBuilder
+          def call
+            {}
+          end
+        end
+
+        # @param headers_injector [Bunny::HeadersInjector]
+        # @param global_properties_builder [EmptyPropertiesBuilder]
+        def initialize(
+          headers_injector: Bunny::HeadersInjector.new,
+          global_properties_builder: EmptyPropertiesBuilder.new
+        )
+          @headers_injector = headers_injector
+          @global_properties_builder = global_properties_builder
+        end
+
+        # @return [Hash<String, String>] properties with injected tracing
+        # headers
+        def call
+          properties = @global_properties_builder.call
+          headers = (properties[:headers] ||= {})
+          @headers_injector.inject(headers)
+          properties
+        end
+      end
+    end
+  end
+end

data/opentracing-instrumentation.gemspec

@@ -29,7 +29,9 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency 'bson', '~> 4.0'
   spec.add_development_dependency 'bundler', File.read('.BUNDLER_VERSION').strip
+  spec.add_development_dependency 'bunny', '~> 2.0'
   spec.add_development_dependency 'faraday', '~> 0.9.2'
+  spec.add_development_dependency 'hutch', '~> 0.26.0'
   spec.add_development_dependency 'rack', '~> 2.2.2'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'redis', '~> 3.3.5'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opentracing-instrumentation
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Fedorenko Dmitrij
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-03-26 00:00:00.000000000 Z
+date: 2020-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -66,6 +66,20 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 2.1.4
+- !ruby/object:Gem::Dependency
+  name: bunny
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +94,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.9.2
+- !ruby/object:Gem::Dependency
+  name: hutch
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.26.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.26.0
 - !ruby/object:Gem::Dependency
   name: rack
   requirement: !ruby/object:Gem::Requirement
@@ -200,11 +228,30 @@ files:
 - bin/console
 - bin/setup
 - lib/opentracing/instrumentation.rb
+- lib/opentracing/instrumentation/bunny.rb
+- lib/opentracing/instrumentation/bunny/consume_operation_name_builder.rb
+- lib/opentracing/instrumentation/bunny/consume_tags_builder.rb
+- lib/opentracing/instrumentation/bunny/consume_tracer.rb
+- lib/opentracing/instrumentation/bunny/consume_tracer_config.rb
+- lib/opentracing/instrumentation/bunny/headers_builder.rb
+- lib/opentracing/instrumentation/bunny/headers_injector.rb
+- lib/opentracing/instrumentation/bunny/publish_operation_name_builder.rb
+- lib/opentracing/instrumentation/bunny/publish_tags_builder.rb
+- lib/opentracing/instrumentation/bunny/publish_tracer.rb
+- lib/opentracing/instrumentation/bunny/publish_tracer_config.rb
+- lib/opentracing/instrumentation/bunny/regexp_routing_key_sanitazer.rb
 - lib/opentracing/instrumentation/common.rb
 - lib/opentracing/instrumentation/common/error_writer.rb
 - lib/opentracing/instrumentation/faraday.rb
 - lib/opentracing/instrumentation/faraday/response_logger.rb
 - lib/opentracing/instrumentation/faraday/trace_middleware.rb
+- lib/opentracing/instrumentation/hutch.rb
+- lib/opentracing/instrumentation/hutch/consume_operation_name_builder.rb
+- lib/opentracing/instrumentation/hutch/consume_tags_builder.rb
+- lib/opentracing/instrumentation/hutch/consume_tracer.rb
+- lib/opentracing/instrumentation/hutch/consume_tracer_builder.rb
+- lib/opentracing/instrumentation/hutch/consume_tracer_config.rb
+- lib/opentracing/instrumentation/hutch/global_properties_builder.rb
 - lib/opentracing/instrumentation/mongo.rb
 - lib/opentracing/instrumentation/mongo/direct_sanitazer.rb
 - lib/opentracing/instrumentation/mongo/query_sanitazer.rb