honkster-newrelic_rpm 2.13.1

data/lib/new_relic/agent/busy_calculator.rb

@@ -0,0 +1,91 @@
+module NewRelic
+  module Agent
+    # 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 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)
+        callers = Thread.current[:busy_entries] -= 1
+        # Ignore nested calls
+        return if callers > 0
+        @lock.synchronize do
+          if @entrypoint_stack.empty?
+            NewRelic::Agent.logger.error("Stack underflow tracking dispatcher entry and exit!\n  #{caller.join("  \n")}")
+          else
+            @accumulator += (end_time - @entrypoint_stack.pop).to_f
+          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
+      end
+
+      self.reset
+
+      # Called before uploading to to the server to collect current busy stats.
+      def harvest_busy
+        busy = 0
+        t0 = Time.now
+        @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]).to_f
+            @entrypoint_stack[frame] = t0
+          end
+
+        end
+
+        busy = 0.0 if busy < 0.0 # don't go below 0%
+
+        time_window = (t0 - harvest_start).to_f
+        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/chained_call.rb

@@ -0,0 +1,13 @@
+# This is used to allow obfuscators to be chained.
+
+class NewRelic::ChainedCall
+  def initialize(block1, block2)
+    @block1 = block1
+    @block2 = block2
+  end
+
+  def call(sql)
+    sql = @block1.call(sql)
+    @block2.call(sql)
+  end
+end

data/lib/new_relic/agent/error_collector.rb

@@ -0,0 +1,131 @@
+
+module NewRelic
+  module Agent
+  class ErrorCollector
+    include NewRelic::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
+    attr_reader :config_enabled
+
+    def initialize
+      @errors = []
+      # lookup of exception class names to ignore.  Hash for fast access
+      @ignore = {}
+      @ignore_filter = nil
+
+      config = NewRelic::Control.instance.fetch('error_collector', {})
+
+      @enabled = @config_enabled = config.fetch('enabled', true)
+      @capture_source = config.fetch('capture_source', true)
+
+      ignore_errors = config.fetch('ignore_errors', "")
+      ignore_errors = ignore_errors.split(",") if ignore_errors.is_a? String
+      ignore_errors.each { |error| error.strip! }
+      ignore(ignore_errors)
+      @lock = Mutex.new
+    end
+
+    def ignore_error_filter(&block)
+      if block
+        @ignore_filter = block
+      else
+        @ignore_filter
+      end
+    end
+
+    # errors is an array of Exception Class Names
+    #
+    def ignore(errors)
+      errors.each { |error| @ignore[error] = true; log.debug("Ignoring errors of type '#{error}'") }
+    end
+
+    # Notice the error with the given available options:
+    #
+    # * <tt>:uri</tt> => The request path, minus any request params or query string.
+    # * <tt>:referer</tt> => The URI of the referer
+    # * <tt>:metric</tt> => The metric name associated with the transaction
+    # * <tt>:request_params</tt> => Request parameters, already filtered if necessary
+    # * <tt>:custom_params</tt> => Custom parameters
+    #
+    # If anything is left over, it's added to custom params
+    # If exception is nil, the error count is bumped and no traced error is recorded
+    def notice_error(exception, options={})
+      return unless @enabled
+      return if exception && @ignore[exception.class.name]
+      if @ignore_filter && exception
+        exception = @ignore_filter.call(exception)
+        return if exception.nil?
+      end
+      NewRelic::Agent.get_stats("Errors/all").increment_count
+      return if exception.nil?
+
+      data = {}
+      data[:request_uri] = options.delete(:uri) || ''
+      data[:request_referer] = options.delete(:referer) || ''
+
+      action_path     = options.delete(:metric) || NewRelic::Agent.instance.stats_engine.scope_name || ''
+      request_params = options.delete(:request_params)
+      custom_params = options.delete(:custom_params) || {}
+      # If anything else is left over, treat it like a custom param:
+      custom_params.merge! options
+
+      data[:request_params] = normalize_params(request_params) if NewRelic::Control.instance.capture_params && request_params
+      data[:custom_params] = normalize_params(custom_params) unless custom_params.empty?
+      data[:rails_root] = NewRelic::Control.instance.root
+      data[:file_name] = exception.file_name if exception.respond_to?('file_name')
+      data[:line_number] = exception.line_number if exception.respond_to?('line_number')
+
+      if @capture_source && exception.respond_to?('source_extract')
+        data[:source] = exception.source_extract
+      end
+
+      if exception.respond_to? 'original_exception'
+        inside_exception = exception.original_exception
+      else
+        inside_exception = exception
+      end
+
+      data[:stack_trace] = (inside_exception && inside_exception.respond_to?('backtrace')) ? 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.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}")
+        else
+          @errors << noticed_error
+        end
+      end
+      exception
+    end
+
+    # Get the errors currently queued up.  Unsent errors are left
+    # over from a previous unsuccessful attempt to send them to the server.
+    # We first clear out all unsent errors before sending the newly queued errors.
+    def harvest_errors(unsent_errors)
+      if unsent_errors && !unsent_errors.empty?
+        return unsent_errors
+      else
+        @lock.synchronize do
+          errors = @errors
+          @errors = []
+          return errors
+        end
+      end
+    end
+
+    private
+    def log
+      NewRelic::Agent.logger
+    end
+  end
+end
+end

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

