opentracing-instrumentation 0.1.0

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'redis/connection/ruby'
+require 'json'
+
+module OpenTracing
+  module Instrumentation
+    module Redis
+      # TracingDriverWrapper wrap redis driver
+      class TracingDriverWrapper
+        extend Forwardable
+
+        class << self
+          DEAFULT_BACKGROUND_DRIVER = ::Redis::Connection::Ruby
+
+          def connect(options)
+            connection = connect_backround_driver(options)
+
+            span_builder = options.fetch(:span_builder, SpanBuilder.new)
+
+            new(
+              connection: connection,
+              span_builder: span_builder,
+              host: options[:host],
+              port: options[:port],
+            )
+          end
+
+          private
+
+          def connect_backround_driver(options)
+            background_driver =
+              options.fetch(:background_driver, DEAFULT_BACKGROUND_DRIVER)
+            background_driver.connect(options)
+          end
+        end
+
+        attr_reader :connection
+        attr_reader :span_builder
+
+        def initialize(
+          connection:,
+          span_builder:,
+          host:,
+          port:
+        )
+          @connection = connection
+          @span_builder = span_builder
+          @host = host
+          @port = port
+        end
+
+        def_delegators :connection,
+                       :connected?,
+                       :disconnect,
+                       :timeout=
+
+        def write(command)
+          scope = start_pipeline_scope
+          connection.write(command).tap do
+            span_builder.write_log_command(scope.span, command) if scope
+          end
+        rescue StandardError => e
+          span_builder.write_error(scope.span, e, event: EVENT_WRITE) if scope
+          close_pipeline_scope
+          raise
+        end
+
+        def read
+          scope = pipeline_scope
+          connection.read.tap do |reply|
+            span_builder.write_log_reply(scope.span, reply) if scope
+          end
+        rescue StandardError => e
+          span_builder.write_error(scope.span, e, event: EVENT_READ) if scope
+          raise
+        ensure
+          close_pipeline_scope
+        end
+
+        private
+
+        attr_reader :pipeline_scope
+        attr_reader :error_writer
+
+        def peer_addr
+          "#{@host}:#{@port}"
+        end
+
+        def start_pipeline_scope
+          if @pipeline_scope
+            @pipeline_queue_size += 1
+            return @pipeline_scope
+          end
+
+          @pipeline_queue_size = 1
+          @pipeline_scope =
+            span_builder.start_active_scope(
+              connection.class,
+              peer_addr,
+            )
+        end
+
+        def close_pipeline_scope
+          return unless @pipeline_scope
+
+          @pipeline_queue_size -= 1
+
+          return if @pipeline_queue_size.positive?
+
+          @pipeline_scope.close
+          @pipeline_scope = nil
+        end
+      end
+    end
+  end
+end

data/lib/opentracing/instrumentation/sidekiq.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module OpenTracing
+  module Instrumentation
+    # Sidekiq instrumentation
+    module Sidekiq
+      autoload :ClientMiddleware,
+               'opentracing/instrumentation/sidekiq/client_middleware'
+
+      autoload :JobTagger,
+               'opentracing/instrumentation/sidekiq/job_tagger'
+
+      autoload :ServerMiddleware,
+               'opentracing/instrumentation/sidekiq/server_middleware'
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module OpenTracing
+  module Instrumentation
+    module Sidekiq
+      # Sidekiq producer middleware
+      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
+
+        def initialize(
+          tracer: OpenTracing.global_tracer,
+          tagger: JobTagger.new,
+          error_writter: Common::ErrorWriter.new,
+          span_kind: DEFAULT_SPAN_KIND,
+          span_name: DEFAULT_SPAN_NAME
+        )
+          @tracer = tracer
+          @tagger = tagger
+          @error_writter = error_writter
+          @span_kind = span_kind
+          @span_name = span_name
+        end
+
+        def call(_worker_class, job, _queue, _redis_pool)
+          scope = tracer.start_active_span(span_name, **build_span_args(job))
+          inject(scope.span.context, job)
+          log(scope.span, job) do
+            yield
+          end
+        ensure
+          scope.close
+        end
+
+        private
+
+        def log(span, job)
+          tagger.write_args_log(span, job['jid'], job['args'])
+
+          yield
+        rescue StandardError => e
+          error_writter.write_error(span, e)
+          raise
+        end
+
+        def build_span_args(job)
+          {
+            tags: tagger.build_tags(job, span_kind),
+          }
+        end
+
+        def inject(span_context, carrier)
+          tracer.inject(span_context, OpenTracing::FORMAT_TEXT_MAP, carrier)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module OpenTracing
+  module Instrumentation
+    module Sidekiq
+      # Span tags and logs building mixin
+      class JobTagger
+        LOG_JID_EVENT = 'job_id'
+        LOG_ARGS_EVENT = 'job_args'
+
+        DEFAULT_COMPONENT = 'sidekiq'
+
+        attr_accessor :component
+        attr_accessor :log_args
+
+        # @param component [String] component name
+        # @param log_args [TrueClass, FalseClass] enable attribute logging
+        def initialize(
+          component: DEFAULT_COMPONENT,
+          log_args: false
+        )
+          @component = component
+          @log_args = log_args
+
+          yield self if block_given?
+        end
+
+        # 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'],
+          }
+        end
+
+        # write job jid and args if log_args enabled
+        # @param span [OpenTracing::Span] target span
+        # @param jid [String] job id
+        # @param args [Array<Object>] argument list
+        def write_args_log(span, jid, args)
+          span.log_kv(
+            event: LOG_JID_EVENT,
+            jid: jid,
+          )
+
+          return unless log_args
+
+          span.log_kv(
+            event: LOG_ARGS_EVENT,
+            args: JSON.dump(args),
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module OpenTracing
+  module Instrumentation
+    module Sidekiq
+      # Sidekiq server middleware
+      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
+
+        def initialize(
+          tracer: OpenTracing.global_tracer,
+          tagger: JobTagger.new,
+          error_writter: Common::ErrorWriter.new,
+          span_kind: DEFAULT_SPAN_KIND,
+          span_name: DEFAULT_SPAN_NAME
+        )
+          @tracer = tracer
+          @tagger = tagger
+          @error_writter = error_writter
+          @span_kind = span_kind
+          @span_name = span_name
+        end
+
+        def call(_worker, job, _queue)
+          scope = tracer.start_active_span(span_name, **build_span_args(job))
+
+          log(scope.span, job) do
+            yield
+          end
+        ensure
+          scope.close
+        end
+
+        private
+
+        def log(span, job)
+          tagger.write_args_log(span, job['jid'], job['args'])
+
+          yield
+        rescue StandardError => e
+          error_writter.write_error(span, e)
+          raise
+        end
+
+        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)
+          [OpenTracing::Reference.follows_from(span_context)]
+        end
+      end
+    end
+  end
+end

