factorylabs-newrelic_rpm 2.10.2.2

data/lib/new_relic/agent/busy_calculator.rb

@@ -0,0 +1,86 @@
+# 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::Agent::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

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/collection_helper.rb

@@ -0,0 +1,66 @@
+module NewRelic::Agent::CollectionHelper
+  # Transform parameter hash into a hash whose values are strictly
+  # strings
+  def normalize_params(params)
+    case params
+      when Symbol, FalseClass, TrueClass, nil
+        params
+      when Numeric
+        truncate(params.to_s)
+      when String
+        truncate(params)
+      when Hash
+        new_params = {}
+        params.each do | key, value |
+          new_params[truncate(normalize_params(key),32)] = normalize_params(value)
+        end
+        new_params
+      when Array
+        params.first(20).map{|item| normalize_params(item)}
+    else
+      truncate(flatten(params))
+    end
+  end
+  
+  # Return an array of strings (backtrace), cleaned up for readability
+  # Return nil if there is no backtrace
+  
+  def strip_nr_from_backtrace(backtrace)
+    if backtrace
+      # this is for 1.9.1, where strings no longer have Enumerable
+      backtrace = backtrace.split("\n") if String === backtrace
+      # strip newrelic from the trace
+      backtrace = backtrace.reject {|line| line =~ /new_relic\/agent\// }
+      # rename methods back to their original state
+      backtrace = backtrace.collect {|line| line.gsub(/_without_(newrelic|trace)/, "")}
+    end
+    backtrace
+  end
+  
+  private
+  
+  # Convert any kind of object to a short string.
+  def flatten(object)
+    s = case object 
+      when nil then ''
+      when object.instance_of?(String) then object
+      when String then String.new(object)  # convert string subclasses to strings
+      else "#<#{object.class.to_s}>"
+    end
+  end
+  def truncate(string, len=256)
+    case string
+    when Symbol then string
+    when nil then ""
+    when String
+      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

data/lib/new_relic/agent/error_collector.rb

@@ -0,0 +1,117 @@
+
+module NewRelic::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
+      @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.fetch('enabled', true)
+      @capture_source = config.fetch('capture_source', true)
+      
+      ignore_errors = config.fetch('ignore_errors', "")
+      ignore_errors = ignore_errors.split(",")
+      ignore_errors.each { |error| error.strip! } 
+      ignore(ignore_errors)
+      @lock = Mutex.new
+    end
+    
+    def ignore_error_filter(&block)
+      @ignore_filter = block
+    end
+    
+    
+    # errors is an array of Exception Class Names
+    #
+    def ignore(errors)
+      errors.each { |error| @ignore[error] = true; log.debug("Ignoring error: '#{error}'") }
+    end
+    
+    def notice_error(exception, request=nil, action_path=nil, filtered_params={})
+      return unless @enabled
+      return if @ignore[exception.class.name] 
+      if @ignore_filter
+        exception = @ignore_filter.call(exception)
+        return if exception.nil?
+      end
+      NewRelic::Agent.get_stats("Errors/all").increment_count
+      return unless NewRelic::Agent.instance.should_send_errors
+      
+      action_path ||= NewRelic::Agent.instance.stats_engine.scope_name || ''
+      
+      data = {}
+      
+      data[:request_params] = normalize_params(filtered_params) if NewRelic::Control.instance.capture_params
+
+      data[:custom_params] = normalize_params(NewRelic::Agent.instance.custom_params) 
+      
+      data[:request_uri] = request.path if request
+      data[:request_uri] ||= ""
+      
+      data[:request_referer] = request.referer if request
+      data[:request_referer] ||= ""
+      
+      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.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}")
+        else
+          @errors << noticed_error
+        end
+      end
+    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::Control.instance.log
+    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,91 @@
+
+# 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.to_f
+                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
+          
+        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
+          end
+        end unless NewRelic::Control.instance['disable_activerecord_instrumentation']
+      end
+    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

@@ -0,0 +1,389 @@
+
+module NewRelic::Agent::Instrumentation
+  # == 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 use
+  # #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"
+      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>
+    #
+    # 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.
+    #
+    # 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?('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 : [])
+      
+      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
+        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
+    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 : [])
+      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
+    
+    # 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 = MetricFrame.current(true)
+      
+      frame_data.apdex_start ||= _detect_upstream_wait(frame_data.start)
+      
+      # If a block was passed in, then the arguments represent options for the instrumentation,
+      # not app method arguments.
+      if args.any?
+        frame_data.force_flag = args.last.is_a?(Hash) && args.last[:force]
+        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.push(category, path)
+      frame_data.filtered_params = (respond_to? :filter_parameters) ? filter_parameters(available_params) : available_params
+      frame_data.available_request ||= (respond_to? :request) ? request : nil
+      frame_data
+    end
+        
+    def _convert_args_to_path(args)
+      options =  args.last.is_a?(Hash) ? args.pop : {}
+      category = 'Controller'
+      params = options[:params] || {}
+      unless path = options[:path]
+        category = case options[:category]
+        when :controller, nil then 'Controller'
+        when :task then 'Controller' #'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
+        # To be consistent with the ActionController::Base#controller_path used in rails to determine the
+        # metric path, we drop the controller off the end of the path if there is one.
+        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
+    
+    def _detect_upstream_wait(now)
+      if newrelic_request_headers
+        if entry_time = newrelic_request_headers['HTTP_X_REQUEST_START']
+          if queue_depth = newrelic_request_headers['HTTP_X_HEROKU_QUEUE_DEPTH']
+            http_entry_time = entry_time.to_f / 1e3
+            _record_heroku_queue_depth(queue_depth)
+          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 _record_heroku_queue_depth(header)
+      length_stat = NewRelic::Agent.agent.stats_engine.get_stats_no_scope('Mongrel/Queue Length')
+      length_stat.trace_call(header.to_i)
+    end
+    
+    def _dispatch_stat
+      NewRelic::Agent.agent.stats_engine.get_stats_no_scope 'HttpDispatcher'  
+    end
+    
+    
+  end 
+end