@@ -0,0 +1,18 @@
+# ActiveMerchant Instrumentation.
+
+if defined? ActiveMerchant
+
+  ActiveMerchant::Billing::Gateway.implementations.each do |gateway|
+    gateway.class_eval do
+      implemented_methods = public_instance_methods(false)
+      gateway_name = self.name.split('::').last
+      [:authorize, :purchase, :credit, :void, :capture, :recurring].each do |operation|
+        if implemented_methods.include?(operation.to_s)
+          add_method_tracer operation, "ActiveMerchant/gateway/#{gateway_name}/#{operation}", :scoped_metric_only => true
+          add_method_tracer operation, "ActiveMerchant/gateway/#{gateway_name}", :push_scope => false
+          add_method_tracer operation, "ActiveMerchant/operation/#{operation}", :push_scope => false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+
+# NewRelic instrumentation for ActiveRecord
+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
+              alias_method :log, :log_with_newrelic_instrumentation
+              protected :log
+            end
+          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))
+              supported_config = @config
+            end
+            if name && (parts = name.split " ") && parts.size == 2
+              model = parts.first
+              operation = parts.last.downcase
+              metric_name = case operation
+                            when 'load' then 'find'
+                            when 'indexes', 'columns' then nil # fall back to DirectSQL
+                            when 'destroy', 'find', 'save', 'create' then operation
+                            when 'update' then 'save'
+                            else
+                              if model == 'Join'
+                                operation
+                              end
+                            end
+              metric = "ActiveRecord/#{model}/#{metric_name}" if metric_name
+            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
+              metrics = [metric, "ActiveRecord/all"]
+              metrics << "ActiveRecord/#{metric_name}" if metric_name
+              self.class.trace_execution_scoped(metrics) do
+                t0 = Time.now
+                begin
+                  log_without_newrelic_instrumentation(sql, name, &block)
+                ensure
+                  NewRelic::Agent.instance.transaction_sampler.notice_sql(sql, supported_config, (Time.now - t0).to_f)
+                end
+              end
+            end
+          end
+
+        end
+
+        # instrumentation to catch logged SQL statements in sampled transactions
+        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.
+        ActiveRecord::Base.class_eval do
+          class << self
+            add_method_tracer :find_by_sql, 'ActiveRecord/#{self.name}/find_by_sql', :metric => false
+            add_method_tracer :transaction, 'ActiveRecord/#{self.name}/transaction', :metric => false
+          end
+        end unless NewRelic::Control.instance['disable_activerecord_instrumentation']
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+if defined?(::ActsAsSolr)
+
+  module NewRelic
+    module Instrumentation
+      module ActsAsSolrInstrumentation
+        module ParserMethodsInstrumentation
+          def parse_query_with_newrelic(*args)
+            self.class.trace_execution_scoped(["SolrClient/ActsAsSolr/query"]) do
+              t0 = Time.now
+              begin
+                parse_query_without_newrelic(*args)
+              ensure
+                NewRelic::Agent.instance.transaction_sampler.notice_nosql(args.first.inspect, (Time.now - t0).to_f) rescue nil
+              end
+            end
+
+          end
+        end
+      end
+    end
+  end
+
+  module ActsAsSolr
+    module ParserMethods #:nodoc
+      include NewRelic::Instrumentation::ActsAsSolrInstrumentation::ParserMethodsInstrumentation
+      alias :parse_query_without_newrelic :parse_query
+      alias :parse_query :parse_query_with_newrelic
+    end
+
+    module ClassMethods #:nodoc
+      %w[find_by_solr find_id_by_solr multi_solr_search count_by_solr].each do |method|
+        add_method_tracer method, 'SolrClient/ActsAsSolr/query'
+      end
+      add_method_tracer :rebuild_solr_index, 'SolrClient/ActsAsSolr/index'
+    end
+
+    module CommonMethods #:nodoc
+      add_method_tracer :solr_add, 'SolrClient/ActsAsSolr/add'
+      add_method_tracer :solr_delete, 'SolrClient/ActsAsSolr/delete'
+      add_method_tracer :solr_commit, 'SolrClient/ActsAsSolr/commit'
+      add_method_tracer :solr_optimize, 'SolrClient/ActsAsSolr/optimize'
+    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, 'Custom/Authlogic/record'
+    class << self
+      add_method_tracer :find, 'Custom/Authlogic/find'
+    end
+  end
+end

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

