signalfx-rails-instrumentation 0.1.0

data/lib/rails/active_support/cache/dalli_tracer.rb

@@ -0,0 +1,106 @@
+require "method/tracer"
+
+module Dalli
+  class Tracer
+    class << self
+      def instrument(tracer: OpenTracing.global_tracer, active_span: nil)
+        ::Dalli::Server.class_eval do
+          @tracer = tracer
+          @active_span = active_span
+
+          class << self
+            attr_reader :tracer, :active_span
+          end
+
+          def tracer
+            self.class.tracer
+          end
+
+          def active_span
+            self.class.active_span
+          end
+
+          alias_method :request_without_instrumentation, :request
+
+          def request(op, *args)
+            tags = {
+              'component' => 'Dalli::Server',
+              'span.kind' => 'client',
+              'db.statement' => op.to_s,
+              'db.type' => 'memcached',
+              'peer.hostname' => hostname,
+              'peer.port' => port,
+              'peer.weight' => weight
+            }
+            # Method::Tracer.trace("Dalli::Server#request", tracer: tracer, child_of: active_span, tags: tags) do
+            #   request_without_instrumentation(op, *args)
+            # end
+            parent_span = active_span.respond_to?(:call) ? active_span.call : active_span
+            span = tracer.start_span("Dalli::Server#request", child_of: parent_span, tags: tags)
+
+            begin
+              request_without_instrumentation(op, *args)
+            rescue  => e
+              if span
+                span.set_tag("error", true)
+                span.log_kv(key: "message", value: error.message)
+              end
+            ensure
+              span.finish() if span
+            end
+          end
+        end
+
+        ::Dalli::Client.class_eval do
+          @tracer = tracer
+          @active_span = active_span
+
+          class << self
+            attr_reader :tracer, :active_span
+          end
+
+          def tracer
+            self.class.tracer
+          end
+
+          def active_span
+            self.class.active_span
+          end
+
+          alias_method :perform_without_instrumentation, :perform
+
+          def perform(*args)
+            parent_span = active_span.respond_to?(:call) ? active_span.call : active_span
+            span = tracer.start_span("Dalli::Client#perform", child_of: active_span, tags: {})
+
+            begin
+              perform_without_instrumentation(*args)
+            rescue => error
+              if span
+                span.set_tag("error", true)
+                span.log_kv(key: "message", value: error.message)
+              end
+            ensure
+              span.finish() if span
+            end
+            # Method::Tracer.trace("Dalli::Client#perform", tracer: tracer, child_of: active_span) do
+            #   perform_without_instrumentation(*args)
+            # end
+          end
+        end
+      end
+
+      def remove_instrumentation
+        ::Dalli::Server.class_eval do
+          alias_method :request, :request_without_instrumentation
+          remove_method :request_without_instrumentation
+        end
+
+        ::Dalli::Client.class_eval do
+          alias_method :perform, :perform_without_instrumentation
+          remove_method :perform_without_instrumentation
+        end
+      end
+    end
+  end
+end

data/lib/rails/active_support/cache/manual_tracer.rb

@@ -0,0 +1,24 @@
+module ActiveSupport
+  module Cache
+    module Tracer
+      class << self
+        def start_span(operation_name, tracer: OpenTracing.global_tracer, active_span: nil, start_time: Time.now, event:, **fields)
+          span = tracer.start_span(operation_name,
+                                   child_of: active_span.respond_to?(:call) ? active_span.call : active_span,
+                                   start_time: start_time,
+                                   tags: {
+                                    'component' => 'ActiveSupport::Cache',
+                                    'span.kind' => 'client',
+                                    'cache.key' => fields.fetch(:key, 'unknown')
+                                   })
+
+          if event == 'read'
+            span.set_tag('cache.hit', fields.fetch(:hit, false))
+          end
+
+          span
+        end
+      end
+    end
+  end
+end

data/lib/rails/active_support/cache/subscriber.rb

