newrelic_rpm 3.6.0.83 → 3.6.1.85.beta

data/lib/new_relic/agent/instrumentation/rails/action_controller.rb

@@ -4,13 +4,13 @@
 
 DependencyDetection.defer do
   @name = :rails21_view
-  
+
   depends_on do
     !NewRelic::Agent.config[:disable_view_instrumentation] &&
     defined?(ActionController) && defined?(ActionController::Base) && defined?(ActionView::PartialTemplate) && defined?(ActionView::Template) &&
     defined?(Rails::VERSION::STRING) && Rails::VERSION::STRING =~ /^2\.1\./   # Rails 2.1 &&
   end
-  
+
   executes do
     ::NewRelic::Agent.logger.info 'Installing Rails 2.1 View instrumentation'
   end
@@ -28,81 +28,81 @@ end
 
 DependencyDetection.defer do
   @name = :old_rails_view
-  
+
   depends_on do
     !NewRelic::Agent.config[:disable_view_instrumentation] &&
     defined?(ActionController) && defined?(ActionController::Base) &&
-    defined?(Rails::VERSION::STRING) && Rails::VERSION::STRING =~ /^(1\.|2\.0)/  # Rails 1.* - 2.0 
+    defined?(Rails::VERSION::STRING) && Rails::VERSION::STRING =~ /^(1\.|2\.0)/  # Rails 1.* - 2.0
   end
-  
+
   executes do
     ::NewRelic::Agent.logger.info 'Installing Rails 1.* - 2.0 View instrumentation'
   end
-  
+
   executes do
     ActionController::Base.class_eval do
       add_method_tracer :render, 'View/#{newrelic_metric_path}/Rendering'
     end
-    
+
   end
 end
 
 DependencyDetection.defer do
   @name = :rails23_view
-  
+
   depends_on do
     !NewRelic::Agent.config[:disable_view_instrumentation] &&
     defined?(ActionView) && defined?(ActionView::Template) && defined?(ActionView::RenderablePartial) &&
-    defined?(Rails::VERSION::STRING) && Rails::VERSION::STRING =~ /^2\.[23]/ 
+    defined?(Rails::VERSION::STRING) && Rails::VERSION::STRING =~ /^2\.[23]/
   end
 
   executes do
     ::NewRelic::Agent.logger.info 'Installing Rails 2.2 - 2.3 View instrumentation'
   end
-  
-  executes do    
+
+  executes do
     ActionView::RenderablePartial.module_eval do
       add_method_tracer :render_partial, 'View/#{path[%r{^(/.*/)?(.*)$},2]}/Partial'
     end
     ActionView::Template.class_eval do
       add_method_tracer :render, 'View/#{path[%r{^(/.*/)?(.*)$},2]}/Rendering'
     end
-  end  
+  end
 end
 
 DependencyDetection.defer do
   @name = :rails2_controller
-  
+
   depends_on do
     defined?(ActionController) && defined?(ActionController::Base)
   end
-  
+
   depends_on do
     defined?(Rails) && Rails::VERSION::MAJOR.to_i == 2
   end
-  
+
   executes do
     ::NewRelic::Agent.logger.info 'Installing Rails 2 Controller instrumentation'
   end
-  
+
   executes do
     ActionController::Base.class_eval do
       include NewRelic::Agent::Instrumentation::ControllerInstrumentation
-      
+
       # Compare with #alias_method_chain, which is not available in
       # Rails 1.1:
       alias_method :perform_action_without_newrelic_trace, :perform_action
       alias_method :perform_action, :perform_action_with_newrelic_trace
       private :perform_action
-      
+
       def self.newrelic_write_attr(attr_name, value) # :nodoc:
         write_inheritable_attribute(attr_name, value)
       end
-      
+
       def self.newrelic_read_attr(attr_name) # :nodoc:
         read_inheritable_attribute(attr_name)
       end
-      
+
       # determine the path that is used in the metric name for
       # the called controller action
       def newrelic_metric_path(action_name_override = nil)

data/lib/new_relic/agent/instrumentation/rails/errors.rb

@@ -4,7 +4,7 @@
 
 DependencyDetection.defer do
   @name = :rails2_error
-  
+
   depends_on do
     defined?(ActionController) && defined?(ActionController::Base)
   end
@@ -15,8 +15,8 @@ DependencyDetection.defer do
 
   executes do
     ::NewRelic::Agent.logger.info 'Installing Rails 2 Error instrumentation'
-  end  
-  
+  end
+
   executes do
 
     ActionController::Base.class_eval do
@@ -26,12 +26,12 @@ DependencyDetection.defer do
       # but we replaced that global method with NewRelic::Agent#notice_error.
       # Use that one outside of controller actions.
       def newrelic_notice_error(exception, custom_params = {})
-        NewRelic::Agent::Instrumentation::MetricFrame.notice_error exception, :custom_params => custom_params, :request => request
+        NewRelic::Agent::Transaction.notice_error exception, :custom_params => custom_params, :request => request
       end
 
       def rescue_action_with_newrelic_trace(exception)
         rescue_action_without_newrelic_trace exception
