opentracing-instrumentation 0.1.0

data/lib/opentracing/instrumentation/common/error_writer.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module OpenTracing
+  module Instrumentation
+    module Common
+      # ErrorWriter can be used to write error tag and log to span
+      class ErrorWriter
+        LOG_ERROR_EVENT = 'error'
+        ERROR_TAG = 'error'
+
+        attr_reader :set_error_tag
+        attr_reader :log_error_event
+
+        # @param set_error_tag [TrueClass,ErrorClass] enable set error tag
+        # @param log_error_event [TrueClass, ErrorClass] enable log exception
+        def initialize(
+          set_error_tag: true,
+          log_error_event: true
+        )
+          @set_error_tag = set_error_tag
+          @log_error_event = log_error_event
+        end
+
+        # Write error tag and log error event
+        # @param span [OpenTracing::Span] target for tag and log
+        # @param exception [Exception] logged to tag
+        def write_error(span, exception, event: LOG_ERROR_EVENT)
+          tag_error(span)
+
+          log_error(span, exception, event)
+        end
+
+        private
+
+        def tag_error(span)
+          return unless set_error_tag
+
+          span.set_tag('error', true)
+        end
+
+        def log_error(span, exception, event)
+          return unless log_error_event
+
+          span.log_kv(
+            event: event,
+            'error.kind': exception.class.to_s,
+            message: exception.to_s,
+            stack: JSON.dump(exception.backtrace),
+          )
+        end
+      end
+    end
+  end
+end