@@ -0,0 +1,62 @@
+module ActiveSupport
+  module Cache
+    module Tracer
+      class Subscriber
+        attr_reader :tracer, :active_span, :event, :operation_name
+
+        def initialize(tracer: OpenTracing.global_tracer, active_span: nil, event:)
+          @tracer = tracer
+          @active_span = active_span
+          @event = event
+          @operation_name = "cache.#{event}"
+        end
+
+        # For compatibility with Rails 3.2
+        def call(*args)
+          _, start, finish, _, payload = *args
+
+          span = Tracer.start_span(operation_name,
+                                    event: event,
+                                    tracer: tracer,
+                                    active_span: active_span,
+                                    start_time: start,
+                                    **payload)
+
+          if payload[:exception]
+            Rails::Tracer::SpanHelpers.set_error(span, payload[:exception_object] || payload[:exception])
+          end
+
+          span.finish(end_time: finish)
+        end
+
+        def start(name, _, payload)
+          span = tracer.start_span(operation_name,
+                                   child_of: active_span.respond_to?(:call) ? active_span.call : active_span,
+                                   tags: {
+                                    'component' => 'ActiveSupport::Cache',
+                                    'span.kind' => 'client'
+                                   })
+
+          payload[:__OT_SPAN__] = span
+        end
+
+        def finish(name, _, payload)
+          span = payload[:__OT_SPAN__]
+          return unless span
+
+          span.set_tag('cache.key', payload.fetch(:key, 'unknown'))
+
+          if event == 'read'
+            span.set_tag('cache.hit', payload.fetch(:hit, false))
+          end
+
+          if payload[:exception]
+            Rails::Tracer::SpanHelpers.set_error(span, payload[:exception_object] || payload[:exception])
+          end
+
+          span.finish
+        end
+      end
+    end
+  end
+end

data/lib/rails/active_support/cache/tracer.rb

@@ -0,0 +1,55 @@
+require 'rails/active_support/cache/core_ext'
+require 'rails/active_support/cache/manual_tracer'
+require 'rails/active_support/cache/subscriber'
+
+module ActiveSupport
+  module Cache
+    module Tracer
+      class << self
+        def instrument(tracer: OpenTracing.global_tracer, active_span: nil, dalli: false)
+          clear_subscribers
+          events = %w(read write generate delete clear)
+          @subscribers = events.map do |event|
+            subscriber = ActiveSupport::Cache::Tracer::Subscriber.new(tracer: tracer,
+                                                                      active_span: active_span,
+                                                                      event: event)
+            ActiveSupport::Notifications.subscribe("cache_#{event}.active_support", subscriber)
+          end
+
+          instrument_dalli(tracer: tracer, active_span: active_span) if dalli
+
+          self
+        end
+
+        def disable
+          if  @subscribers
+            @subscribers.each { |subscriber| ActiveSupport::Notifications.unsubscribe(subscriber) }
+            @subscribers.clear
+          end
+
+          self
+        end
+
+        alias :clear_subscribers :disable
+
+        def instrument_dalli(tracer:, active_span:)
+          return unless defined?(ActiveSupport::Cache::DalliStore)
+          require 'rails/active_support/cache/dalli_tracer'
+
+          Dalli::Tracer.instrument(tracer: tracer, active_span: active_span)
+          instrument_dalli_logger(active_span: active_span)
+        end
+
+        def instrument_dalli_logger(active_span:, level: Logger::ERROR)
+          return unless defined?(Tracing::Logger)
+          return unless active_span
+          return if [Tracing::Logger, Tracing::CompositeLogger].any? { |t| Dalli.logger.is_a?(t) }
+
+          tracing_logger = Tracing::Logger.new(active_span: active_span, level: level)
+          loggers = [tracing_logger, Dalli.logger].compact
+          Dalli.logger = Tracing::CompositeLogger.new(*loggers)
+        end
+      end
+    end
+  end
+end

data/lib/rails/defer_notifications.rb

@@ -0,0 +1,78 @@
+
+module Rails
+  module Tracer
+    module Defer
+      class << self
+        attr_reader :enabled
+
+        def enable
+          @enabled = true
+          @requests = {}
+          @parent_spans = {}
+        end
+
+        def requests
+          @requests
+        end
+
+        def add_parent(id, span)
+          @parent_spans[id] = span
+        end
+
+        def defer_span(id:, spaninfo:, tracer: OpenTracing.global_tracer)
+          if @requests[id].nil?
+            @requests[id] = []
+          end
+
+          # if this is a process_action then the request is complete, so we can write out the span
+          if spaninfo['event'] == 'process_action.action_controller'
+
+            # check if we've registered a parent span
+            # at this point, only a rack span
+            parent_span = @parent_spans[id]
+
+            if parent_span.nil?
+              # use process_action as the parent span for this request
+              parent_span = tracer.start_span(spaninfo['name'],
+                                              start_time: spaninfo['start'],
+                                              tags: spaninfo['tags'])
+            else
+              # if we have another parent span and process_action will
+              # not need to be used as a parent span, add it to the list
+              # to write out with all the others
+              @requests[id] << spaninfo
+            end
+
+            # each of the stored notifications with the current request id will
+            # be written out as spans
+            write_spans(notifications: @requests[id], parent_span: parent_span)
+
+            # the rack span will finish on its own, but we need to finish if we
+            # started a parent span using the process_action notification
+            parent_span.finish(end_time: spaninfo['finish']) if @parent_spans[id].nil?
+
+            # now that all spans are written, these can be deleted to free up space
+            @requests.delete(id)
+            @parent_spans.delete(id)
+          else
+            # this isn't a span that specifically means anything, so
+            # just save the span info
+            @requests[id] << spaninfo
+          end
+
+        end
+
+        def write_spans(notifications: [], parent_span: nil, tracer: OpenTracing.global_tracer)
+          notifications.each do |spaninfo|
+            span = tracer.start_span(spaninfo['name'],
+                                     child_of: parent_span,
+                                     start_time: spaninfo['start'],
+                                     tags: spaninfo['tags'])
+
+            span.finish(end_time: spaninfo['finish'])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails/rack/tracer.rb