-        NewRelic::Agent::Instrumentation::MetricFrame.notice_error exception, :request => request
+        NewRelic::Agent::Transaction.notice_error exception, :request => request
       end
 
       # Compare with #alias_method_chain, which is not available in

data/lib/new_relic/agent/instrumentation/rails3/errors.rb

@@ -10,7 +10,7 @@ module NewRelic
           def newrelic_notice_error(exception, custom_params = {})
             filtered_params = (respond_to? :filter_parameters) ? filter_parameters(params) : params
             filtered_params.merge!(custom_params)
-            NewRelic::Agent::Instrumentation::MetricFrame.notice_error( \
+            NewRelic::Agent::Transaction.notice_error( \
                 exception, \
                 :request => request, \
                 :metric => newrelic_metric_path, \
@@ -24,9 +24,9 @@ end
 
 DependencyDetection.defer do
   @name = :rails3_error
-  
+
   depends_on do
-    defined?(::Rails) && ::Rails.respond_to?(:version) && ::Rails.version.to_i == 3
+    defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 3
   end
 
   depends_on do

data/lib/new_relic/agent/instrumentation/rails4/action_controller.rb

@@ -1,6 +1,7 @@
 # encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+require 'new_relic/agent/instrumentation/action_controller_subscriber'
 
 module NewRelic
   module Agent
@@ -14,31 +15,6 @@ module NewRelic
           def self.newrelic_read_attr(attr_name) # :nodoc:
             read_inheritable_attribute(attr_name)
           end
-
-          # determine the path that is used in the metric name for
-          # the called controller action
-          def newrelic_metric_path(action_name_override = nil)
-            action_part = action_name_override || action_name
-            if action_name_override || self.class.action_methods.include?(action_part)
-              "#{self.class.controller_path}/#{action_part}"
-            else
-              "#{self.class.controller_path}/(other)"
-            end
-          end
-
-          def process_action(*args)
-            # skip instrumentation if we are in an ignored action
-            if _is_filtered?('do_not_trace')
-              NewRelic::Agent.disable_all_tracing do
-                return super
-              end
-            end
-
-            perform_action_with_newrelic_trace(:category => :controller, :name => self.action_name, :path => newrelic_metric_path, :params => request.filtered_parameters, :class_name => self.class.name)  do
-              super
-            end
-          end
-
         end
       end
     end
@@ -65,5 +41,7 @@ DependencyDetection.defer do
       include NewRelic::Agent::Instrumentation::ControllerInstrumentation
       include NewRelic::Agent::Instrumentation::Rails4::ActionController
     end
+    NewRelic::Agent::Instrumentation::ActionControllerSubscriber \
+      .subscribe(/^process_action.action_controller$/)
   end
 end

data/lib/new_relic/agent/instrumentation/rails4/action_view.rb

@@ -1,120 +1,7 @@
 # encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-# Listen for ActiveSupport::Notifications events for ActionView render
-# events.  Write metric data and transaction trace segments for each event.
-module NewRelic
-  module Agent
-    module Instrumentation
-      class ActionViewSubscriber
-        def initialize
-          @queue_key = ['NewRelic', self.class.name, object_id].join('-')
-        end
-
-        def self.subscribe
-          if !subscribed?
-            ActiveSupport::Notifications.subscribe(/render_.+\.action_view$/,
-                                                   new)
-          end
-        end
-
-        def self.subscribed?
-          # TODO: need to talk to Rails core about an API for this,
-          # rather than digging through Listener ivars
-          ActiveSupport::Notifications.notifier.instance_variable_get(:@subscribers) \
-            .find{|s| s.instance_variable_get(:@delegate).class == self }
-        end
-
-        def start(name, id, payload)
-          event = RenderEvent.new(name, Time.now, nil, id, payload)
-          parent = event_stack[id].last
-          event.parent = parent
-          parent << event if parent
-          event_stack[id].push event
-
-          if NewRelic::Agent.is_execution_traced? && event.recordable?
-            event.scope = NewRelic::Agent.instance.stats_engine \
-              .push_scope(event.metric_name, event.time)
-          end
-        end
-
-        def finish(name, id, payload)
-          event = event_stack[id].pop
-          event.end = Time.now
-
-          if NewRelic::Agent.is_execution_traced? && event.recordable?
-            record_metrics(event)
-            NewRelic::Agent.instance.stats_engine \
-              .pop_scope(event.scope, event.duration, event.end)
-          end
-        end
-
-        def record_metrics(event)
-          NewRelic::Agent.instance.stats_engine \
-            .record_metrics(event.metric_name,
-                            Helper.milliseconds_to_seconds(event.duration),
-                            :scoped => true)
-        end
-
-        def event_stack
-          Thread.current[@queue_key] ||= Hash.new {|h,id| h[id] = [] }
-        end
-
-        if defined?(ActiveSupport::Notifications::Event)
-          class RenderEvent < ActiveSupport::Notifications::Event
-            attr_accessor :parent, :scope
-
-            # 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/(unknown)/Partial'
-            end
-
-            def metric_name
-              if parent && (payload[:virtual_path] ||
-                  (parent.payload[:identifier] =~ /template$/))
-                return parent.metric_name
-              elsif payload[: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
-                '(unknown)'
-              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
-end
+require 'new_relic/agent/instrumentation/action_view_subscriber'
 
 DependencyDetection.defer do
   @name = :rails4_view
@@ -133,6 +20,6 @@ DependencyDetection.defer do
   end
 
   executes do
-    NewRelic::Agent::Instrumentation::ActionViewSubscriber.subscribe
+    NewRelic::Agent::Instrumentation::ActionViewSubscriber.subscribe(/render_.+\.action_view$/)
   end
 end

data/lib/new_relic/agent/instrumentation/rails4/active_record.rb

@@ -1,87 +1,7 @@
 # encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-require 'new_relic/agent/instrumentation/active_record_helper'
-
-# Listen for ActiveSupport::Notifications events for ActiveRecord query
-# events.  Write metric data, transaction trace segments and slow sql
-# nodes for each event.
-module NewRelic
-  module Agent
-    module Instrumentation
-      class ActiveRecordSubscriber
-        include NewRelic::Agent::Instrumentation
-
-        def self.subscribed?
-          # TODO: need to talk to Rails core about an API for this,
-          # rather than digging through Listener ivars
-          ActiveSupport::Notifications.notifier.listeners_for('sql.active_record') \
-            .find{|l| l.instance_variable_get(:@delegate).class == self }
-        end
-
-        def call(*args)
-          return unless NewRelic::Agent.is_execution_traced?
-
-          event = ActiveSupport::Notifications::Event.new(*args)
-          record_metrics(event)
-          notice_sql(event)
-        end
-
-        def notice_sql(event)
-          config = active_record_config_for_event(event)
-          metric = base_metric(event)
-
-          # enter transaction trace segment
-          scope = NewRelic::Agent.instance.stats_engine.push_scope(metric, event.time)
-
-          NewRelic::Agent.instance.transaction_sampler \
-            .notice_sql(event.payload[:sql], config,
-                        Helper.milliseconds_to_seconds(event.duration))
-
-          NewRelic::Agent.instance.sql_sampler \
-            .notice_sql(event.payload[:sql], metric, config,
-                        Helper.milliseconds_to_seconds(event.duration))
-
-          # exit transaction trace segment
-          NewRelic::Agent.instance.stats_engine.pop_scope(scope, event.duration, event.end)
-        end
-
-        def record_metrics(event)
-          base = base_metric(event)
-          NewRelic::Agent.instance.stats_engine.record_metrics(base,
-                              Helper.milliseconds_to_seconds(event.duration),
-                              :scoped => true)
-
-          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.each do |metric_name|
-            NewRelic::Agent.instance.stats_engine.record_metrics(metric_name,
-                                            Helper.milliseconds_to_seconds(event.duration),
-                                            :scoped => false)
-          end
-        end
-
-        def base_metric(event)
-          ActiveRecordHelper.metric_for_name(event.payload[:name]) ||
-            ActiveRecordHelper.metric_for_sql(NewRelic::Helper.correctly_encoded(event.payload[:sql]))
-        end
-
-        def active_record_config_for_event(event)
-          return unless event.payload[:connection_id]
-
-          # TODO: This will not work for JRuby and in any case we want
-          # this to be part of the event meta data so it doesn't have
-          # to be dug out of an ivar.
-          connection = ObjectSpace._id2ref(event.payload[:connection_id])
-          connection.instance_variable_get(:@config) if connection
-        end
-      end
-    end
-  end
-end
+require 'new_relic/agent/instrumentation/active_record_subscriber'
 
 DependencyDetection.defer do
   @name = :active_record
@@ -98,7 +18,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing ActiveRecord instrumentation'
+    ::NewRelic::Agent.logger.info 'Installing ActiveRecord 4 instrumentation'
   end
 
   executes do

data/lib/new_relic/agent/instrumentation/rails4/errors.rb

@@ -10,10 +10,9 @@ module NewRelic
           def newrelic_notice_error(exception, custom_params = {})
             filtered_params = (respond_to? :filter_parameters) ? filter_parameters(params) : params
             filtered_params.merge!(custom_params)
-            NewRelic::Agent::Instrumentation::MetricFrame.notice_error( \
+            NewRelic::Agent::Transaction.notice_error( \
                 exception, \
                 :request => request, \
-                :metric => newrelic_metric_path, \
                 :custom_params => filtered_params)
           end
         end
@@ -24,9 +23,9 @@ end
 
 DependencyDetection.defer do
   @name = :rails4_error
-  
+
   depends_on do
-    defined?(::Rails) && ::Rails.respond_to?(:version) && ::Rails.version.to_i == 4
+    defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 4
   end
 
   depends_on do