opentracing-instrumentation 0.1.0

data/lib/opentracing/instrumentation/mongo/trace_subscriber.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'opentracing/instrumentation/mongo/query_sanitazer'
+
+module OpenTracing
+  module Instrumentation
+    module Mongo
+      # TraceSubscriber trace mongo requests
+      class TraceSubscriber
+        include Forwardable
+
+        DEFAULT_OPERATION_NAME = 'mongo_command'
+
+        def initialize(
+          tracer: OpenTracing.global_tracer,
+          scope_store: {},
+          operation_name: DEFAULT_OPERATION_NAME,
+          sanitazer: QuerySanitazer.new
+        )
+          @tracer = tracer
+          @monitor = Monitor.new
+          @scope_store = scope_store
+          @operation_name = operation_name
+          @sanitazer = sanitazer
+        end
+
+        def started(event)
+          scope = tracer.start_active_span(
+            operation_name,
+            tags: base_tags(event).merge(mongo_tags(event)),
+          )
+
+          store_scope(event.operation_id, scope)
+        end
+
+        def succeeded(event)
+          clean_scope(event.operation_id)
+        end
+
+        def failed(event)
+          tag_error(event.operation_id, event.message, event.failure)
+          clean_scope(event.operation_id)
+        end
+
+        private
+
+        attr_reader :tracer
+        attr_reader :scope_store
+        attr_reader :monitor
+        attr_reader :operation_name
+        attr_reader :sanitazer
+
+        def base_tags(event)
+          {
+            'component' => 'db',
+
+            'db.type' => 'mongo',
+            'db.instance' => event.address.to_s,
+          }
+        end
+
+        def mongo_tags(event)
+          collection_name = event.command[event.command_name]
+          command_args = sanitazer.sanitaze(event.command, event.command_name)
+
+          {
+            'mongo.request_id' => event.request_id,
+            'mongo.operation_id' => event.operation_id,
+            'mongo.database_name' => event.database_name,
+            'mongo.collection_name' => collection_name,
+            'mongo.command_name' => event.command_name,
+            'mongo.command_args' => JSON.dump(command_args),
+          }
+        end
+
+        def store_scope(operation_id, scope)
+          monitor.synchronize do
+            scope_store[operation_id] = scope
+          end
+        end
+
+        def clean_scope(operation_id)
+          monitor.synchronize do
+            scope_store
+              .delete(operation_id)
+              .close
+          end
+        end
+
+        ERROR_TAG = 'error'
+
+        def tag_error(operation_id, message, object)
+          monitor.synchronize do
+            scope_store[operation_id]
+              .span
+              .set_tag(ERROR_TAG, true)
+              .log_kv(
+                'error.kind': message,
+                'error.object': JSON.dump(object),
+              )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opentracing/instrumentation/object_wrapper.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module OpenTracing
+  module Instrumentation
+    # ObjectWrapper allow trace call methods on any ruby object.
+    #
+    # Usage:
+    #   wrapped_object = OpenTracing::Instrumentation::ObjectWrapper.new(other_object)
+    #   wrapped_object.other_object_method
+    class ObjectWrapper
+      DEFAULT_COMMAND_NAME = 'method_call'
+
+      attr_reader :tracer,
+                  :command_name
+
+      def initialize(
+        object,
+        tracer: OpenTracing.global_tracer,
+        command_name: DEFAULT_COMMAND_NAME
+      )
+        @object = object
+        @tracer = tracer
+        @command_name = command_name
+      end
+
+      # wrapped object
+      attr_reader :object
+
+      def respond_to_missing?(method_name, *)
+        object.response_to?(method_name)
+      end
+
+      def method_missing(method_name, *args)
+        return super unless object.respond_to?(method_name)
+
+        tags = build_tags(method_name)
+        tracer.start_active_span(command_name, tags: tags) do |scope|
+          call_method(scope.span, method_name, *args)
+        end
+      end
+
+      private
+
+      def call_method(span, method_name, *args)
+        object.send(method_name, *args)
+      rescue StandardError => e
+        span.set_tag('error', true)
+        raise e
+      end
+
+      def build_tags(method)
+        {
+          'object.class' => object.class.to_s,
+          'object.method' => method.to_s,
+        }
+      end
+    end
+  end
+end

