oneapm_rpm 1.1.0

data/lib/one_apm/inst/rails3/errors.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+module OneApm
+  module Agent
+    module Instrumentation
+      module Rails3
+        module Errors
+          def oneapm_notice_error(exception, custom_params = {})
+            filtered_params = (respond_to? :filter_parameters) ? filter_parameters(params) : params
+            filtered_params.merge!(custom_params)
+            OneApm::Transaction.notice_error( \
+                exception, \
+                :request => request, \
+                :metric => oneapm_metric_path, \
+                :custom_params => filtered_params)
+          end
+        end
+      end
+    end
+  end
+end
+
+LibraryDetection.defer do
+  @name = :rails3_error
+
+  depends_on do
+    defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 3
+  end
+
+  depends_on do
+    defined?(ActionController) && defined?(ActionController::Base)
+  end
+
+  executes do
+    ::OneApm::Agent.logger.info 'Installing Rails 3 Error instrumentation'
+  end
+
+  executes do
+    class ActionController::Base
+      include OneApm::Agent::Instrumentation::Rails3::Errors
+    end
+  end
+end

data/lib/one_apm/inst/rails4/action_controller.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+require 'one_apm/inst/rails4/action_controller_subscriber'
+
+
+LibraryDetection.defer do
+  @name = :rails4_controller
+
+  depends_on do
+    defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 4
+  end
+
+  depends_on do
+    defined?(ActionController) && defined?(ActionController::Base)
+  end
+
+  executes do
+    ::OneApm::Agent.logger.info 'Installing Rails 4 Controller instrumentation'
+  end
+
+  executes do
+    class ActionController::Base
+      include OneApm::Agent::Instrumentation::TransactionBase
+    end
+    OneApm::Agent::Instrumentation::ActionControllerSubscriber \
+      .subscribe(/^process_action.action_controller$/)
+  end
+end

data/lib/one_apm/inst/rails4/action_controller_subscriber.rb

@@ -0,0 +1,121 @@
+# encoding: utf-8
+require 'one_apm/inst/support/evented_subscriber'
+require 'one_apm/inst/support/ignore_actions'
+
+module OneApm
+  module Agent
+    module Instrumentation
+      class ActionControllerSubscriber < EventedSubscriber
+
+        def start(name, id, payload) #THREAD_LOCAL_ACCESS
+          state = TransactionState.tl_get
+          request = state.request
+          event = ControllerEvent.new(name, Time.now, nil, id, payload, request)
+          push_event(event)
+
+          if state.is_execution_traced? && !event.ignored?
+            start_transaction(state, event)
+          else
+            # if this transaction is ignored, make sure child
+            # transaction are also ignored
+            state.current_transaction.ignore! if state.current_transaction
+            OneApm::Agent.instance.push_trace_execution_flag(false)
+          end
+        rescue => e
+          log_notification_error(e, name, 'start')
+        end
+
+        def finish(name, id, payload) #THREAD_LOCAL_ACCESS
+          event = pop_event(id)
+          event.payload.merge!(payload)
+
+          state = TransactionState.tl_get
+
+          if state.is_execution_traced? && !event.ignored?
+            stop_transaction(state, event)
+          else
+            Agent.instance.pop_trace_execution_flag
+          end
+        rescue => e
+          log_notification_error(e, name, 'finish')
+        end
+
+        def start_transaction(state, event)
+          Transaction.start(state, :controller,
+                            :request          => event.request,
+                            :filtered_params  => filter(event.payload[:params]),
+                            :apdex_start_time => event.queue_start,
+                            :transaction_name => event.metric_name)
+        end
+
+        def stop_transaction(state, event)
+          txn = state.current_transaction
+          txn.ignore_apdex!   if event.apdex_ignored?
+          txn.ignore_enduser! if event.enduser_ignored?
+          Transaction.stop(state)
+        end
+
+        def filter(params)
+          munged_params = params.dup
+          munged_params.delete('controller')
+          munged_params.delete('action')
+          filters = Rails.application.config.filter_parameters
+          ActionDispatch::Http::ParameterFilter.new(filters).filter(munged_params)
+        end
+      end
+
+      class ControllerEvent < Event
+        attr_accessor :parent
+        attr_reader :queue_start, :request
+
+        def initialize(name, start, ending, transaction_id, payload, request)
+          # We have a different initialize parameter list, so be explicit
+          super(name, start, ending, transaction_id, payload)
+
+          @request = request
+          @controller_class = payload[:controller].split('::') \
+            .inject(Object){|m,o| m.const_get(o)}
+
+          if request && request.respond_to?(:env)
+            @queue_start = QueueTime.parse_frontend_timestamp(request.env, self.time)
+          end
+        end
+
+        def metric_name
+          @metric_name || "Controller/#{metric_path}/#{metric_action}"
+        end
+
+        def metric_path
+          @controller_class.controller_path
+        end
+
+        def metric_action
+          payload[:action]
+        end
+
+        def ignored?
+          _is_filtered?(TransactionBase::OA_DO_NOT_TRACE_KEY)
+        end
+
+        def apdex_ignored?
+          _is_filtered?(TransactionBase::OA_IGNORE_APDEX_KEY)
+        end
+
+        def enduser_ignored?
+          _is_filtered?(TransactionBase::OA_IGNORE_ENDUSER_KEY)
+        end
+
+        def _is_filtered?(key)
+          OneApm::Agent::Instrumentation::IgnoreActions.is_filtered?(
+            key,
+            @controller_class,
+            metric_action)
+        end
+
+        def to_s
+          "#<OneApm::Agent::Instrumentation::ControllerEvent:#{object_id} name: \"#{name}\" id: #{transaction_id} payload: #{payload}}>"
+        end
+      end
+    end
+  end
+end

