signalfx-rails-instrumentation 0.1.4 → 0.2.0

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

@@ -1,11 +0,0 @@
-module ActiveSupport
-  module Cache
-    class Store
-      # See the PR https://github.com/rails/rails/pull/15943/files
-      # In order to make the instrumentation to work we need to override the original implementation
-      def self.instrument
-        true
-      end
-    end
-  end
-end

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

@@ -1,106 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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) if span
-        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 if span
-        end
-      end
-    end
-  end
-end

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

@@ -1,55 +0,0 @@
-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

@@ -1,78 +0,0 @@
-
-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']) if span
-          end
-        end
-      end
-    end
-  end
-end

data/lib/rails/rack/tracer.rb

@@ -1,61 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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