newrelic_rpm 2.9.9 → 2.10.3

data/lib/new_relic/agent/busy_calculator.rb

@@ -0,0 +1,91 @@
+# This module supports calculation of actual time spent processing requests over the course of
+# one harvest period.  It's similar to what you would get if you just added up all the
+# execution times of controller calls, however that will be inaccurate when requests
+# span the minute boundaries.  This module manages accounting of requests not yet
+# completed. 
+#
+# Calls are re-entrant.  All start calls must be paired with finish
+# calls, or a reset call.
+module NewRelic
+  module Agent
+    module BusyCalculator
+  
+  extend self
+  
+  # For testability, add accessors:
+  attr_reader :harvest_start, :accumulator
+  
+  def dispatcher_start(time)
+    Thread.current[:busy_entries] ||= 0 
+    callers = Thread.current[:busy_entries] += 1
+    return if callers > 1
+    @lock.synchronize do
+      @entrypoint_stack.push time      
+    end
+  end
+  
+  def dispatcher_finish(end_time = Time.now.to_f)
+    callers = Thread.current[:busy_entries] -= 1
+    # Ignore nested calls
+    return if callers > 0
+    @lock.synchronize do
+      if @entrypoint_stack.empty?
+        NewRelic::Control.instance.log.error("Stack underflow tracking dispatcher entry and exit!\n  #{caller.join("  \n")}") 
+      else
+        @accumulator += (end_time - @entrypoint_stack.pop)
+      end
+    end
+  end
+  
+  def busy_count
+    @entrypoint_stack.size
+  end
+  
+  # Reset the state of the information accumulated by all threads,
+  # but only reset the recursion counter for this thread.
+  def reset
+    @entrypoint_stack = []
+    Thread.current[:busy_entries] = 0
+    @lock ||= Mutex.new
+    @accumulator = 0
+    @harvest_start = Time.now.to_f
+  end
+  
+  self.reset
+  
+  # Called before uploading to to the server to collect current busy stats.
+  def harvest_busy
+    busy = 0
+    t0 = Time.now.to_f
+    @lock.synchronize do
+      busy = accumulator
+      @accumulator = 0
+      
+      # Walk through the stack and capture all times up to 
+      # now for entrypoints
+      @entrypoint_stack.size.times do |frame| 
+        busy += (t0 - @entrypoint_stack[frame])
+        @entrypoint_stack[frame] = t0
+      end
+      
+    end
+    
+    busy = 0.0 if busy < 0.0 # don't go below 0%
+    
+    time_window = (t0 - harvest_start)
+    time_window = 1.0 if time_window == 0.0  # protect against divide by zero
+    
+    busy = busy / time_window
+    
+    instance_busy_stats.record_data_point busy
+    @harvest_start = t0
+  end
+  private
+  def instance_busy_stats
+    # Late binding on the Instance/busy stats
+    NewRelic::Agent.agent.stats_engine.get_stats_no_scope 'Instance/Busy'  
+  end
+  
+end
+end
+end

data/lib/new_relic/agent/collection_helper.rb

@@ -1,4 +1,6 @@
-module NewRelic::Agent::CollectionHelper
+module NewRelic
+  module Agent
+    module CollectionHelper
   # Transform parameter hash into a hash whose values are strictly
   # strings
   def normalize_params(params)
@@ -53,9 +55,16 @@ module NewRelic::Agent::CollectionHelper
     when Symbol then string
     when nil then ""
     when String
