newrelic_rpm 2.8.11 → 2.9.2

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

@@ -1,24 +1,21 @@
 # We have to patch the mongrel dispatcher live since the classes
 # aren't defined when our instrumentation loads
+# To use this module, you need to monkey patch a method newrelic_response_code
+# which will return the response status code when the dispatcher finishes.
 module NewRelic::Agent::Instrumentation
   module DispatcherInstrumentation
     
-    @@newrelic_agent = NewRelic::Agent.agent
-    @@newrelic_rails_dispatch_stat = @@newrelic_agent.stats_engine.get_stats 'Rails/HTTP Dispatch'
-    @@newrelic_mongrel_queue_stat = @@newrelic_agent.stats_engine.get_stats('WebFrontend/Mongrel/Average Queue Time')
-    
     def newrelic_dispatcher_start
       # Put the current time on the thread.  Can't put in @ivar because this could
       # be a class or instance context
-      t0 = Time.now.to_f
-      NewRelic::Config.instance.log.warn "Recursive entry into dispatcher_start!\n#{caller.join("\n   ")}" if Thread.current[:newrelic_t0]
-      Thread.current[:newrelic_t0] = t0
-      NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.dispatcher_start t0
+      newrelic_dispatcher_start_time = Time.now.to_f
+      Thread.current[:newrelic_dispatcher_start] = newrelic_dispatcher_start_time
+      NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.dispatcher_start newrelic_dispatcher_start_time
       # capture the time spent in the mongrel queue, if running in mongrel.  This is the 
       # current time less the timestamp placed in 'started_on' by mongrel. 
       mongrel_start = Thread.current[:started_on]
-      @@newrelic_mongrel_queue_stat.trace_call(t0 - mongrel_start.to_f) if mongrel_start
-      @@newrelic_agent.start_transaction
+      mongrel_queue_stat.trace_call(newrelic_dispatcher_start_time - mongrel_start.to_f) if mongrel_start
+      NewRelic::Agent.agent.start_transaction
       
       # Reset the flag indicating the controller action should be ignored.
       # It may be set by the action to either true or false or left nil meaning false
@@ -26,18 +23,26 @@ module NewRelic::Agent::Instrumentation
     end
     
     def newrelic_dispatcher_finish
-      t0 = Thread.current[:newrelic_t0]
-      if t0.nil?
-        NewRelic::Config.instance.log.warn "Dispatcher finish called twice!\n#{caller.join("\n   ")}" 
-        return
+      #puts @env.to_a.map{|k,v| "#{'%32s' % k}: #{v.inspect[0..64]}"}.join("\n")
+      dispatcher_end_time = Time.now.to_f
+      NewRelic::Agent.agent.end_transaction
+      NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.dispatcher_finish dispatcher_end_time
+      unless Thread.current[:controller_ignored]
+        # Store the response header
+        newrelic_dispatcher_start_time = Thread.current[:newrelic_dispatcher_start]
+        response_code = newrelic_response_code
+        if response_code
+          stats = response_stats[response_code] ||= NewRelic::Agent.agent.stats_engine.get_stats("HTTP/Response/#{response_code}")
+          stats.trace_call(dispatcher_end_time - newrelic_dispatcher_start_time)
+        end
+        dispatch_stat.trace_call(dispatcher_end_time - newrelic_dispatcher_start_time) 
       end
-      t1 = Time.now.to_f
-      @@newrelic_agent.end_transaction
-      @@newrelic_rails_dispatch_stat.trace_call(t1 - t0) unless Thread.current[:controller_ignored]
-      NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.dispatcher_finish t1    
-      Thread.current[:newrelic_t0] = nil
     end
-    
+    def newrelic_response_code
+      raise "Must be implemented in the dispatcher class"
+    end
+    # Used only when no before/after callbacks are available with
+    # the dispatcher, such as Rails before 2.0
     def dispatch_newrelic(*args)
       newrelic_dispatcher_start
       begin
@@ -47,48 +52,62 @@ module NewRelic::Agent::Instrumentation
       end
     end
     