data/lib/one_apm/inst/rails4/action_view.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+require 'one_apm/inst/rails4/action_view_subscriber'
+
+LibraryDetection.defer do
+  @name = :rails4_view
+
+  depends_on do
+    defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 4
+  end
+
+  depends_on do
+    !OneApm::Agent.config[:disable_view_instrumentation] &&
+      !OneApm::Agent::Instrumentation::ActionViewSubscriber.subscribed?
+  end
+
+  executes do
+    ::OneApm::Agent.logger.info 'Installing Rails 4 view instrumentation'
+  end
+
+  executes do
+    OneApm::Agent::Instrumentation::ActionViewSubscriber.subscribe(/render_.+\.action_view$/)
+  end
+end

data/lib/one_apm/inst/rails4/action_view_subscriber.rb

@@ -0,0 +1,93 @@
+# encoding: utf-8
+require 'one_apm/inst/support/evented_subscriber'
+
+# Listen for ActiveSupport::Notifications events for ActionView render
+# events.  Write metric data and transaction trace segments for each event.
+module OneApm
+  module Agent
+    module Instrumentation
+      class ActionViewSubscriber < EventedSubscriber
+        def start(name, id, payload) #THREAD_LOCAL_ACCESS
+          event = RenderEvent.new(name, Time.now, nil, id, payload)
+          push_event(event)
+
+          state = OneApm::TransactionState.tl_get
+
+          if state.is_execution_traced? && event.recordable?
+            stack = state.traced_method_stack
+            event.frame = stack.push_frame(state, :action_view, event.time)
+          end
+        rescue => e
+          log_notification_error(e, name, 'start')
+        end
+
+        def finish(name, id, payload) #THREAD_LOCAL_ACCESS
+          event = pop_event(id)
+
+          state = OneApm::TransactionState.tl_get
+
+          if state.is_execution_traced? && event.recordable?
+            stack = state.traced_method_stack
+            frame = stack.pop_frame(state, event.frame, event.metric_name, event.end)
+            record_metrics(event, frame)
+          end
+        rescue => e
+          log_notification_error(e, name, 'finish')
+        end
+
+        def record_metrics(event, frame) #THREAD_LOCAL_ACCESS
+          exclusive = event.duration - frame.children_time
+          OneApm::Agent.instance.stats_engine.tl_record_scoped_and_unscoped_metrics(
+            event.metric_name, nil, event.duration, exclusive)
+        end
+
+        class RenderEvent < Event
+          # Nearly every "render_blah.action_view" event has a child
+          # in the form of "!render_blah.action_view".  The children
+          # are the ones we want to record.  There are a couple
+          # special cases of events without children.
+          def recordable?
+            name[0] == '!' ||
+              metric_name == 'View/text template/Rendering' ||
+              metric_name == "View/#{OneApm::Transaction::UNKNOWN_METRIC}/Partial"
+          end
+
+          def metric_name
+            if parent && (payload[:virtual_path] ||
+                          (parent.payload[:identifier] =~ /template$/))
+              return parent.metric_name
+            elsif payload.key?(:virtual_path)
+              identifier = payload[:virtual_path]
+            else
+              identifier = payload[:identifier]
+            end
+
+            # memoize
+            @metric_name ||= "View/#{metric_path(identifier)}/#{metric_action(name)}"
+            @metric_name
+          end
+
+          def metric_path(identifier)
+            if identifier == nil
+              'file'
+            elsif identifier =~ /template$/
+              identifier
+            elsif (parts = identifier.split('/')).size > 1
+              parts[-2..-1].join('/')
+            else
+              OneApm::Transaction::UNKNOWN_METRIC
+            end
+          end
+
+          def metric_action(name)
+            case name
+            when /render_template.action_view$/  then 'Rendering'
+            when 'render_partial.action_view'    then 'Partial'
+            when 'render_collection.action_view' then 'Partial'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/one_apm/inst/rails4/active_record_subscriber.rb