-      string.to_s.gsub(/^(.{#{len}})(.*)/) {$2.blank? ? $1 : $1 + "..."}
+      real_string = flatten(string)
+      if real_string.size > len
+        real_string = real_string.slice(0...len)
+        real_string << "..."
+      end
+      real_string
     else
       truncate(flatten(string), len)     
     end
   end
 end
+end
+end

data/lib/new_relic/agent/error_collector.rb

@@ -1,14 +1,20 @@
 
-module NewRelic::Agent
+module NewRelic
+  module Agent
   class ErrorCollector
     include CollectionHelper
     
+    # Defined the methods that need to be stubbed out when the
+    # agent is disabled
+    module Shim #:nodoc:
+      def notice_error(*args); end
+    end
+    
     MAX_ERROR_QUEUE_LENGTH = 20 unless defined? MAX_ERROR_QUEUE_LENGTH
     
     attr_accessor :enabled
     
-    def initialize(agent = nil)
-      @agent = agent
+    def initialize
       @errors = []
       # lookup of exception class names to ignore.  Hash for fast access
       @ignore = {}
@@ -34,36 +40,38 @@ module NewRelic::Agent
     # errors is an array of Exception Class Names
     #
     def ignore(errors)
-      errors.each { |error| @ignore[error] = true; log.debug("Ignoring error: '#{error}'") }
+      errors.each { |error| @ignore[error] = true; log.debug("Ignoring errors of type '#{error}'") }
     end
     
-    
-    def notice_error(exception, request=nil, action_path=nil, filtered_params={})
-      
+    # Notice the error with the given available options:
+    #
+    # * :uri => The request path, minus any request params or query string.
+    # * :referer => The URI of the referer
+    # * :metric => The metric name associated with the transaction
+    # * :request_params => Request parameters, already filtered if necessary
+    # * :custom_params => Custom parameters
+    def notice_error(exception, options={})
       return unless @enabled
       return if @ignore[exception.class.name] 
-      
       if @ignore_filter
         exception = @ignore_filter.call(exception)
-        
         return if exception.nil?
       end
-      
-      error_stat.increment_count
+
+      action_path     = options[:metric] || NewRelic::Agent.instance.stats_engine.scope_name || ''
+      filtered_params = options[:request_params] || {}
+
+      NewRelic::Agent.get_stats("Errors/all").increment_count
+      return unless NewRelic::Agent.instance.should_send_errors
       
       data = {}
       
-      action_path ||= ''
-      
-      data[:request_params] = normalize_params(filtered_params) if NewRelic::Control.instance.capture_params
+      data[:request_params] = normalize_params(options[:request_params]) if NewRelic::Control.instance.capture_params && options[:request_params]
 
-      data[:custom_params] = normalize_params(@agent.custom_params) if @agent
-      
-      data[:request_uri] = request.path if request
-      data[:request_uri] ||= ""
+      data[:custom_params] = normalize_params(options[:custom_params]) if options[:custom_params]
       
-      data[:request_referer] = request.referer if request
-      data[:request_referer] ||= ""
+      data[:request_uri] = options[:uri] || ''
+      data[:request_referer] = options[:referer] || ''
       
       data[:rails_root] = NewRelic::Control.instance.root
       
@@ -80,13 +88,13 @@ module NewRelic::Agent
         inside_exception = exception
       end
 
-      data[:stack_trace] = inside_exception.backtrace
+      data[:stack_trace] = inside_exception ? inside_exception.backtrace : '<no stack trace>'
       
       noticed_error = NewRelic::NoticedError.new(action_path, data, exception)
       
       @lock.synchronize do
-        if @errors.length >= MAX_ERROR_QUEUE_LENGTH
-          log.info("The error reporting queue has reached #{MAX_ERROR_QUEUE_LENGTH}. This error will not be reported to RPM: #{exception.message}")
+        if @errors.length == MAX_ERROR_QUEUE_LENGTH
+          log.warn("The error reporting queue has reached #{MAX_ERROR_QUEUE_LENGTH}. The error detail for this and subsequent errors will not be transmitted to RPM until the queued errors have been sent: #{exception.message}")
         else
           @errors << noticed_error
         end
@@ -109,11 +117,9 @@ module NewRelic::Agent
     end
     
     private
-    def error_stat
-      @error_stat ||= NewRelic::Agent.get_stats("Errors/all")
-    end
     def log
       NewRelic::Control.instance.log
     end
   end
-end
+end
+end

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

@@ -1,12 +1,12 @@
 
 # NewRelic instrumentation for ActiveRecord
-if defined?(ActiveRecord::Base) && !NewRelic::Control.instance['skip_ar_instrumentation']
-  
+if defined?(ActiveRecord) && defined?(ActiveRecord::Base) && !NewRelic::Control.instance['skip_ar_instrumentation']
+
   module NewRelic
     module Agent
       module Instrumentation
         module ActiveRecordInstrumentation
-
+          
           def self.included(instrumented_class)
             instrumented_class.class_eval do
               alias_method :log_without_newrelic_instrumentation, :log
@@ -15,11 +15,10 @@ if defined?(ActiveRecord::Base) && !NewRelic::Control.instance['skip_ar_instrume
             end
           end
           
-          def active_record_all_stats
-            NewRelic::Agent.instance.stats_engine.get_stats_no_scope("ActiveRecord/all")
-          end
-          
           def log_with_newrelic_instrumentation(sql, name, &block)
+            
+            return log_without_newrelic_instrumentation(sql, name, &block) unless NewRelic::Agent.is_execution_traced?
+            
             # Capture db config if we are going to try to get the explain plans
             if (defined?(ActiveRecord::ConnectionAdapters::MysqlAdapter) && self.is_a?(ActiveRecord::ConnectionAdapters::MysqlAdapter)) ||
                 (defined?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter) && self.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter))
@@ -39,28 +38,34 @@ if defined?(ActiveRecord::Base) && !NewRelic::Control.instance['skip_ar_instrume
                               end
                             end
               metric = "ActiveRecord/#{model}/#{metric_name}" if metric_name
-            end      
-            if metric.nil? && sql =~ /^(select|update|insert|delete)/i
-              # Could not determine the model/operation so let's find a better
-              # metric.  If it doesn't match the regex, it's probably a show
-              # command or some DDL which we'll ignore.
-              metric = "Database/SQL/#{$1.downcase}"
+            end
+            
+            if metric.nil?
+              metric = NewRelic::Agent::Instrumentation::MetricFrame.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
+                  # metric.  If it doesn't match the regex, it's probably a show
+                  # command or some DDL which we'll ignore.
+                  metric = "Database/SQL/#{$1.downcase}"
+                else
+                  metric = "Database/SQL/other"
+                end
+              end
             end
             
             if !metric
               log_without_newrelic_instrumentation(sql, name, &block)
             else
-              self.class.trace_method_execution_with_scope metric, true, true do        
+              metrics = [metric, "ActiveRecord/all"]
+              metrics << "ActiveRecord/#{metric_name}" if metric_name
+              self.class.trace_execution_scoped(metrics) do
                 t0 = Time.now.to_f
-                result = log_without_newrelic_instrumentation(sql, name, &block)
-                duration = Time.now.to_f - t0
-                
-                NewRelic::Agent.instance.transaction_sampler.notice_sql(sql, supported_config, duration)
-                # Record in the overall summary metric
-                active_record_all_stats.record_data_point(duration)
-                # Record in the summary metric for this operation
-                NewRelic::Agent.instance.stats_engine.get_stats_no_scope("ActiveRecord/#{metric_name}").record_data_point(duration) if metric_name
-                result
+                begin
+                  log_without_newrelic_instrumentation(sql, name, &block) 
+                ensure
+                  NewRelic::Agent.instance.transaction_sampler.notice_sql(sql, supported_config, Time.now.to_f - t0) 
+                end
               end
             end
           end
@@ -71,7 +76,7 @@ if defined?(ActiveRecord::Base) && !NewRelic::Control.instance['skip_ar_instrume
         ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
           include ::NewRelic::Agent::Instrumentation::ActiveRecordInstrumentation
         end
-
+        
         # This instrumentation will add an extra scope to the transaction traces
         # which will show the code surrounding the query, inside the model find_by_sql
         # method.
@@ -79,8 +84,7 @@ if defined?(ActiveRecord::Base) && !NewRelic::Control.instance['skip_ar_instrume
           class << self
             add_method_tracer :find_by_sql, 'ActiveRecord/#{self.name}/find_by_sql', :metric => false
           end
-        end
-        
+        end unless NewRelic::Control.instance['disable_activerecord_instrumentation']
       end
     end
   end

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

@@ -0,0 +1,8 @@
+if defined? Authlogic::Session::Base
+  Authlogic::Session::Base.class_eval do
+  #  add_method_tracer :record, 'Authlogic/record'
+    class << self
+      add_method_tracer :find, 'Authlogic/find'
+    end
+  end
+end

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

@@ -1,44 +1,33 @@
-# NewRelic instrumentation for controllers
-#
-# This instrumentation is applied to the action controller by default if the agent
-# is actively collecting statistics.  It will collect statistics for the 
-# given action.
-#
-# In cases where you don't want to instrument the top level action, but instead
-# have other methods which are dispatched to by your action, and you want to treat
-# these as distinct actions, then what you need to do is call newrelic_ignore
-# on the top level action, and manually instrument the called 'actions'.  
-#
-# Here's an example of a controller with a send_message action which dispatches
-# to more specific send_servicename methods.  This results in the controller 
-# action stats showing up for send_servicename.
-#
-# MyController < ActionController::Base
-#   newrelic_ignore :only => 'send_message'
-#   # dispatch this action to the method given by the service parameter.
-#   def send_message
-#     service = params['service']
-#     dispatch_to_method = "send_messge_to_#{service}"
-#     perform_action_with_newrelic_trace(dispatch_to_method) do
-#       send dispatch_to_method, params['message']
-#     end
-#   end
-# end
-
-module NewRelic::Agent::Instrumentation
+require 'new_relic/agent/instrumentation/metric_frame'
+module NewRelic
+  module Agent
+    module Instrumentation
+  # == NewRelic instrumentation for controller actions and tasks
+  #
+  # This instrumentation is applied to the action controller to collect
+  # metrics for every web request.
+  #
+  # It can also be used to capture performance information for 
+  # background tasks and other non-web transactions, including
+  # detailed transaction traces and traced errors.
+  #
+  # For details on how to instrument background tasks see
+  # ClassMethods#add_transaction_tracer and
+  # #perform_action_with_newrelic_trace
+  #
   module ControllerInstrumentation
     
-    def self.included(clazz)
+    def self.included(clazz) # :nodoc:
       clazz.extend(ClassMethods)
     end
     
     # This module is for importing stubs when the agent is disabled
-    module ClassMethodsShim
+    module ClassMethodsShim # :nodoc:
       def newrelic_ignore(*args); end
       def newrelic_ignore_apdex(*args); end
     end
     
-    module Shim
+    module Shim # :nodoc:
       def self.included(clazz)
         clazz.extend(ClassMethodsShim)
       end
@@ -71,12 +60,92 @@ module NewRelic::Agent::Instrumentation
         end
       end
       
-      # Should be monkey patched into the controller class implemented with the inheritable attribute mechanism.
+      # Should be monkey patched into the controller class implemented
+      # with the inheritable attribute mechanism.
       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}", value
+        instance_variable_get "@#{attr_name}"
+      end
+      
+      # Add transaction tracing to the given method.  This will treat
+      # the given method as a main entrypoint for instrumentation, just
+      # like controller actions are treated by default.  Useful especially
+      # for background tasks. 
+      #
+      # Example for background job:
+      #   class Job
+      #     include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+      #     def run(task)
+      #        ...
+      #     end
+      #     # Instrument run so tasks show up under task.name.  Note single
+      #     # quoting to defer eval to runtime.
+      #     add_transaction_tracer :run, :name => '#{args[0].name}'
+      #   end
+      #
+      # Here's an example of a controller that uses a dispatcher
+      # action to invoke operations which you want treated as top
+      # level actions, so they aren't all lumped into the invoker
+      # action.
+      #      
+      #   MyController < ActionController::Base
+      #     include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+      #     # dispatch the given op to the method given by the service parameter.
+      #     def invoke_operation
+      #       op = params['operation']
+      #       send op
+      #     end
+      #     # Ignore the invoker to avoid double counting
+      #     newrelic_ignore :only => 'invoke_operation'
+      #     # Instrument the operations:
+      #     add_transaction_tracer :print
+      #     add_transaction_tracer :show
+      #     add_transaction_tracer :forward
+      #   end
+      #
+      # Here's an example of how to pass contextual information into the transaction
+      # so it will appear in transaction traces:
+      #
+      #   class Job
+      #     include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+      #     def process(account)
+      #        ...
+      #     end
+      #     # Include the account name in the transaction details.  Note the single
+      #     # quotes to defer eval until call time.
+      #     add_transaction_tracer :process, :params => '{ :account_name => args[0].name }'
+      #   end
+      #
+      # See NewRelic::Agent::Instrumentation::ControllerInstrumentation#perform_action_with_newrelic_trace
+      # for the full list of available options.
+      #
+      def add_transaction_tracer(method, options={})
+        # The metric path:
+        options[:name] ||= method.to_s
+        # create the argument list:
+        options_arg = []
+        options.each do |key, value|
+          valuestr = case
+          when value.is_a?(Symbol)
+            value.inspect
+          when key == :params
+            value.to_s
+          else
+              %Q["#{value.to_s}"]
+          end
+          options_arg << %Q[:#{key} => #{valuestr}]
+        end
+        class_eval <<-EOC
+        def #{method.to_s}_with_newrelic_transaction_trace(*args, &block)
+          perform_action_with_newrelic_trace(#{options_arg.join(',')}) do
+            #{method.to_s}_without_newrelic_transaction_trace(*args, &block)
+          end
+        end
+        EOC
+        alias_method "#{method.to_s}_without_newrelic_transaction_trace", method.to_s
+        alias_method method.to_s, "#{method.to_s}_with_newrelic_transaction_trace"
       end
     end
     
@@ -88,100 +157,201 @@ module NewRelic::Agent::Instrumentation
       raise "Not implemented!"
     end
     
-    # Perform the current action with NewRelic tracing.  Used in a method
-    # chain via aliasing.  Call directly if you want to instrument a specifc
-    # block as if it were an action.  Pass the block along with the path.
-    # The metric is named according to the action name, or the given path if called
-    # directly.  
-    def perform_action_with_newrelic_trace(*args)
-      agent = NewRelic::Agent.instance
-      stats_engine = agent.stats_engine
+    # Yield to the given block with NewRelic tracing.  Used by 
+    # default instrumentation on controller actions in Rails and Merb.
+    # But it can also be used in custom instrumentation of controller
+    # methods and background tasks.
+    #
+    # This is the method invoked by instrumentation added by the
+    # <tt>ClassMethods#add_transaction_tracer</tt>.  
+    #
+    # Here's a more verbose version of the example shown in
+    # <tt>ClassMethods#add_transaction_tracer</tt> using this method instead of
+    # #add_transaction_tracer.
+    #
+    # Below is a controller with an +invoke_operation+ action which
+    # dispatches to more specific operation methods based on a
+    # parameter (very dangerous, btw!).  With this instrumentation,
+    # the +invoke_operation+ action is ignored but the operation
+    # methods show up in RPM as if they were first class controller
+    # actions
+    #    
+    #   MyController < ActionController::Base
+    #     include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+    #     # dispatch the given op to the method given by the service parameter.
+    #     def invoke_operation
+    #       op = params['operation']
+    #       perform_action_with_newrelic_trace(:name => op) do
+    #         send op, params['message']
+    #       end
+    #     end
+    #     # Ignore the invoker to avoid double counting
+    #     newrelic_ignore :only => 'invoke_operation'
+    #   end
+    #
+    #
+    # When invoking this method explicitly as in the example above, pass in a 
+    # block to measure with some combination of options:
+    #
+    # * <tt>:category => :controller</tt> indicates that this is a
+    #   controller action and will appear with all the other actions.  This
+    #   is the default.
+    # * <tt>:category => :task</tt> indicates that this is a
+    #   background task and will show up in RPM with other background
+    #   tasks instead of in the controllers list
+    # * <tt>:category => :rack</tt> if you are instrumenting a rack
+    #   middleware call.  The <tt>:name</tt> is optional, useful if you 
+    #   have more than one potential transaction in the #call.
+    # * <tt>:category => :uri</tt> indicates that this is a
+    #   web transaction whose name is a normalized URI, where  'normalized'
+    #   means the URI does not have any elements with data in them such
+    #   as in many REST URIs.
+    # * <tt>:name => action_name</tt> is used to specify the action
+    #   name used as part of the metric name
+    # * <tt>:params => {...}</tt> to provide information about the context
+    #   of the call, used in transaction trace display, for example:
+    #   <tt>:params => { :account => @account.name, :file => file.name }</tt>
+    #   These are treated similarly to request parameters in web transactions.
+    #
+    # Seldomly used options:
+    #
+    # * <tt>:force => true</tt> indicates you should capture all
+    #   metrics even if the #newrelic_ignore directive was specified
+    # * <tt>:class_name => aClass.name</tt> is used to override the name
+    #   of the class when used inside the metric name.  Default is the
+    #   current class.
+    # * <tt>:path => metric_path</tt> is *deprecated* in the public API.  It
+    #   allows you to set the entire metric after the category part.  Overrides
+    #   all the other options.
+    # * <tt>:request => Rack::Request#new(env)</tt> is used to pass in a 
+    #   request object that may respond to uri and referer.
+    #
+    # If a single argument is passed in, it is treated as a metric
+    # path.  This form is deprecated.
+    def perform_action_with_newrelic_trace(*args, &block)
+      
+      NewRelic::Agent.instance.ensure_worker_thread_started
       
       # Skip instrumentation based on the value of 'do_not_trace' and if 
       # we aren't calling directly with a block.
-      if !block_given? && is_filtered?(self.class.newrelic_read_attr('do_not_trace'))
-        # Tell the dispatcher instrumentation that we ignored this action and it shouldn't
-        # be counted for the overall HTTP operations measurement.
-        Thread.current[:controller_ignored] = true
-        
-        return perform_action_without_newrelic_trace(*args)
+      if !block_given? && _is_filtered?('do_not_trace')
+        # Also ignore all instrumentation in the call sequence
+        NewRelic::Agent.disable_all_tracing do
+          return perform_action_without_newrelic_trace(*args)
+        end
       end
       
-      # reset this in case we came through a code path where the top level controller is ignored
-      Thread.current[:controller_ignored] = nil
+      return perform_action_with_newrelic_profile(args, &block) if NewRelic::Control.instance.profiling?
       
-      start = Time.now.to_f
-      agent.ensure_worker_thread_started
-      
-      # generate metrics for all all controllers (no scope)
-      self.class.trace_method_execution_no_scope "Controller" do 
-        # assuming the first argument, if present, is the action name
-        path = newrelic_metric_path(args.size > 0 ? args[0] : nil)
-        controller_metric = "Controller/#{path}"
-        
-        self.class.trace_method_execution_with_scope controller_metric, true, true do 
-          stats_engine.transaction_name = controller_metric
-          
-          local_params = (respond_to? :filter_parameters) ? filter_parameters(params) : params
-          
-          agent.transaction_sampler.notice_transaction(path, request, local_params)
-          
-          t = Process.times.utime + Process.times.stime
-          
-          failed = false
-          
+      frame_data = _push_metric_frame(block_given? ? args : [])
+      begin      
+        NewRelic::Agent.trace_execution_scoped frame_data.recorded_metrics, :force => frame_data.force_flag do
+          frame_data.start_transaction
           begin
-            # run the action
+            NewRelic::Agent::BusyCalculator.dispatcher_start frame_data.start
             if block_given?
               yield
             else
               perform_action_without_newrelic_trace(*args)
             end
           rescue Exception => e
-            failed = true
-            raise e
-          ensure
-            cpu_burn = (Process.times.utime + Process.times.stime) - t
-            stats_engine.get_stats_no_scope("ControllerCPU/#{path}").record_data_point(cpu_burn)
-            agent.transaction_sampler.notice_transaction_cpu_time(cpu_burn)
-            
-            # do the apdex bucketing
-            #
-            unless is_filtered?(self.class.newrelic_read_attr('ignore_apdex'))
-              duration = Time.now.to_f - start
-              controller_stat = stats_engine.get_custom_stats("Apdex/#{path}", NewRelic::ApdexStats)
-              case
-                when failed
-                apdex_overall_stat.record_apdex_f    # frustrated
-                controller_stat.record_apdex_f
-                when duration <= NewRelic::Control.instance['apdex_t']
-                apdex_overall_stat.record_apdex_s    # satisfied
-                controller_stat.record_apdex_s
-                when duration <= 4 * NewRelic::Control.instance['apdex_t']
-                apdex_overall_stat.record_apdex_t    # tolerating
-                controller_stat.record_apdex_t
-              else
-                apdex_overall_stat.record_apdex_f    # frustrated
-                controller_stat.record_apdex_f
-              end
-            end
+            frame_data.notice_error(e)
+            raise
           end
         end
+      ensure
+        NewRelic::Agent::BusyCalculator.dispatcher_finish
+        # Look for a metric frame 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 _is_filtered?('ignore_apdex')
+        frame_data.pop
       end
-    ensure
-      # clear out the name of the traced transaction under all circumstances
-      stats_engine.transaction_name = nil
+    end
+
+    protected
+    # Should be implemented in the dispatcher class
+    def newrelic_response_code; end
+    
+    def newrelic_request_headers
+      self.respond_to?(:request) && self.request.respond_to?(:headers) && self.request.headers
     end
     
     private
-    def apdex_overall_stat
-      NewRelic::Agent.instance.stats_engine.get_custom_stats("Apdex", NewRelic::ApdexStats)  
+    
+    # Profile the instrumented call.  Dev mode only.  Experimental. 
+    def perform_action_with_newrelic_profile(args)
+      frame_data = _push_metric_frame(block_given? ? args : [])
+      NewRelic::Agent.trace_execution_scoped frame_data.metric_name do
+        MetricFrame.current(true).start_transaction
+        NewRelic::Agent.disable_all_tracing do
+          # turn on profiling
+          profile = RubyProf.profile do
+            if block_given?
+              yield
+            else
+              perform_action_without_newrelic_trace(*args)
+            end
+          end
+          NewRelic::Agent.instance.transaction_sampler.notice_profile profile
+        end
+      end
+    ensure
+      frame_data.pop
     end
     
-    def is_filtered?(ignore_actions)
+    # Write a metric frame 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 
+      # If a block was passed in, then the arguments represent options for the instrumentation,
+      # not app method arguments.
+      if args.any?
+        if options = args.last.is_a?(Hash) && args.last
+          frame_data.force_flag = options[:force] 
+          frame_data.request = options[:request] if options[:request]
+        end
+        category, path, available_params = _convert_args_to_path(args)
+      else
+        category = 'Controller'
+        path = newrelic_metric_path
+        available_params = self.respond_to?(:params) ? self.params : {}
+        frame_data.request = self.request if self.respond_to? :request
+      end
+      frame_data.push(category, path)
+      frame_data.filtered_params = (respond_to? :filter_parameters) ? filter_parameters(available_params) : available_params
+      frame_data
+    end
+        
+    def _convert_args_to_path(args)
+      options =  args.last.is_a?(Hash) ? args.pop : {}
+      params = options[:params] || {}
+      category = 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
+      unless path = options[:path]
+        action = options[:name] || args.first 
+        metric_class = options[:class_name] || (self.is_a?(Class) ? self.name : self.class.name)
+        path = metric_class
+        path += ('/' + action) if action
+      end
+      [category, path, params]
+    end
+
+    # Filter out 
+    def _is_filtered?(key)
+      ignore_actions = self.class.newrelic_read_attr(key) if self.class.respond_to? :newrelic_read_attr
       case ignore_actions
-        when nil; false
-        when Hash
+      when nil; false
+      when Hash
         only_actions = Array(ignore_actions[:only])
         except_actions = Array(ignore_actions[:except])
         only_actions.include?(action_name.to_sym) || (except_actions.any? && !except_actions.include?(action_name.to_sym))
@@ -189,5 +359,46 @@ module NewRelic::Agent::Instrumentation
         true
       end
     end
+    # Take a guess at a measure representing the number of requests waiting in mongrel
+    # or heroku.
+    def _record_queue_length
+      if newrelic_request_headers
+        if queue_depth = newrelic_request_headers['HTTP_X_HEROKU_QUEUE_DEPTH']
+          queue_depth = queue_depth.to_i rescue nil
+        elsif mongrel = NewRelic::Control.instance.local_env.mongrel
+          # Always subtrace 1 for the active mongrel
+          queue_depth = [mongrel.workers.list.length.to_i - 1, 0].max rescue nil
+        end
+        NewRelic::Agent.agent.stats_engine.get_stats_no_scope('Mongrel/Queue Length').trace_call(queue_depth) if queue_depth
+      end
+    end
+    
+    def _detect_upstream_wait(now)
+      if newrelic_request_headers
+        if entry_time = newrelic_request_headers['HTTP_X_REQUEST_START']
+          if newrelic_request_headers['HTTP_X_HEROKU_QUEUE_DEPTH'] # this is a heroku measure
+            http_entry_time = entry_time.to_f / 1e3
+          else # apache / nginx
+            apache_parsed_time = entry_time[/t=(\d+)/, 1]
+            http_entry_time = apache_parsed_time.to_f/1e6 if apache_parsed_time
+          end
+        end
+      end
+      # If we didn't find the custom header, look for the mongrel timestamp
+      http_entry_time ||= Thread.current[:started_on] and http_entry_time = http_entry_time.to_f
+      if http_entry_time
+        queue_stat = NewRelic::Agent.agent.stats_engine.get_stats_no_scope 'WebFrontend/Mongrel/Average Queue Time'
+        total_time = (now - http_entry_time)
+        queue_stat.trace_call(total_time) unless total_time < 0 # using remote timestamps could lead to negative queue time
+      end
+      http_entry_time || now
+    end
+
+    def _dispatch_stat
+      NewRelic::Agent.agent.stats_engine.get_stats_no_scope 'HttpDispatcher'  
+    end
+    
   end 
 end  
+end
+end