+    private
+    # memoize the stats to avoid the cost of the lookup each time.
+    def dispatch_stat
+      @@newrelic_rails_dispatch_stat ||= NewRelic::Agent.agent.stats_engine.get_stats 'Rails/HTTP Dispatch'  
+    end
+    def mongrel_queue_stat
+      @@newrelic_mongrel_queue_stat ||= NewRelic::Agent.agent.stats_engine.get_stats('WebFrontend/Mongrel/Average Queue Time')  
+    end
+    def response_stats
+      @@newrelic_response_stats ||= { '200' => NewRelic::Agent.agent.stats_engine.get_stats('HTTP/Response/200')}  
+    end
+    
     # This won't work with Rails 2.2 multi-threading
     module BusyCalculator
       extend self
       # the fraction of the sample period that the dispatcher was busy
-      @instance_busy = NewRelic::Agent.agent.stats_engine.get_stats('Instance/Busy')
+      
       @harvest_start = Time.now.to_f
       @accumulator = 0
-      @dispatcher_start = nil    
+      @entrypoint_stack = []
+      @lock = Mutex.new
+      
       def dispatcher_start(time)
-        Thread.critical = true
-        @dispatcher_start = time      
-        Thread.critical = false
+        @lock.synchronize do
+          @entrypoint_stack.push time      
+        end
       end
       
       def dispatcher_finish(time)
-        Thread.critical = true
-        @accumulator += (time - @dispatcher_start)
-        @dispatcher_start = nil
-        
-        Thread.critical = false
+        @lock.synchronize do
+          NewRelic::Control.instance.log.error("Stack underflow tracking dispatcher entry and exit!\n  #{caller.join("  \n")}") and return if @entrypoint_stack.empty?
+          @accumulator += (time - @entrypoint_stack.pop)
+        end
       end
       
-      def is_busy?
-        @dispatcher_start
+      def busy_count
+        @entrypoint_stack.size
       end
-      
+
+      # Called before uploading to to the server to collect current busy stats.
       def harvest_busy
-        Thread.critical = true
-        
-        busy = @accumulator
-        @accumulator = 0
-        
+        busy = 0
         t0 = Time.now.to_f
-        
-        if @dispatcher_start
-          busy += (t0 - @dispatcher_start)
-          @dispatcher_start = t0
+        @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
         
-        
-        Thread.critical = false
-        
         busy = 0.0 if busy < 0.0 # don't go below 0%
         
         time_window = (t0 - @harvest_start)
@@ -96,10 +115,16 @@ module NewRelic::Agent::Instrumentation
         
         busy = busy / time_window
         
-        busy = 1.0 if busy > 1.0    # cap at 100%
-        @instance_busy.record_data_point busy
+        instance_busy_stats.record_data_point busy unless busy == 0
         @harvest_start = t0
       end
+      private
+      def instance_busy_stats
+        # Late binding on the Instance/busy stats
+        @instance_busy ||= NewRelic::Agent.agent.stats_engine.get_stats('Instance/Busy')  
+      end
+      
     end
+    
   end
 end

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

@@ -0,0 +1,14 @@
+module NewRelic::Agent::Instrumentation
+  module ErrorInstrumentation
+    module Shim
+      def newrelic_notice_error(*args); end      
+    end
+    # Send the error instance to New Relic.
+    # +metric_path+ is the optional metric identifier given for the context of the error.
+    # +param_info+ is additional hash of info to be shown with the error. 
+    def newrelic_notice_error(exception, metric_path = nil, param_info = {})
+      metric_path ||= self.newrelic_metric_path if self.respond_to? :newrelic_metric_path 
+      NewRelic::Agent.agent.error_collector.notice_error(exception, nil, metric_path, param_info)
+    end
+  end
+end

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

@@ -4,7 +4,16 @@ require 'merb-core/controller/merb_controller'
 Merb::Controller.class_eval do
   include NewRelic::Agent::Instrumentation::ControllerInstrumentation
   
-  class_inheritable_accessor :newrelic_ignore_attr
+  class_inheritable_accessor :do_not_trace
+  class_inheritable_accessor :ignore_apdex
+  
+  def self.newrelic_write_attr(attr_name, value) # :nodoc:
+    self.send "#{attr_name}=", attr_name, value
+  end
+  
+  def self.newrelic_read_attr(attr_name) # :nodoc:
+    self.send attr_name
+  end
   
   protected
   # determine the path that is used in the metric name for

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

@@ -1,15 +1,13 @@
 require 'merb-core/dispatch/dispatcher'
 # NewRelic RPM instrumentation for http request dispatching (Routes mapping)
