newrelic_rpm 3.6.0.83 → 3.6.1.85.beta

data/lib/new_relic/agent/instrumentation/action_view_subscriber.rb

@@ -0,0 +1,88 @@
+# 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/evented_subscriber'
+
+# 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 < EventedSubscriber
+        def start(name, id, payload)
+          event = RenderEvent.new(name, Time.now, nil, id, payload)
+          push_event(event)
+
+          if NewRelic::Agent.is_execution_traced? && event.recordable?
+            event.scope = NewRelic::Agent.instance.stats_engine \
+              .push_scope(:action_view, event.time)
+          end
+        end
+
+        def finish(name, id, payload)
+          event = pop_event(id)
+
+          if NewRelic::Agent.is_execution_traced? && event.recordable?
+            record_metrics(event)
+            NewRelic::Agent.instance.stats_engine \
+              .pop_scope(event.scope, event.metric_name, event.end)
+          end
+        end
+
+        def record_metrics(event)
+          NewRelic::Agent.instance.stats_engine \
+            .record_metrics(event.metric_name,
+                            event.duration,
+                            :scoped => true)
+        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/(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

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

@@ -72,7 +72,7 @@ module NewRelic
         end
 
         def metric_for_sql(sql)
-          metric = NewRelic::Agent::Instrumentation::MetricFrame.database_metric_name
+          metric = NewRelic::Agent::Transaction.database_metric_name
           if metric.nil?
             if sql =~ /^(select|update|insert|delete|show)/i
               # Could not determine the model/operation so let's find a better

data/lib/new_relic/agent/instrumentation/active_record_helper.rb

@@ -32,7 +32,7 @@ module NewRelic
         end
 
         def metric_for_sql(sql)
-          metric = NewRelic::Agent::Instrumentation::MetricFrame.database_metric_name
+          metric = NewRelic::Agent::Transaction.database_metric_name
           if metric.nil?
             if sql =~ /^(select|update|insert|delete|show)/i
               # Could not determine the model/operation so let's find a better

data/lib/new_relic/agent/instrumentation/active_record_subscriber.rb

@@ -0,0 +1,84 @@
+# 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(:active_record, 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, metric, 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

data/lib/new_relic/agent/instrumentation/browser_monitoring_timings.rb

@@ -8,11 +8,12 @@ module NewRelic
       class BrowserMonitoringTimings
 
         def initialize(queue_time_in_seconds, transaction)
+          @transaction = transaction
           @now = Time.now.to_i
-          if transaction.nil?
+          if @transaction.nil?
             @start_time_in_seconds = 0.0
           else
-            @transaction_name = transaction.transaction_name
+            @transaction_name = transaction.transaction.name
             @start_time_in_seconds = transaction.start_time.to_i
           end
 

data/lib/new_relic/agent/instrumentation/controller_instrumentation.rb

@@ -2,7 +2,7 @@
 # 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/metric_frame'
+require 'new_relic/agent/transaction'
 require 'new_relic/agent/instrumentation/queue_time'
 module NewRelic
   module Agent
@@ -39,7 +39,6 @@ module NewRelic
           end
           def newrelic_notice_error(*args); end
           def new_relic_trace_controller_action(*args); yield; end
-          def newrelic_metric_path; end
           def perform_action_with_newrelic_trace(*args); yield; end
         end
 
@@ -75,6 +74,7 @@ module NewRelic
           def newrelic_write_attr(attr_name, value) # :nodoc:
             instance_variable_set "@#{attr_name}", value
           end
+
           def newrelic_read_attr(attr_name) # :nodoc:
             instance_variable_get "@#{attr_name}"
           end
@@ -167,12 +167,54 @@ module NewRelic
           end
         end
 
-        # Must be implemented in the controller class:
-        # Determine the path that is used in the metric name for
-        # the called controller action.  Of the form controller_path/action_name
-        #
-        def newrelic_metric_path(action_name_override = nil) # :nodoc:
-          raise "Not implemented!"
+        class TransactionNamer
+          def initialize(traced_obj)
+            @traced_obj = traced_obj
+            if (@traced_obj.is_a?(Class) || @traced_obj.is_a?(Module))
+              @traced_class_name = @traced_obj.name
+            else
+              @traced_class_name = @traced_obj.class.name
+            end
+          end
+
+          def name(options={})
+            name = "#{category_name(options[:category])}/#{path_name(options)}"
+          end
+
+          def category_name(type = nil)
+            type ||= Transaction.current && Transaction.current.type
+            case type
+            when :controller, nil then 'Controller'
+            when :task then 'OtherTransaction/Background'
+            when :rack then 'Controller/Rack'
+            when :uri then 'Controller'
+            when :sinatra then 'Controller/Sinatra'
+              # for internal use only
+            else type.to_s
+            end
+          end
+
+          def path_name(options={})
+            # if we have the path, use the path
+            path = options[:path]
+
+            class_name = options[:class_name] || @traced_class_name
+
+            # if we have an explicit action name option, use that
+            if options[:name]
+              path ||= [ class_name, options[:name] ].compact.join('/')
+            end
+
+            # if newrelic_metric_path() is defined, use that
+            if @traced_obj.respond_to?(:newrelic_metric_path)
+              path ||= @traced_obj.newrelic_metric_path
+            end
+
+            # fall back on just the traced class name
+            path ||= class_name
+
+            return path
+          end
         end
 
         # Yield to the given block with NewRelic tracing.  Used by
@@ -262,39 +304,58 @@ module NewRelic
           control = NewRelic::Control.instance
           return perform_action_with_newrelic_profile(args, &block) if control.profiling?
 
-          frame_data = _push_metric_frame(block_given? ? args : [])
+          txn = _start_transaction(block_given? ? args : [])
           begin
-            NewRelic::Agent.trace_execution_scoped frame_data.recorded_metrics, :force => frame_data.force_flag do
-              frame_data.start_transaction
-              begin
-                NewRelic::Agent::BusyCalculator.dispatcher_start frame_data.start
-                result = if block_given?
-                  yield
-                else
-                  perform_action_without_newrelic_trace(*args)
+            options = { :force => txn.force_flag, :transaction => true }
+            return yield if !(NewRelic::Agent.is_execution_traced? || options[:force])
+            options[:metric] = true if options[:metric].nil?
+            options[:deduct_call_time_from_parent] = true if options[:deduct_call_time_from_parent].nil?
+            start_time, expected_scope = NewRelic::Agent::MethodTracer::InstanceMethods::TraceExecutionScoped.trace_execution_scoped_header(options)
+
+            begin
+              NewRelic::Agent::BusyCalculator.dispatcher_start txn.start_time
+              result = if block_given?
+                         yield
+                       else
+                         perform_action_without_newrelic_trace(*args)
+                       end
+              if defined?(request) && request && defined?(response) && response
+                if !Agent.config[:disable_mobile_headers]
+                  NewRelic::Agent::BrowserMonitoring.insert_mobile_response_header(request, response)
                 end
-                if defined?(request) && request && defined?(response) && response
-                  if !Agent.config[:disable_mobile_headers]
-                    NewRelic::Agent::BrowserMonitoring.insert_mobile_response_header(request, response)
-                  end
-                end
-                result
-              rescue => e
-                frame_data.notice_error(e)
-                raise
               end
+              result
+            rescue => e
+              txn.notice_error(e)
+              raise
             end
+
           ensure
+            txn.freeze_name
+            metrics = recorded_metrics(txn)
+            txn_name = metrics.first
+
+            metric_names = Array(metrics)
+            first_name = metric_names.shift
+            scope = NewRelic::Agent.instance.stats_engine.scope_name
+            NewRelic::Agent::MethodTracer::InstanceMethods::TraceExecutionScoped.trace_execution_scoped_footer(start_time, first_name, metric_names, expected_scope, scope, options)
             NewRelic::Agent::BusyCalculator.dispatcher_finish
-            # Look for a metric frame in the thread local and process it.
+            # Look for a transaction in the thread local and process it.
             # Clear the thread local when finished to ensure it only gets called once.
-            frame_data.record_apdex unless ignore_apdex?
-            frame_data.pop
+            txn = Transaction.stop(txn_name)
+            txn.record_apdex(txn_name) unless ignore_apdex?
 
             NewRelic::Agent::TransactionInfo.get.ignore_end_user = true if ignore_enduser?
           end
         end
 
+        def recorded_metrics(txn)
+          metric_parser = NewRelic::MetricParser::MetricParser.for_metric_named(txn.name)
+          metrics = [txn.name]
+          metrics += metric_parser.summary_metrics unless txn.has_parent?
+          metrics
+        end
+
         protected
 
         def newrelic_request(args)
@@ -343,10 +404,9 @@ module NewRelic
         # Profile the instrumented call.  Dev mode only.  Experimental
         # - should definitely not be used on production applications
         def perform_action_with_newrelic_profile(args)
-          frame_data = _push_metric_frame(block_given? ? args : [])
+          txn = _start_transaction(block_given? ? args : [])
           val = nil
-          NewRelic::Agent.trace_execution_scoped frame_data.metric_name do
-            MetricFrame.current(true).start_transaction
+          NewRelic::Agent.trace_execution_scoped txn.metric_name do
             NewRelic::Agent.disable_all_tracing do
               # turn on profiling
               profile = RubyProf.profile do
@@ -361,78 +421,35 @@ module NewRelic
           end
           return val
         ensure
-          frame_data.pop
-        end
-
-        def transaction_name(options={})
-          name = "#{category_name(options)}/#{path_name(options)}"
-          NewRelic::Agent.instance.transaction_rules.rename(name)
-        end
-
-        def category_name(options)
-          case options[:category]
-            when :controller, nil then 'Controller'
-            when :task then 'OtherTransaction/Background' # 'Task'
-            when :rack then 'Controller/Rack' #'WebTransaction/Rack'
-            when :uri then 'Controller' #'WebTransaction/Uri'
-            when :sinatra then 'Controller/Sinatra' #'WebTransaction/Uri'
-              # for internal use only
-            else options[:category].to_s
-          end
-        end
-
-        def path_name(options)
-          if options.any?
-            options[:path] || path_class_and_action(options)
-          else
-            newrelic_metric_path
-          end
+          txn.pop
         end
 
-        def path_class_and_action(options)
-          metric_class = options[:class_name]
-
-          if !metric_class
-            if (self.is_a?(Class) || self.is_a?(Module))
-              metric_class = self.name
-            else
-              metric_class = self.class.name
-            end
-          end
-
-          [ metric_class, options[:name] ].compact.join('/')
-        end
-
-        # Write a metric frame onto a thread local if there isn't already one there.
+        # Write a transaction onto a thread local if there isn't already one there.
         # If there is one, just update it.
-        def _push_metric_frame(args) # :nodoc:
-          frame_data = NewRelic::Agent::Instrumentation::MetricFrame.current(true)
-
-          frame_data.apdex_start ||= _detect_upstream_wait(frame_data.start)
-          _record_queue_length
-
+        def _start_transaction(args) # :nodoc:
           # If a block was passed in, then the arguments represent options for the instrumentation,
           # not app method arguments.
           options = {}
           if args.any?
             if args.last.is_a?(Hash)
               options = args.pop
-              frame_data.force_flag = options[:force]
-              frame_data.request = options[:request] if options[:request]
             end
             available_params = options[:params] || {}
             options[:name] ||= args.first
           else
             available_params = self.respond_to?(:params) ? self.params : {}
           end
-          frame_data.request ||= self.request if self.respond_to? :request
 
-          txn_name = transaction_name(options || {})
+          options[:request] ||= self.request if self.respond_to? :request
+          options[:filtered_params] = (respond_to? :filter_parameters) ? filter_parameters(available_params) : available_params
+          category = options[:category] || :controller
+          txn = Transaction.start(category, options)
+          txn.name = TransactionNamer.new(self).name(options)
+
+          txn.apdex_start ||= _detect_upstream_wait(txn.start_time)
+          _record_queue_length
 
-          frame_data.push(txn_name)
-          NewRelic::Agent::TransactionInfo.get.transaction_name = txn_name
-          frame_data.filtered_params = (respond_to? :filter_parameters) ? filter_parameters(available_params) : available_params
-          frame_data
+          return txn
         end
 
         # Filter out a request if it matches one of our parameters for

data/lib/new_relic/agent/instrumentation/evented_subscriber.rb

@@ -0,0 +1,91 @@
+# 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.
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      class EventedSubscriber
+        def initialize
+          @queue_key = ['NewRelic', self.class.name, object_id].join('-')
+        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 self.subscribe(pattern)
+          if !subscribed?
+            ActiveSupport::Notifications.subscribe(pattern, new)
+          end
+        end
+
+        def start(name, id, payload)
+          event = ActiveSupport::Notifications::Event.new(name, Time.now, nil, id, payload)
+          push_event(event)
+          return event
+        end
+
+        def finish(name, id, payload)
+          pop_event(id)
+        end
+
+        def push_event(event)
+          parent = event_stack[event.transaction_id].last
+          event.parent = parent
+          parent << event if parent
+          event_stack[event.transaction_id].push event
+        end
+
+        def pop_event(transaction_id)
+          event = event_stack[transaction_id].pop
+          event.end = Time.now
+          return event
+        end
+
+        def event_stack
+          Thread.current[@queue_key] ||= Hash.new {|h,id| h[id] = [] }
+        end
+      end
+
+      # Taken from ActiveSupport::Notifications::Event, pasted here
+      # with a couple minor additions so we don't have a hard
+      # dependency on ActiveSupport::Notifications.
+      #
+      # Represents an intrumentation event, provides timing and metric
+      # name information useful when recording metrics.
+      class Event
+        attr_reader :name, :time, :transaction_id, :payload, :children
+        attr_accessor :end, :parent, :scope
+
+        def initialize(name, start, ending, transaction_id, payload)
+          @name           = name
+          @payload        = payload.dup
+          @time           = start
+          @transaction_id = transaction_id
+          @end            = ending
+          @children       = []
+        end
+
+        def metric_name
+          raise NotImplementedError
+        end
+
+        def duration
+          self.end - time
+        end
+
+        def <<(event)
+          @children << event
+        end
+
+        def parent_of?(event)
+          @children.include? event
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/memcache.rb

@@ -20,7 +20,7 @@ module NewRelic
             the_class.class_eval <<-EOD
               def #{method_name}_with_newrelic_trace(*args, &block)
                 metrics = ["Memcache/#{method_name}",
-                           (NewRelic::Agent::Instrumentation::MetricFrame.recording_web_transaction? ? 'Memcache/allWeb' : 'Memcache/allOther')]
+                           (NewRelic::Agent::Transaction.recording_web_transaction? ? 'Memcache/allWeb' : 'Memcache/allOther')]
                 self.class.trace_execution_scoped(metrics) do
                   t0 = Time.now
                   begin