data/lib/opentracing/instrumentation/faraday.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module OpenTracing
+  module Instrumentation
+    # Faraday tracing middlewares
+    module Faraday
+      autoload :TraceMiddleware, 'opentracing/instrumentation/faraday/trace_middleware'
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module OpenTracing
+  module Instrumentation
+    module Faraday
+      # ResponseLogger add request and response log_kv to faraday_request span
+      class ResponseLogger
+        DEFAULT_REQUEST_LOG_HEADERS = %w[].freeze
+        DEFAULT_REQUEST_TAG_HEADERS = {
+          accept: 'Accept',
+          connection: 'Connection',
+          content_type: 'Content-Type',
+          user_agent: 'User-Agent',
+        }.freeze
+        DEFAULT_RESPONSE_LOG_HEADERS = %w[
+          Content-Length
+        ].freeze
+        DEFAULT_RESPONSE_TAG_HEADERS = {
+          connection: 'Connection',
+          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
+
+        def initialize(
+          request_log_headers: DEFAULT_REQUEST_LOG_HEADERS,
+          request_tag_headers: DEFAULT_REQUEST_TAG_HEADERS,
+          response_tag_headers: DEFAULT_RESPONSE_TAG_HEADERS,
+          response_log_headers: DEFAULT_RESPONSE_LOG_HEADERS
+        )
+          @request_tag_headers = request_tag_headers
+          @request_log_headers = request_log_headers
+          @response_tag_headers = response_tag_headers
+          @response_log_headers = response_log_headers
+        end
+
+        def log_request(span, request_headers)
+          log_headers(span, request_headers, request_log_headers, 'request')
+          tag_headers(span, request_headers, request_tag_headers, 'request')
+        end
+
+        def log_response(span, response_headers)
+          log_headers(span, response_headers, response_log_headers, 'response')
+          tag_headers(span, response_headers, response_tag_headers, 'response')
+        end
+
+        private
+
+        def tag_headers(span, headers, tag_headers, event)
+          tag_headers.each do |key, header_name|
+            header_value = headers[header_name]
+            next unless header_value
+
+            span.set_tag("http.#{event}.#{key}", header_value)
+          end
+        end
+
+        def log_headers(span, headers, log_headers, event)
+          header_hash =
+            log_headers
+            .map { |key| [key, headers[key]] }
+            .reject { |(_key, value)| value.nil? }
+            .to_h
+
+          span.log_kv(
+            event: event,
+            headers: JSON.dump(header_hash),
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require 'opentracing/instrumentation/faraday/response_logger'
+
+module OpenTracing
+  module Instrumentation
+    module Faraday
+      # TraceMiddleware inject tracing header into request and trace request
+      #
+      # Usage with default config:
+      #   Faraday.new(url) do |connection|
+      #     connection.use \
+      #       OpenTracing::Instrumentation::Faraday::TraceMiddleware
+      #   end
+      #
+      # Usage with config block:
+      #   Faraday.new(url) do |connection|
+      #     connection.use \
+      #       OpenTracing::Instrumentation::Faraday::TraceMiddleware do |c|
+      #         # c is instance of Config
+      #         c.tracer = tracer
+      #       end
+      #   end
+      class TraceMiddleware
+        extend Forwardable
+
+        # Config for TraceMiddleware
+        class Config
+          DEFAULT_COMMAND_NAME = 'faraday_request'
+          DEFAULT_COMPONENT = 'faraday'
+          DEFAULT_EXPECTED_ERRORS = [StandardError].freeze
+
+          def initialize
+            @tracer = OpenTracing.global_tracer
+            @operation_name = DEFAULT_COMMAND_NAME
+            @component = DEFAULT_COMPONENT
+            @expected_errors = DEFAULT_EXPECTED_ERRORS
+            @service_name = nil
+            @inject = true
+            @response_logger = ResponseLogger.new
+          end
+
+          # Instance of tracer. Should implement OpenTracing::Tracer API.
+          #
+          # @return [OpenTracing::Tracer]
+          attr_accessor :tracer
+
+          # Operation name of tracing span.
+          #
+          # @return [String]
+          attr_accessor :operation_name
+
+          # List of handled errors.
+          #
+          # @return [Array<Class>]
+          attr_accessor :expected_errors
+
+          # Value for component tag
+          #
+          # @return [String]
+          attr_accessor :component
+
+          # Value for service_name tag.
+          #
+          # @return [String]
+          attr_accessor :service_name
+
+          # Instance of response logger
+          #
+          # @return [ResponseLogger]
+          attr_accessor :response_logger
+
+          # Inject trace headers to response
+          #
+          # @return [Boolean]
+          attr_accessor :inject
+        end
+
+        # @param config [Config]
+        #
+        # @yieldparam config [Config]
+        def initialize(
+          app,
+          config = Config.new
+        )
+          @app = app
+          @config = config
+          yield(config) if block_given?
+        end
+
+        # Wrap Faraday request to trace it with OpenTracing
+        # @param env [Faraday::Env]
+        # @return [Faraday::Response]
+        def call(env)
+          trace_request(env) do |span|
+            inject_tracing(span, env) if inject
+            response_logger&.log_request(span, env.request_headers)
+            @app.call(env).on_complete do |response|
+              set_response_tags(span, response)
+              response_logger&.log_response(span, response.response_headers)
+            end
+          end
+        end
+
+        private
+
+        def_delegators :@config,
+                       :tracer,
+                       :operation_name,
+                       :component,
+                       :expected_errors,
+                       :inject,
+                       :response_logger,
+                       :service_name
+
+        def trace_request(env)
+          scope = build_scope(env)
+          span = scope.span
+
+          yield(span)
+        rescue *expected_errors => e
+          set_exception_tags(span, e)
+          raise
+        ensure
+          scope.close
+        end
+
+        def build_scope(env)
+          tracer.start_active_span(
+            operation_name,
+            tags: request_tags(env),
+          )
+        end
+
+        def inject_tracing(span, env)
+          tracer.inject(
+            span.context,
+            OpenTracing::FORMAT_RACK,
+            env[:request_headers],
+          )
+        end
+
+        def request_tags(env)
+          base_tags
+            .merge(http_tags(env))
+            .merge(faraday_tags(env))
+        end
+
+        def base_tags
+          {
+            'span.kind' => 'client',
+            'component' => component,
+            'peer.service_name' => service_name,
+          }.compact
+        end
+
+        def http_tags(env)
+          {
+            'http.method' => env[:method],
+            'http.url' => env[:url].to_s,
+          }
+        end
+
+        def faraday_tags(env)
+          {
+            'faraday.adapter' => @app.class.to_s,
+            'faraday.parallel' => env.parallel?,
+            'faraday.parse_body' => env.parse_body?,
+            'faraday.ssl_verify' => env.ssl.verify?,
+          }
+        end
+
+        def set_response_tags(span, response)
+          span.set_tag('http.status_code', response.status)
+
+          return if response.success?
+
+          set_http_error_tags(span, response)
+        end
+
+        def set_http_error_tags(span, response)
+          span.set_tag('error', true)
+          span.log_kv(
+            event: 'error',
+            message: response.body.to_s,
+            'error.kind': 'http',
+          )
+        end
+
+        def set_exception_tags(span, error)
+          span.set_tag('error', true)
+          span.log_kv(
+            event: 'error',
+            message: error.message,
+            'error.kind': error.class.to_s,
+            'stack': error.backtrace,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/opentracing/instrumentation/mongo.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module OpenTracing
+  module Instrumentation
+    # Mongo driver instrumentation. Support mongo gem version 2.x.
+    module Mongo
+      autoload :DirectSanitazer, 'opentracing/instrumentation/mongo/direct_sanitazer'
+      autoload :TraceSubscriber, 'opentracing/instrumentation/mongo/trace_subscriber'
+      autoload :QuerySanitazer, 'opentracing/instrumentation/mongo/query_sanitazer'
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module OpenTracing
+  module Instrumentation
+    module Mongo
+      # DirectSanitazer requests.
+      class DirectSanitazer
+        def sanitaze(command, command_name)
+          command = command.dup
+          command.delete(command_name)
+          command
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'bson'
+require 'date'
+require 'opentracing/instrumentation/mongo/direct_sanitazer'
+
+module OpenTracing
+  module Instrumentation
+    module Mongo
+      # QuerySanitazer clean private data from requests.
+      class QuerySanitazer < DirectSanitazer
+        DEFAULT_SAFE_CLASSES = [
+          TrueClass,
+          FalseClass,
+          Numeric,
+          Date,
+          Time,
+        ].freeze
+        DEFAULT_EXCLUDE_KEYS = %w[lsid].freeze
+
+        def initialize(
+          safe_classes: DEFAULT_SAFE_CLASSES,
+          exclude_keys: DEFAULT_EXCLUDE_KEYS
+        )
+          @safe_classes = safe_classes
+          @exclude_keys = exclude_keys
+        end
+
+        def sanitaze(command, command_name)
+          command_without_command_name = super(command, command_name)
+          exclude_keys.each do |key|
+            command_without_command_name.delete(key)
+          end
+          sanitaze_value(command_without_command_name)
+        end
+
+        private
+
+        attr_reader :safe_classes
+        attr_reader :exclude_keys
+
+        OBJECT_ID_PLACEHOLDER = '$oid'
+        STRING_PLACEHOLDER = '$string'
+        PLACEHOLDER = '?'
+
+        def sanitaze_value(value)
+          case value
+          when Hash
+            sanitaze_hash(value)
+          when Enumerable
+            sanitaze_array(value)
+          else
+            sanitaze_simple(value)
+          end
+        end
+
+        def sanitaze_simple(value)
+          case value
+          when BSON::ObjectId
+            OBJECT_ID_PLACEHOLDER
+          when String
+            STRING_PLACEHOLDER
+          when *safe_classes
+            value
+          else
+            PLACEHOLDER
+          end
+        end
+
+        def sanitaze_hash(hash)
+          hash.transform_values do |value|
+            sanitaze_value(value)
+          end
+        end
+
+        def sanitaze_array(array)
+          array.map do |value|
+            sanitaze_value(value)
+          end
+        end
+      end
+    end
+  end
+end