-# Note, the dispatcher class from no module into into the ActionController modile 
-# in rails 2.0.  Thus we need to check for both
-
 Merb::Request.class_eval do
   
-  # This is for merb prior to 1.0
   include NewRelic::Agent::Instrumentation::DispatcherInstrumentation
+
   alias_method :dispatch_without_newrelic, :handle
   alias_method :handle, :dispatch_newrelic
-  
-  # After merb 1.0, you can use before and after callbacks
-  # for this?
+  def newrelic_response_code
+    # Don't have an easy way to get the HTTP status from here yet
+    nil
+  end
 end

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

@@ -1,6 +1,8 @@
 # Hook in the notification to merb
 error_notifier = Proc.new {
-  NewRelic::Agent.agent.error_collector.notice_error("#{request.controller.name}/#{params[:action]}", request.path, params, request.exceptions.first)
+  if request.exceptions #check that there's actually an exception
+    NewRelic::Agent.agent.error_collector.notice_error(request.exceptions.first, request, "#{params[:controller]}/#{params[:action]}", params)
+  end
 }
 Merb::Dispatcher::DefaultException.before error_notifier
 Exceptions.before error_notifier

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

@@ -0,0 +1,7 @@
+if defined?(PhusionPassenger)
+  NewRelic::Control.instance.log.debug "Installing Passenger shutdown hook."
+  PhusionPassenger.on_event(:stopping_worker_process) do 
+    NewRelic::Control.instance.log.info "Passenger stopping this process, shutdown the agent."
+    NewRelic::Agent.instance.shutdown
+  end
+end 

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

@@ -1,6 +1,30 @@
 
-if defined? ActionController 
+if defined? ActionController
+  
+  case Rails::VERSION::STRING
 
+    when /^(1\.|2\.0)/  # Rails 1.* - 2.0
+    ActionController::Base.class_eval do
+      add_method_tracer :render, 'View/#{newrelic_metric_path}/Rendering'
+    end  
+
+    when /^2\.1\./  # Rails 2.1
+    ActionView::PartialTemplate.class_eval do
+      add_method_tracer :render, 'View/#{path_without_extension}.#{@view.template_format}.#{extension}/Partial'
+    end
+    ActionView::Template.class_eval do
+      add_method_tracer :render, 'View/#{path_without_extension}.#{@view.template_format}.#{extension}/Rendering'
+    end
+
+    when /^2\./   # Rails 2.2-2.*
+    ActionView::RenderablePartial.module_eval do
+      add_method_tracer :render_partial, 'View/#{path}/Partial'
+    end
+    ActionView::Template.class_eval do
+      add_method_tracer :render, 'View/#{path}/Rendering'
+    end
+  end
+  
   ActionController::Base.class_eval do
     include NewRelic::Agent::Instrumentation::ControllerInstrumentation
     
@@ -10,15 +34,18 @@ if defined? ActionController
     alias_method :perform_action, :perform_action_with_newrelic_trace
     private :perform_action
     
-    add_method_tracer :render, 'View/#{newrelic_metric_path}/Rendering'
+    #add_method_tracer :render_for_file, 'View/#{args[0]}/ForFile/Rendering'
+    #add_method_tracer :render_for_text, 'View/#{newrelic_metric_path}/Text/Rendering'
+    #add_method_tracer :render, 'View/#{newrelic_metric_path}/Rendering'
     
-    def self.newrelic_ignore_attr=(value)
-      write_inheritable_attribute('do_not_trace', value)
+    def self.newrelic_write_attr(attr_name, value) # :nodoc:
+      write_inheritable_attribute(attr_name, value)
     end
-    def self.newrelic_ignore_attr
-      read_inheritable_attribute('do_not_trace')
+    
+    def self.newrelic_read_attr(attr_name) # :nodoc:
+      read_inheritable_attribute(attr_name)
     end
-
+    
     # determine the path that is used in the metric name for
     # the called controller action
     def newrelic_metric_path(action_name_override = nil)

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

@@ -1,5 +1,4 @@
 require 'dispatcher'
-
 # NewRelic RPM instrumentation for http request dispatching (Routes mapping)
 # Note, the dispatcher class from no module into into the ActionController module 
 # in Rails 2.0.  Thus we need to check for both
@@ -7,23 +6,32 @@ if defined? ActionController::Dispatcher
   target = ActionController::Dispatcher
 elsif defined? Dispatcher
   target = Dispatcher