data/lib/opentracing/instrumentation/rack.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module OpenTracing
+  module Instrumentation
+    # Rack tracing middlewares
+    module Rack
+      autoload :HttpTagger, 'opentracing/instrumentation/rack/http_tagger'
+      autoload :TraceMiddleware, 'opentracing/instrumentation/rack/trace_middleware'
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'rack'
+
+module OpenTracing
+  module Instrumentation
+    module Rack
+      # HttpTagger create addition tags on span
+      class HttpTagger
+        DEFAULT_TAG_REQUEST_HEADERS = {
+          connection: 'Connection',
+          content_type: 'Content-Type',
+          user_agent: 'User-Agent',
+        }.freeze
+
+        DEFAULT_TAG_RESPONSE_HEADERS = {
+          connection: 'Connection',
+          content_type: 'Content-Type',
+          keep_alive: 'Keep-Alive',
+        }.freeze
+
+        def initialize(
+          tag_request_headers: DEFAULT_TAG_REQUEST_HEADERS,
+          tag_response_headers: DEFAULT_TAG_RESPONSE_HEADERS
+        )
+          @tag_request_headers =
+            prepare_request_mapping(tag_request_headers)
+          @tag_response_headers =
+            prepare_response_mapping(tag_response_headers)
+        end
+
+        def request_tags(env)
+          @tag_request_headers
+            .transform_values { |header_name| env[header_name] }
+            .compact
+        end
+
+        def response_tags(headers)
+          header_mapper = lambda do |header_regexp|
+            headers.find do |(header, _value)|
+              header_regexp.match?(header)
+            end&.dig(1)
+          end
+          @tag_response_headers
+            .transform_values(&header_mapper)
+            .compact
+        end
+
+        private
+
+        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
+            [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
+            header_regexp = /^#{header}$/i
+            [tag_name, header_regexp]
+          end.to_h
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'rack'
+
+module OpenTracing
+  module Instrumentation
+    module Rack
+      # TraceMiddleware observer rack requests.
+      class TraceMiddleware
+        def initialize(
+          app,
+          logger: nil,
+          command_name: 'rack',
+          http_tagger: HttpTagger.new,
+          tracer: OpenTracing.global_tracer
+        )
+          @app = app
+          @logger = logger
+          @command_name = command_name
+          @http_tagger = http_tagger
+          @tracer = tracer
+        end
+
+        def call(env)
+          trace_request(env) do |span|
+            catch_error(span) do
+              status, headers, body = app.call(env)
+
+              set_response_tags(span, status, headers)
+              [status, headers, body]
+            end
+          end
+        end
+
+        private
+
+        attr_reader :app
+        attr_reader :http_tagger
+        attr_reader :tracer
+        attr_reader :logger
+
+        def trace_request(env)
+          extracted_ctx = tracer.extract(OpenTracing::FORMAT_RACK, env)
+          logger&.info('Tracing context extracted') if extracted_ctx
+          tracer.start_active_span(
+            @command_name,
+            child_of: extracted_ctx,
+            tags: request_tags(env),
+          ) do |scope|
+            yield(scope.span)
+          end
+        end
+
+        def catch_error(span)
+          yield
+        rescue StandardError => e
+          logger&.error(e)
+          error_tag(span, e)
+          raise
+        end
+
+        REQUEST_URI = 'REQUEST_URI'
+
+        def request_tags(env)
+          {
+            'http.method' => env[::Rack::REQUEST_METHOD],
+            'http.url' => env[REQUEST_URI],
+            'span.kind' => 'server',
+          }.merge(http_tagger.request_tags(env))
+        end
+
+        def set_response_tags(span, status, headers)
+          set_status_tag(span, status)
+          set_header_tags(span, headers)
+        end
+
+        def set_status_tag(span, status)
+          span.set_tag('http.status', status)
+        end
+
+        def set_header_tags(span, headers)
+          http_tagger
+            .response_tags(headers)
+            .each(&span.method(:set_tag))
+        end
+
+        def error_tag(span, error)
+          span.set_tag('error', true)
+          span.log_kv('error.kind': error.class.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/opentracing/instrumentation/redis.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module OpenTracing
+  module Instrumentation
+    # Redis tracing drivers
+    module Redis
+      EVENT_WRITE = 'redis_write'
+      EVENT_READ = 'redis_read'
+
+      autoload :Config,
+               'opentracing/instrumentation/redis/config'
+      autoload :SpanBuilder,
+               'opentracing/instrumentation/redis/span_builder'
+      autoload :TracingDriverWrapper,
+               'opentracing/instrumentation/redis/tracing_driver_wrapper'
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'redis/connection/ruby'
+
+module OpenTracing
+  module Instrumentation
+    module Redis
+      # Redis tracing mixin config
+      class Config
+        DEFAULT_SPAN_NAME = 'redis_command'
+        # Safe by default
+        DEFAULT_LOG_ARGS = false
+        DEFAULT_LOG_REPLY = false
+        DEFAULT_COMPONENT = 'kv'
+
+        attr_accessor :tracer
+        attr_accessor :span_name
+        attr_accessor :log_args
+        attr_accessor :log_reply
+        attr_accessor :component
+
+        def initialize(
+          tracer: OpenTracing.global_tracer,
+          span_name: DEFAULT_SPAN_NAME,
+          log_args: DEFAULT_LOG_ARGS,
+          log_reply: DEFAULT_LOG_REPLY,
+          component: DEFAULT_COMPONENT
+        )
+          @tracer = tracer
+          @span_name = span_name
+          @log_args = log_args
+          @log_reply = log_reply
+          @component = component
+
+          yield self if block_given?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module OpenTracing
+  module Instrumentation
+    module Redis
+      # SpanBuilder create span with tags and logs
+      class SpanBuilder
+        extend Forwardable
+
+        def initialize(
+          config: Config.new,
+          error_writer: Common::ErrorWriter.new
+        )
+          @config = config
+          @error_writer = error_writer
+        end
+
+        def_delegators :@config,
+                       :tracer,
+                       :span_name,
+                       :component,
+                       :log_args,
+                       :log_reply
+
+        def_delegators :@error_writer,
+                       :write_error
+
+        def start_active_scope(connection_class, peer_addr)
+          tags = build_tags(connection_class, peer_addr)
+          tracer.start_active_span(
+            span_name,
+            tags: tags,
+          )
+        end
+
+        def build_tags(connection_class, peer_addr)
+          {
+            'span.kind' => 'client',
+            'component' => component,
+            'peer.address' => peer_addr,
+            'peer.service' => 'redis',
+            'redis.driver' => connection_class.to_s,
+          }.compact
+        end
+
+        REDACTED_ARG = ['*'].freeze
+
+        def write_log_command(span, command)
+          command_name, *args = command
+          args_value = log_args ? JSON.dump(args) : REDACTED_ARG * args.size
+
+          span.log_kv(
+            event: EVENT_WRITE,
+            'redis.command': command_name,
+            'redis.args': args_value,
+          )
+        end
+
+        def write_error_reply(span, reply)
+          return unless reply.is_a?(::Redis::CommandError)
+
+          span.set_tag('error', true)
+          span.log_kv(
+            'error.kind': 'redis_error',
+            message: reply.to_s,
+            event: EVENT_READ,
+          )
+        end
+
+        def write_log_reply(span, reply)
+          write_error_reply(span, reply)
+
+          return unless log_reply
+
+          span.log_kv(
+            event: EVENT_READ,
+            'redis.reply': JSON.dump(reply),
+          )
+        end
+      end
+    end
+  end
+end