@@ -0,0 +1,96 @@
+# encoding: utf-8
+require 'one_apm/agent/database/active_record_helper'
+require 'one_apm/inst/support/evented_subscriber'
+
+# Listen for ActiveSupport::Notifications events for ActiveRecord query
+# events.  Write metric data, transaction trace segments and slow sql
+# nodes for each event.
+module OneApm
+  module Agent
+    module Instrumentation
+      class ActiveRecordSubscriber < EventedSubscriber
+        CACHED_QUERY_NAME = 'CACHE'.freeze unless defined? CACHED_QUERY_NAME
+
+        def start(name, id, payload) #THREAD_LOCAL_ACCESS
+          return if payload[:name] == CACHED_QUERY_NAME
+          return unless OneApm::Agent.tl_is_execution_traced?
+          super
+        rescue => e
+          log_notification_error(e, name, 'start')
+        end
+
+        def finish(name, id, payload) #THREAD_LOCAL_ACCESS
+          return if payload[:name] == CACHED_QUERY_NAME
+          state = OneApm::TransactionState.tl_get
+          return unless state.is_execution_traced?
+          event = pop_event(id)
+          record_metrics(event)
+          notice_sql(state, event)
+        rescue => e
+          log_notification_error(e, name, 'finish')
+        end
+
+        def get_explain_plan( config, query )
+          connection = OneApm::Agent::Database.get_connection(config) do
+            ::ActiveRecord::Base.send("#{config[:adapter]}_connection",
+                                      config)
+          end
+          if connection && connection.respond_to?(:execute)
+            return connection.execute("EXPLAIN #{query}")
+          end
+        end
+
+        def notice_sql(state, event)
+          stack  = state.traced_method_stack
+          config = active_record_config_for_event(event)
+          metric = base_metric(event)
+
+          # enter transaction trace segment
+          frame = stack.push_frame(state, :active_record, event.time)
+
+          OneApm::Agent.instance.transaction_sampler \
+            .notice_sql(event.payload[:sql], config,
+                        Helper.milliseconds_to_seconds(event.duration),
+                        state, &method(:get_explain_plan))
+
+          OneApm::Agent.instance.sql_sampler \
+            .notice_sql(event.payload[:sql], metric, config,
+                        Helper.milliseconds_to_seconds(event.duration),
+                        state, &method(:get_explain_plan))
+
+          # exit transaction trace segment
+          stack.pop_frame(state, frame, metric, event.end)
+        end
+
+        def record_metrics(event) #THREAD_LOCAL_ACCESS
+          base = base_metric(event)
+
+          other_metrics = ActiveRecordHelper.rollup_metrics_for(base)
+          if config = active_record_config_for_event(event)
+            other_metrics << ActiveRecordHelper.remote_service_metric(config[:adapter], config[:host])
+          end
+          other_metrics.compact!
+
+          OneApm::Agent.instance.stats_engine.tl_record_scoped_and_unscoped_metrics(
+            base, other_metrics,
+            Helper.milliseconds_to_seconds(event.duration)
+          )
+        end
+
+        def base_metric(event)
+          ActiveRecordHelper.metric_for_name(event.payload[:name]) ||
+            ActiveRecordHelper.metric_for_sql(OneApm::Helper.correctly_encoded(event.payload[:sql]))
+        end
+
+        def active_record_config_for_event(event)
+          return unless event.payload[:connection_id]
+
+          connections = ::ActiveRecord::Base.connection_handler.connection_pool_list.map { |handler| handler.connections }.flatten
+          connection = connections.detect { |cnxn| cnxn.object_id == event.payload[:connection_id] }
+
+          connection.instance_variable_get(:@config) if connection
+        end
+      end
+    end
+  end
+end

data/lib/one_apm/inst/rails4/errors.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+module OneApm
+  module Agent
+    module Instrumentation
+      module Rails4
+        module Errors
+          def oneapm_notice_error(exception, custom_params = {})
+            filtered_params = (respond_to? :filter_parameters) ? filter_parameters(params) : params
+            filtered_params.merge!(custom_params)
+            OneApm::Transaction.notice_error( \
+                exception, \
+                :request => request, \
+                :custom_params => filtered_params)
+          end
+        end
+      end
+    end
+  end
+end
+
+LibraryDetection.defer do
+  @name = :rails4_error
+
+  depends_on do
+    defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 4
+  end
+
+  depends_on do
+    defined?(ActionController) && defined?(ActionController::Base)
+  end
+
+  executes do
+    ::OneApm::Agent.logger.info 'Installing Rails 4 Error instrumentation'
+  end
+
+  executes do
+    class ActionController::Base
+      include OneApm::Agent::Instrumentation::Rails4::Errors
+    end
+  end
+end