-else
-  target = nil
 end
 
+# NOTE TODO: maybe this should be done with a middleware?
 if target
+  require 'action_pack/version'
   NewRelic::Agent.instance.log.debug "Adding #{target} instrumentation"
   
-  # in Rails 2.3 (Rack-based) we don't want to add instrumentation on class level
-  unless defined? ::Rails::Rack
-    target = target.class_eval { class << self; self; end }
-  end
-  
   target.class_eval do
-    include NewRelic::Agent::Instrumentation::DispatcherInstrumentation
-
-    alias_method :dispatch_without_newrelic, :dispatch
-    alias_method :dispatch, :dispatch_newrelic
+    if ActionPack::VERSION::MAJOR >= 2
+      # In versions later that 1.* the dispatcher callbacks are used
+      include NewRelic::Agent::Instrumentation::DispatcherInstrumentation
+      before_dispatch :newrelic_dispatcher_start
+      after_dispatch :newrelic_dispatcher_finish
+      def newrelic_response_code
+        (@response.headers['Status']||'200')[0..2] if ActionPack::VERSION::MAJOR == 2 && ActionPack::VERSION::MINOR < 3 
+      end
+    else
+      # In version 1.2.* the instrumentation is done by method chaining
+      # the static dispatch method on the dispatcher class
+      extend NewRelic::Agent::Instrumentation::DispatcherInstrumentation
+      class << self
+        alias_method :dispatch_without_newrelic, :dispatch
+        alias_method :dispatch, :dispatch_newrelic
+        def newrelic_response_code; end
+      end
+    end
   end
 else
   NewRelic::Agent.instance.log.debug "WARNING: Dispatcher instrumentation not added"

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

@@ -1,11 +1,10 @@
-# todo: patch rescue_action and track how many are occuring and capture instances as well
+
 ActionController::Base.class_eval do
   
   def newrelic_notice_error(exception)
-    local_params = (respond_to? :filter_parameters) ? filter_parameters(params) : params
+    filtered_params = (respond_to? :filter_parameters) ? filter_parameters(params) : params
     
-    NewRelic::Agent.agent.error_collector.notice_error(newrelic_metric_path, (request) ? request.path : nil,
-    local_params, exception)
+    NewRelic::Agent.agent.error_collector.notice_error(exception, request, newrelic_metric_path, filtered_params)
   end
   
   def rescue_action_with_newrelic_trace(exception)
@@ -21,3 +20,5 @@ ActionController::Base.class_eval do
   protected :rescue_action
 
 end if defined? ActionController
+
+Object.send :include, NewRelic::Agent::Instrumentation::ErrorInstrumentation

data/lib/new_relic/agent/method_tracer.rb

@@ -1,171 +1,195 @@
+module NewRelic::Agent
 
-class Module
-  
-  # Original method preserved for API backward compatibility
-  def trace_method_execution (metric_name, push_scope, produce_metric, deduct_call_time_from_parent, &block)
-    if push_scope
-      trace_method_execution_with_scope(metric_name, produce_metric, deduct_call_time_from_parent, &block)
-    else
-      trace_method_execution_no_scope(metric_name, &block)
-    end
-  end
-  
-  # This is duplicated inline in add_method_tracer
-  def trace_method_execution_no_scope(metric_name)
-    t0 = Time.now.to_f
-    stats = @@newrelic_stats_engine.get_stats_no_scope metric_name
-  
-    result = yield
-    duration = Time.now.to_f - t0              # for some reason this is 3 usec faster than Time - Time
-    stats.trace_call(duration, duration)    
-    result 
-  end
+  # These are stubs for API methods installed when the agent is disabled.
 
-  def trace_method_execution_with_scope(metric_name, produce_metric, deduct_call_time_from_parent)
+  module MethodTracerShim
+    def trace_method_execution(*args); yield; end
+    
+    def trace_method_execution_no_scope(metric_name); yield; end
+    def trace_method_execution_with_scope(*args); yield; end
+    def add_method_tracer (*args); end
+    def remove_method_tracer(*args); end
+  end
   
-    t0 = Time.now.to_f
-    stats = nil
+  # These are the class methods added to support installing custom
+  # metric tracers and executing for individual metrics.
+  # This module is included in class Module.
+  module MethodTracer
     