@@ -0,0 +1,409 @@
+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) # :nodoc:
+      clazz.extend(ClassMethods)
+    end
+
+    # This module is for importing stubs when the agent is disabled
+    module ClassMethodsShim # :nodoc:
+      def newrelic_ignore(*args); end
+      def newrelic_ignore_apdex(*args); end
+    end
+
+    module Shim # :nodoc:
+      def self.included(clazz)
+        clazz.extend(ClassMethodsShim)
+      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
+
+    module ClassMethods
+      # Have NewRelic ignore actions in this controller.  Specify the actions as hash options
+      # using :except and :only.  If no actions are specified, all actions are ignored.
+      def newrelic_ignore(specifiers={})
+        newrelic_ignore_aspect('do_not_trace', specifiers)
+      end
+      # Have NewRelic omit apdex measurements on the given actions.  Typically used for
+      # actions that are not user facing or that skew your overall apdex measurement.
+      # Accepts :except and :only options, as with #newrelic_ignore.
+      def newrelic_ignore_apdex(specifiers={})
+        newrelic_ignore_aspect('ignore_apdex', specifiers)
+      end
+
+      def newrelic_ignore_aspect(property, specifiers={}) # :nodoc:
+        if specifiers.empty?
+          self.newrelic_write_attr property, true
+        elsif ! (Hash === specifiers)
+          logger.error "newrelic_#{property} takes an optional hash with :only and :except lists of actions (illegal argument type '#{specifiers.class}')"
+        else
+          self.newrelic_write_attr property, specifiers
+        end
+      end
+
+      # 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}"
+      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"
+        NewRelic::Control.instance.log.debug("Traced transaction: class = #{self.name}, method = #{method.to_s}, options = #{options.inspect}")
+      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!"
+    end
+
+    # 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)
+
+      # 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?('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
+
+      return perform_action_with_newrelic_profile(args, &block) if NewRelic::Control.instance.profiling?
+
+      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
+            NewRelic::Agent::BusyCalculator.dispatcher_start frame_data.start
+            if block_given?
+              yield
+            else
+              perform_action_without_newrelic_trace(*args)
+            end
+          rescue Exception => e
+            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
+    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
+
+    # Profile the instrumented call.  Dev mode only.  Experimental.
+    def perform_action_with_newrelic_profile(args)
+      frame_data = _push_metric_frame(block_given? ? args : [])
+      val = nil
+      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?
+              val = yield
+            else
+              val = perform_action_without_newrelic_trace(*args)
+            end
+          end
+          NewRelic::Agent.instance.transaction_sampler.notice_profile profile
+        end
+      end
+      return val
+    ensure
+      frame_data.pop
+    end
+
+    # 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 args.last.is_a?(Hash)
+          options = 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 : {}
+      end
+      frame_data.request ||= self.request if self.respond_to? :request
+      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
+        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))
+      else
+        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
+
+    # Return a Time instance representing the upstream start time.
+    # now is a Time instance to fall back on if no other candidate
+    # for the start time is found.
+    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.to_f) unless total_time.to_f <= 0.0 # using remote timestamps could lead to negative queue time
+      end
+      return http_entry_time ? Time.at(http_entry_time) : now
+    end
+
+    def _dispatch_stat
+      NewRelic::Agent.agent.stats_engine.get_stats_no_scope 'HttpDispatcher'
+    end
+
+  end
+end
+end
+end