data/lib/opentracing/instrumentation/sinatra.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module OpenTracing
+  module Instrumentation
+    # OpenTracing instrumentation for Sinatra
+    module Sinatra
+      autoload :TraceMiddleware,
+               'opentracing/instrumentation/sinatra/trace_middleware'
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'sinatra/base'
+
+module OpenTracing
+  module Instrumentation
+    module Sinatra
+      # TraceMiddleware for sinatra
+      #
+      # Usage
+      #   class MyApp < Sinatra::Base
+      #     use OpenTracing::Instrumentation::Sinatra::TraceMiddleware
+      #     set :tracer, MyTracer.instance # optionaly
+      #   end
+      module TraceMiddleware
+        def self.registered(app)
+          app.helpers self
+
+          app.set :tracer, OpenTracing.global_tracer
+          app.set :command_name, 'sinatra_request'
+
+          app.before do
+            start_span
+          end
+
+          app.after do
+            close_span
+          end
+        end
+
+        private
+
+        def start_span
+          @scope = settings.tracer.start_active_span(
+            settings.command_name,
+            tags: build_base_tags,
+          )
+        end
+
+        def close_span
+          set_response_span_tags(@scope.span, env)
+          @scope.close
+        end
+
+        def build_base_tags
+          {
+            'sinatra.app' => self.class.to_s,
+            'sinatra.environment' => settings.environment,
+            'sinatra.threaded' => settings.threaded,
+            'sinatra.show_exceptions' => settings.show_exceptions,
+          }
+        end
+
+        def set_response_span_tags(span, env)
+          sinatra_route = env['sinatra.route']
+          span.set_tag 'sinatra.route', sinatra_route
+
+          sinatra_error = env['sinatra.error']
+          span.set_tag('error', true) if sinatra_error
+        end
+      end
+    end
+  end
+end

data/lib/opentracing/instrumentation/thrift.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module OpenTracing
+  module Instrumentation
+    # OpenTracing instrumentation for Thrift client and server
+    module Thrift
+      autoload :Config,
+               'opentracing/instrumentation/thrift/config'
+      autoload :TracedProtocol,
+               'opentracing/instrumentation/thrift/traced_protocol'
+      autoload :TracedProtocolFactory,
+               'opentracing/instrumentation/thrift/traced_protocol_factory'
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module OpenTracing
+  module Instrumentation
+    module Thrift
+      # Config for TracedProtocol
+      class Config
+        attr_accessor :tracer,
+                      :write_operation_name,
+                      :read_operation_name
+
+        def initialize(
+          tracer: OpenTracing.global_tracer,
+          write_operation_name: 'thrift_write',
+          read_operation_name: 'thrift_read'
+        )
+          @tracer = tracer
+          @write_operation_name = write_operation_name
+          @read_operation_name = read_operation_name
+        end
+      end
+    end
+  end
+end