-    begin
-      # Keep a reference to the scope we are pushing so we can do a sanity check making
-      # sure when we pop we get the one we 'expected'
-      expected_scope = @@newrelic_stats_engine.push_scope(metric_name, t0, deduct_call_time_from_parent)
+    # Deprecated: original method preserved for API backward compatibility, use one of the other
+    # +trace_method..+ calls.
+    def trace_method_execution(metric_name, push_scope, produce_metric, deduct_call_time_from_parent, &block) 
+      if push_scope
+        trace_method_execution_with_scope(metric_name, produce_metric, deduct_call_time_from_parent, &block)
+      else
+        trace_method_execution_no_scope(metric_name, &block)
+      end
+    end
+    
+    # Trace a given block with stats assigned to the given metric_name.  It does not 
+    # provide scoped measurements, meaning whatever is being traced will not 'blame the
+    # Controller'--that is to say appear in the breakdown chart. 
+    # This is duplicated inline in #add_method_tracer.
+    def trace_method_execution_no_scope(metric_name)
+      t0 = Time.now.to_f
+      stats = NewRelic::Agent.instance.stats_engine.get_stats_no_scope metric_name
       
-      stats = @@newrelic_stats_engine.get_stats metric_name, true if produce_metric
-    rescue => e
-      NewRelic::Config.instance.log.error("Caught exception in trace_method_execution header. Metric name = #{metric_name}, exception = #{e}")
-      NewRelic::Config.instance.log.error(e.backtrace.join("\n"))
+      begin
+        yield
+      ensure
+        duration = Time.now.to_f - t0              # for some reason this is 3 usec faster than Time - Time
+        stats.trace_call(duration, duration)
+      end
     end
 
-    begin
-      yield
-    ensure
-      t1 = Time.now.to_f
-      duration = t1 - t0
+    # Trace a given block with stats, like #trace_method_execution_no_scope but 
+    def trace_method_execution_with_scope(metric_name, produce_metric, deduct_call_time_from_parent, scoped_metric_only=false)
+      t0 = Time.now.to_f
+      stats = nil
       
       begin
-        if expected_scope
-          scope = @@newrelic_stats_engine.pop_scope expected_scope, duration, t1
-          
-          exclusive = duration - scope.children_time
-          stats.trace_call(duration, exclusive) if stats
-        end
+        # Keep a reference to the scope we are pushing so we can do a sanity check making
+        # sure when we pop we get the one we 'expected'
+        expected_scope = NewRelic::Agent.instance.stats_engine.push_scope(metric_name, t0, deduct_call_time_from_parent)
+        
+        stats = NewRelic::Agent.instance.stats_engine.get_stats(metric_name, true, scoped_metric_only) if produce_metric
       rescue => e
-        NewRelic::Config.instance.log.error("Caught exception in trace_method_execution footer. Metric name = #{metric_name}, exception = #{e}")
-        NewRelic::Config.instance.log.error(e.backtrace.join("\n"))
+        NewRelic::Control.instance.log.error("Caught exception in trace_method_execution header. Metric name = #{metric_name}, exception = #{e}")
+        NewRelic::Control.instance.log.error(e.backtrace.join("\n"))
+      end
+      
+      begin
+        yield
+      ensure
+        t1 = Time.now.to_f
+        duration = t1 - t0
+        
+        begin
+          if expected_scope
+            scope = NewRelic::Agent.instance.stats_engine.pop_scope expected_scope, duration, t1
+            
+            exclusive = duration - scope.children_time
+            stats.trace_call(duration, exclusive) if stats
+          end
+        rescue => e
+          NewRelic::Control.instance.log.error("Caught exception in trace_method_execution footer. Metric name = #{metric_name}, exception = #{e}")
+          NewRelic::Control.instance.log.error(e.backtrace.join("\n"))
+        end
       end
     end