@@ -0,0 +1,61 @@
+module Rails
+  module Rack
+    class Tracer
+      class << self
+        def instrument(tracer: OpenTracing.global_tracer, middlewares: Rails.configuration.middleware)
+          return unless defined?(::Rack::Tracer)
+          @owns_all_middlewares = false
+          unless middlewares.include?(::Rack::Tracer)
+            middlewares.use(::Rack::Tracer, tracer: tracer)
+            @owns_all_middlewares = true
+          end
+          middlewares.insert_after(::Rack::Tracer, Rails::Rack::Tracer)
+        end
+
+        def disable(middlewares: Rails.configuration.middleware)
+          middlewares.delete(Rails::Rack::Tracer)
+          if @owns_all_middlewares
+            middlewares.delete(::Rack::Tracer)
+            @owns_all_middlewares = false
+          end
+        rescue
+        end
+      end
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env)
+      ensure
+        enhance_rack_span(env)
+      end
+
+      private
+
+      def enhance_rack_span(env)
+        span = extract_span(env)
+        if span && route_found?(env)
+          span.operation_name = operation_name(env)
+        end
+      end
+
+      def extract_span(env)
+        env['rack.span']
+      end
+
+      def route_found?(env)
+        env["action_dispatch.request.path_parameters"]
+      end
+
+      def operation_name(env)
+        path_parameters = env["action_dispatch.request.path_parameters"]
+        action_controller = env["action_controller.instance"]
+        controller = action_controller ? action_controller.class.to_s : path_parameters[:controller]
+        action = path_parameters[:action]
+        "#{controller}##{action}"
+      end
+    end
+  end
+end

data/lib/rails/span_helpers.rb

@@ -0,0 +1,24 @@
+module Rails
+  module Tracer
+    module SpanHelpers
+      class << self
+        def set_error(span, exception)
+          span.set_tag('error', true)
+
+          case exception
+          when Array
+            exception_class, exception_message = exception
+            span.log(event: 'error', :'error.kind' => exception_class, message: exception_message)
+          when Exception
+            span.log(event: 'error', :'error.object' => exception)
+          end
+        end
+        def rack_span(payload)
+          # if rack tracing is disabled, this will just be nil
+          headers = payload.fetch(:headers, nil)
+          headers.env['rack.span'] if !headers.nil?
+        end
+      end
+    end
+  end
+end

data/lib/rails/tracer.rb

@@ -0,0 +1,38 @@
+require "rails/span_helpers"
+require "rails/defer_notifications"
+require "rails/rack/tracer"
+require "rails/active_record/tracer"
+require "rails/active_support/cache/tracer"
+require "rails/action_controller/tracer"
+require "rails/action_view/tracer"
+
+module Rails
+  module Tracer
+    class << self
+      def instrument(tracer: OpenTracing.global_tracer, active_span: nil,
+                     rack: false, middlewares: Rails.configuration.middleware,
+                     active_record: true,
+                     active_support_cache: true, dalli: false,
+                     action_controller: true,
+                     action_view: true,
+                     full_trace: false)
+        Rails::Rack::Tracer.instrument(tracer: tracer, middlewares: middlewares) if rack
+        ActiveRecord::Tracer.instrument(tracer: tracer, active_span: active_span) if active_record
+        ActiveSupport::Cache::Tracer.instrument(tracer: tracer, active_span: active_span, dalli: dalli) if active_support_cache
+        ActionController::Tracer.instrument(tracer: tracer, active_span: active_span) if action_controller
+        ActionView::Tracer.instrument(tracer: tracer, active_span: active_span) if action_view
+
+        # hold the requests until they can be written
+        Rails::Tracer::Defer.enable if full_trace
+      end
+
+      def disable
+        ActiveRecord::Tracer.disable
+        ActiveSupport::Cache::Tracer.disable
+        Rails::Rack::Tracer.disable
+        ActionController::Tracer.disable
+        ActionView::Tracer.disable
+      end
+    end
+  end
+end