@@ -33,7 +33,7 @@ module NewRelic
               alias #{method_name}_without_newrelic_trace #{method_name}
               alias #{method_name} #{method_name}_with_newrelic_trace
             EOD
-         end      
+         end
         end
         def memcache_key_snippet(method_name)
           return "" unless NewRelic::Agent.config[:capture_memcache_keys]
@@ -46,7 +46,7 @@ end
 
 DependencyDetection.defer do
   @name = :memcache
-  
+
   depends_on do
     !NewRelic::Agent.config[:disable_memcache_instrumentation]
   end
@@ -55,7 +55,7 @@ DependencyDetection.defer do
     defined?(::MemCache) || defined?(::Memcached) ||
       defined?(::Dalli::Client) || defined?(::Spymemcached)
   end
-    
+
   executes do
     commands = %w[get get_multi set add incr decr delete replace append prepend]
     if defined? ::MemCache

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

@@ -12,18 +12,18 @@ DependencyDetection.defer do
   depends_on do
     Merb::Dispatcher::DefaultException.respond_to?(:before)
   end
-  
+
   executes do
     ::NewRelic::Agent.logger.info 'Installing Merb Errors instrumentation'
   end
-  
+
   executes do
 
     # Hook in the notification to merb
     error_notifier = Proc.new {
       if request.exceptions #check that there's actually an exception
-        # Note, this assumes we have already captured the other information such as uri and params in the MetricFrame.
-        NewRelic::Agent::Instrumentation::MetricFrame.notice_error(request.exceptions.first)
+        # Note, this assumes we have already captured the other information such as uri and params in the Transaction.
+        NewRelic::Agent::Transaction.notice_error(request.exceptions.first)
       end
     }
     Merb::Dispatcher::DefaultException.before error_notifier

data/lib/new_relic/agent/instrumentation/rack.rb

@@ -77,7 +77,7 @@ module NewRelic
           perform_action_with_newrelic_trace(:category => :rack, :request => @newrelic_request) do
             result = call_without_newrelic(*args)
             # Ignore cascaded calls
-            MetricFrame.abort_transaction! if result.first == 404
+            Transaction.abort_transaction! if result.first == 404
             result
           end
         end