-  end
-
-  # Add a method tracer to the specified method.  
-  # metric_name_code is ruby code that determines the name of the
-  # metric to be collected during tracing.  As such, the code
-  # should be provided in 'single quote' strings rather than
-  # "double quote" strings, so that #{} evaluation happens
-  # at traced method execution time.
-  # Example: tracing a method :foo, where the metric name is
-  # the first argument converted to a string
-  #     add_method_tracer :foo, '#{args.first.to_s}'
-  # statically defined metric names can be specified as regular strings
-  # push_scope specifies whether this method tracer should push
-  # the metric name onto the scope stack.
-  def add_method_tracer (method_name, metric_name_code, options = {})
-    return unless NewRelic::Agent.agent.config.tracers_enabled?
-    
-    @@newrelic_stats_engine ||= NewRelic::Agent.agent.stats_engine
-    
-    if !options.is_a?(Hash)
-      options = {:push_scope => options} 
-    end
-    # options[:push_scope] true if we are noting the scope of this for
-    # stats collection as well as the transaction tracing
-    options[:push_scope] = true if options[:push_scope].nil?
-    # options[:metric] true if you are tracking stats for a metric, otherwise
-    # it's just for transaction tracing.
-    options[:metric] = true if options[:metric].nil?
-    options[:deduct_call_time_from_parent] = false if options[:deduct_call_time_from_parent].nil? && !options[:metric]
-    options[:deduct_call_time_from_parent] = true if options[:deduct_call_time_from_parent].nil?
-    options[:code_header] ||= ""
-    options[:code_footer] ||= ""
-    
-    klass = (self === Module) ? "self" : "self.class"
-    
-    unless method_defined?(method_name) || private_method_defined?(method_name)
-      NewRelic::Config.instance.log.warn("Did not trace #{self}##{method_name} because that method does not exist")
-      return
-    end
-    
-    traced_method_name = _traced_method_name(method_name, metric_name_code)
-    if method_defined? traced_method_name
-      NewRelic::Config.instance.log.warn("Attempt to trace a method twice with the same metric: Method = #{method_name}, Metric Name = #{metric_name_code}")
-      return
-    end
-    
-    fail "Can't add a tracer where push_scope is false and metric is false" if options[:push_scope] == false && !options[:metric]
     
-    if options[:push_scope] == false
-      class_eval "@@newrelic_stats_engine = NewRelic::Agent.agent.stats_engine"
-      code = <<-CODE
+    # Add a method tracer to the specified method.  
+    # metric_name_code is ruby code that determines the name of the
+    # metric to be collected during tracing.  As such, the code
+    # should be provided in 'single quote' strings rather than
+    # "double quote" strings, so that #{} evaluation happens
+    # at traced method execution time.
+    #
+    # Example: tracing a method :foo, where the metric name is
+    # the first argument converted to a string
+    #
+    #     add_method_tracer :foo, '#{args.first.to_s}'
+    #
+    # Statically defined metric names can be specified as regular strings.
+    # The option +:push_scope+ specifies whether this method tracer should 
+    # keep track of the caller so it will show up in controller breakdown
+    # pie charts.
+    def add_method_tracer (method_name, metric_name_code, options = {})
+      if !options.is_a?(Hash)
+        options = {:push_scope => options} 
+      end
+      # options[:push_scope] true if we are noting the scope of this for
+      # stats collection as well as the transaction tracing
+      options[:push_scope] = true if options[:push_scope].nil?
+      # options[:metric] true if you are tracking stats for a metric, otherwise
+      # it's just for transaction tracing.
+      options[:metric] = true if options[:metric].nil?
+      options[:deduct_call_time_from_parent] = false if options[:deduct_call_time_from_parent].nil? && !options[:metric]
+      options[:deduct_call_time_from_parent] = true if options[:deduct_call_time_from_parent].nil?
+      options[:code_header] ||= ""
+      options[:code_footer] ||= ""
+      options[:scoped_metric_only] ||= false
+      
+      klass = (self === Module) ? "self" : "self.class"
+      
+      unless method_defined?(method_name) || private_method_defined?(method_name)
+        NewRelic::Control.instance.log.warn("Did not trace #{self}##{method_name} because that method does not exist")
+        return
+      end
+      
+      traced_method_name = _traced_method_name(method_name, metric_name_code)
+      if method_defined? traced_method_name
+        NewRelic::Control.instance.log.warn("Attempt to trace a method twice with the same metric: Method = #{method_name}, Metric Name = #{metric_name_code}")
+        return
+      end
+      
+      fail "Can't add a tracer where push_scope is false and metric is false" if options[:push_scope] == false && !options[:metric]
+      
+      if options[:push_scope] == false
+        code = <<-CODE
         def #{_traced_method_name(method_name, metric_name_code)}(*args, &block)
           #{options[:code_header]}
 
           t0 = Time.now.to_f
-          stats = @@newrelic_stats_engine.get_stats_no_scope "#{metric_name_code}"
+          stats = NewRelic::Agent.instance.stats_engine.get_stats_no_scope "#{metric_name_code}"
 
-          result = #{_untraced_method_name(method_name, metric_name_code)}(*args, &block)
-          duration = Time.now.to_f - t0
-          stats.trace_call(duration, duration)     # for some reason this is 3 usec faster than Time - Time
-          #{options[:code_footer]}
-          result 
+          begin
+            #{_untraced_method_name(method_name, metric_name_code)}(*args, &block)
+          ensure
+            duration = Time.now.to_f - t0
+            stats.trace_call(duration, duration)     # for some reason this is 3 usec faster than Time - Time
+            #{options[:code_footer]}
+          end
         end
       CODE
-    else
-      code = <<-CODE
+      else
+        code = <<-CODE
       def #{_traced_method_name(method_name, metric_name_code)}(*args, &block)
         #{options[:code_header]}
-        result = #{klass}.trace_method_execution_with_scope("#{metric_name_code}", #{options[:metric]}, #{options[:deduct_call_time_from_parent]}) do
+        result = #{klass}.trace_method_execution_with_scope("#{metric_name_code}", #{options[:metric]}, #{options[:deduct_call_time_from_parent]}, #{options[:scoped_metric_only]}) do
           #{_untraced_method_name(method_name, metric_name_code)}(*args, &block)
         end
         #{options[:code_footer]}
         result
       end
       CODE
+      end
+      
+      class_eval code, __FILE__, __LINE__
+      
+      alias_method _untraced_method_name(method_name, metric_name_code), method_name
+      alias_method method_name, _traced_method_name(method_name, metric_name_code)
+      
+      NewRelic::Control.instance.log.debug("Traced method: class = #{self}, method = #{method_name}, "+
+        "metric = '#{metric_name_code}', options: #{options.inspect}, ")
     end
+    
+    # Not recommended for production use, because tracers must be removed in reverse-order
+    # from when they were added, or else other tracers that were added to the same method
+    # may get removed as well.
+    def remove_method_tracer(method_name, metric_name_code)
+      return unless NewRelic::Control.instance.agent_enabled?
       
-    class_eval code, __FILE__, __LINE__
-  
-    alias_method _untraced_method_name(method_name, metric_name_code), method_name
-    alias_method method_name, _traced_method_name(method_name, metric_name_code)
+      if method_defined? "#{_traced_method_name(method_name, metric_name_code)}"
+        alias_method method_name, "#{_untraced_method_name(method_name, metric_name_code)}"
+        undef_method "#{_traced_method_name(method_name, metric_name_code)}"
+      else
+        raise "No tracer for '#{metric_name_code}' on method '#{method_name}'"
+      end
+    end
     
-    NewRelic::Config.instance.log.debug("Traced method: class = #{self}, method = #{method_name}, "+
-        "metric = '#{metric_name_code}', options: #{options}, ")
-  end
-
-  # Not recommended for production use, because tracers must be removed in reverse-order
-  # from when they were added, or else other tracers that were added to the same method
-  # may get removed as well.
-  def remove_method_tracer(method_name, metric_name_code)
-    return unless NewRelic::Agent.agent.config.tracers_enabled?
+    private
     
-    if method_defined? "#{_traced_method_name(method_name, metric_name_code)}"
-      alias_method method_name, "#{_untraced_method_name(method_name, metric_name_code)}"
-      undef_method "#{_traced_method_name(method_name, metric_name_code)}"
-    else
-      raise "No tracer for '#{metric_name_code}' on method '#{method_name}'"
-    end
-  end
-
-private
-
-  def _untraced_method_name(method_name, metric_name)
+    def _untraced_method_name(method_name, metric_name)
     "#{_sanitize_name(method_name)}_without_trace_#{_sanitize_name(metric_name)}" 
-  end
-  
-  def _traced_method_name(method_name, metric_name)
+    end
+    
+    def _traced_method_name(method_name, metric_name)
     "#{_sanitize_name(method_name)}_with_trace_#{_sanitize_name(metric_name)}" 
-  end
-  
-  def _sanitize_name(name)
-    name.to_s.tr('^a-z,A-Z,0-9', '_')
+    end
+    
+    def _sanitize_name(name)
+      name.to_s.tr('^a-z,A-Z,0-9', '_')
+    end
   end
 end