honkster-newrelic_rpm 2.13.1

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

@@ -0,0 +1,17 @@
+if defined? Net::HTTP
+  Net::HTTP.class_eval do
+    def request_with_newrelic_trace(*args, &block)
+      metrics = ["External/#{@address}/Net::HTTP/#{args[0].method}","External/#{@address}/all"]
+      if NewRelic::Agent::Instrumentation::MetricFrame.recording_web_transaction?
+        metrics << "External/allWeb"
+      else
+        metrics << "External/allOther"
+      end
+      self.class.trace_execution_scoped metrics do
+        request_without_newrelic_trace(*args, &block)
+      end
+    end
+    alias request_without_newrelic_trace request
+    alias request request_with_newrelic_trace
+  end
+end

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

@@ -0,0 +1,22 @@
+if defined?(PhusionPassenger)
+  NewRelic::Agent.logger.debug "Installing Passenger event hooks."
+
+  PhusionPassenger.on_event(:stopping_worker_process) do
+    NewRelic::Agent.logger.debug "Passenger stopping this process, shutdown the agent."
+    NewRelic::Agent.instance.shutdown
+  end
+
+  PhusionPassenger.on_event(:starting_worker_process) do |forked|
+    # We want to reset the stats from the stats engine in case any carried
+    # over into the spawned process.  Don't clear them in case any were
+    # cached.  We do this even in conservative spawning.
+    NewRelic::Agent.after_fork(:force_reconnect => true)
+  end
+
+elsif (defined?(::Passenger) && defined?(::Passenger::AbstractServer)) || defined?(::IN_PHUSION_PASSENGER)
+  # We're on an older version of passenger
+  NewRelic::Agent.logger.warn "An older version of Phusion Passenger has been detected.  We recommend using at least release 2.1.1."
+
+  NewRelic::Agent::Instrumentation::MetricFrame.check_server_connection = true
+
+end

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

@@ -0,0 +1,98 @@
+require 'new_relic/agent/instrumentation/controller_instrumentation'
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      # == Instrumentation for Rack
+      #
+      # New Relic will instrument a #call method as if it were a controller
+      # action, collecting transaction traces and errors.  The middleware will
+      # be identified only by it's class, so if you want to instrument multiple
+      # actions in a middleware, you need to use
+      # NewRelic::Agent::Instrumentation::ControllerInstrumentation::ClassMethods#add_transaction_tracer
+      #
+      # Example:
+      #   require 'newrelic_rpm'
+      #   require 'new_relic/agent/instrumentation/rack'
+      #   class Middleware
+      #     def call(env)
+      #       ...
+      #     end
+      #     # Do the include after the call method is defined:
+      #     include NewRelic::Agent::Instrumentation::Rack
+      #   end
+      #
+      # == Instrumenting Metal and Cascading Middlewares
+      #
+      # Metal apps and apps belonging to Rack::Cascade middleware
+      # follow a convention of returning a 404 for all requests except
+      # the ones they are set up to handle.  This means that New Relic
+      # needs to ignore these calls when they return a 404.
+      #
+      # In these cases, you should not include or extend the Rack
+      # module but instead include
+      # NewRelic::Agent::Instrumentation::ControllerInstrumentation.
+      # Here's how that might look for a Metal app:
+      #
+      #   require 'new_relic/agent/instrumentation/controller_instrumentation'
+      #   class MetalApp
+      #     extend NewRelic::Agent::Instrumentation::ControllerInstrumentation
+      #     def self.call(env)
+      #       if should_do_my_thing?
+      #         perform_action_with_newrelic_trace(:category => :rack) do
+      #           return my_response(env)
+      #         end
+      #       else
+      #         return [404, {"Content-Type" => "text/html"}, ["Not Found"]]
+      #       end
+      #     end
+      #   end
+      #
+      # == Overriding the metric name
+      #
+      # By default the middleware is identified only by its class, but if you want to
+      # be more specific and pass in name, then omit including the Rack instrumentation
+      # and instead follow this example:
+      #
+      #   require 'newrelic_rpm'
+      #   require 'new_relic/agent/instrumentation/controller_instrumentation'
+      #   class Middleware
+      #     include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+      #     def call(env)
+      #       ...
+      #     end
+      #     add_transaction_tracer :call, :category => :rack, :name => 'my app'
+      #   end
+      #
+      module Rack
+        def newrelic_request_headers
+          @newrelic_request.env
+        end
+        def call_with_newrelic(*args)
+          @newrelic_request = ::Rack::Request.new(args.first)
+          perform_action_with_newrelic_trace(:category => :rack, :request => @newrelic_request) do
+            result = call_without_newrelic(*args)
+            # Ignore cascaded calls
+            MetricFrame.abort_transaction! if result.first == 404
+            result
+          end
+        end
+        def self.included middleware #:nodoc:
+          middleware.class_eval do
+            alias call_without_newrelic call
+            alias call call_with_newrelic
+          end
+        end
+        include ControllerInstrumentation
+        def self.extended middleware #:nodoc:
+          middleware.class_eval do
+            class << self
+              alias call_without_newrelic call
+              alias call call_with_newrelic
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+
+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[%r{^(/.*/)?(.*)$},2]}.#{@view.template_format}.#{extension}/Partial'
+    end
+    # this is for template rendering, as opposed to partial rendering.
+    ActionView::Template.class_eval do
+      add_method_tracer :render, 'View/#{(path_without_extension || @view.controller.newrelic_metric_path)[%r{^(/.*/)?(.*)$},2]}.#{@view.template_format}.#{extension}/Rendering'
+    end
+
+    when /^2\./   # Rails 2.2-2.*
+    ActionView::RenderablePartial.module_eval do
+      add_method_tracer :render_partial, 'View/#{path[%r{^(/.*/)?(.*)$},2]}/Partial'
+    end
+    ActionView::Template.class_eval do
+      add_method_tracer :render, 'View/#{path[%r{^(/.*/)?(.*)$},2]}/Rendering'
+    end
+  end unless NewRelic::Control.instance['disable_view_instrumentation']
+
+  ActionController::Base.class_eval do
+    include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+
+    # Compare with #alias_method_chain, which is not available in
+    # Rails 1.1:
+    alias_method :perform_action_without_newrelic_trace, :perform_action
+    alias_method :perform_action, :perform_action_with_newrelic_trace
+    private :perform_action
+
+    def self.newrelic_write_attr(attr_name, value) # :nodoc:
+      write_inheritable_attribute(attr_name, value)
+    end
+
+    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)
+      action_part = action_name_override || action_name
+      if action_name_override || self.class.action_methods.include?(action_part)
+        "#{self.class.controller_path}/#{action_part}"
+      else
+        "#{self.class.controller_path}/(other)"
+      end
+    end
+  end
+else
+  NewRelic::Agent.instance.log.debug "WARNING: ActionController instrumentation not added"
+end

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

@@ -0,0 +1,27 @@
+# NewRelic Agent instrumentation for WebServices
+
+# Note Action Web Service is removed from default package in rails 2.0
+if defined? ActionWebService
+
+  # instrumentation for Web Service martialing - XML RPC
+  ActionWebService::Protocol::XmlRpc::XmlRpcProtocol.class_eval do
+    add_method_tracer :decode_request, "WebService/Xml Rpc/XML Decode"
+    add_method_tracer :encode_request, "WebService/Xml Rpc/XML Encode"
+    add_method_tracer :decode_response, "WebService/Xml Rpc/XML Decode"
+    add_method_tracer :encode_response, "WebService/Xml Rpc/XML Encode"
+  end
+
+  # instrumentation for Web Service martialing - Soap
+  ActionWebService::Protocol::Soap::SoapProtocol.class_eval do
+    add_method_tracer :decode_request, "WebService/Soap/XML Decode"
+    add_method_tracer :encode_request, "WebService/Soap/XML Encode"
+    add_method_tracer :decode_response, "WebService/Soap/XML Decode"
+    add_method_tracer :encode_response, "WebService/Soap/XML Encode"
+  end
+
+  ActionController::Base.class_eval do
+    if method_defined? :perform_invocation
+      add_method_tracer :perform_invocation, 'WebService/#{controller_name}/#{args.first}'
+    end
+  end if defined? ActionController::Base
+end

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

@@ -0,0 +1,24 @@
+
+ActionController::Base.class_eval do
+
+  # Make a note of an exception associated with the currently executing
+  # controller action.  Note that this used to be available on Object
+  # but we replaced that global method with NewRelic::Agent#notice_error.
+  # Use that one outside of controller actions.
+  def newrelic_notice_error(exception, custom_params = {})
+    NewRelic::Agent::Instrumentation::MetricFrame.notice_error exception, :custom_params => custom_params, :request => request
+  end
+
+  def rescue_action_with_newrelic_trace(exception)
+    rescue_action_without_newrelic_trace exception
+    NewRelic::Agent::Instrumentation::MetricFrame.notice_error exception, :request => request
+  end
+
+  # Compare with #alias_method_chain, which is not available in
+  # Rails 1.1:
+  alias_method :rescue_action_without_newrelic_trace, :rescue_action
+  alias_method :rescue_action, :rescue_action_with_newrelic_trace
+  protected :rescue_action
+
+end if defined? ActionController
+

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

@@ -0,0 +1,45 @@
+module NewRelic
+  module Agent
+    module Instrumentation
+      module Rails3
+        module ActionController
+          def self.newrelic_write_attr(attr_name, value) # :nodoc:
+            write_inheritable_attribute(attr_name, value)
+          end
+
+          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)
+            action_part = action_name_override || action_name
+            if action_name_override || self.class.action_methods.include?(action_part)
+              "#{self.class.controller_path}/#{action_part}"
+            else
+              "#{self.class.controller_path}/(other)"
+            end
+          end
+
+          def process_action(*args)
+
+            perform_action_with_newrelic_trace(:category => :controller, :name => self.action_name, :params => request.filtered_parameters, :class_name => self.class.name)  do
+              super
+            end
+          end
+
+        end
+      end
+    end
+  end
+end
+
+if defined?(ActionController) && defined?(ActionController::Base)
+  puts "ApplicationController is defined"
+  class ActionController::Base
+    include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+    include NewRelic::Agent::Instrumentation::Rails3::ActionController
+  end
+end
+

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

@@ -0,0 +1,21 @@
+module NewRelic
+  module Agent
+    module Instrumentation
+      module Rails3
+        module Errors
+          def newrelic_notice_error(exception, custom_params = {})
+            filtered_params = (respond_to? :filter_parameters) ? filter_parameters(params) : params
+            filtered_params.merge!(custom_params)
+            NewRelic::Agent.agent.error_collector.notice_error(exception, request, newrelic_metric_path, filtered_params)
+          end
+        end
+      end
+    end
+  end
+end
+
+if defined?(ActionController) && defined?(ActionController::Base)
+  class ActionController::Base
+    include NewRelic::Agent::Instrumentation::Rails3::Errors
+  end
+end

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

@@ -0,0 +1,46 @@
+if defined?(Sinatra::Base)
+  require 'new_relic/agent/instrumentation/controller_instrumentation'
+  module NewRelic
+    module Agent
+      module Instrumentation
+        # NewRelic instrumentation for Sinatra applications.  Sinatra actions will
+        # appear in the UI similar to controller actions, and have breakdown charts
+        # and transaction traces.
+        #
+        # The actions in the UI will correspond to the pattern expression used
+        # to match them.  HTTP operations are not distinguished.  Multiple matches
+        # will all be tracked as separate actions.
+        module Sinatra
+
+          include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+
+          def route_eval_with_newrelic(&block_arg)
+            path = unescape(@request.path_info)
+            name = path
+            # Go through each route and look for a match
+            if routes = self.class.routes[@request.request_method]
+              routes.detect do |pattern, keys, conditions, block|
+                if block_arg.equal? block
+                  name = pattern.source
+                end
+              end
+            end
+            # strip of leading ^ and / chars and trailing $ and /
+            name.gsub!(%r{^[/^]*(.*?)[/\$]*$}, '\1')
+            name = 'root' if name.empty?
+            perform_action_with_newrelic_trace(:category => :sinatra, :name => name) do
+              route_eval_without_newrelic(&block_arg)
+            end
+          end
+        end
+
+        ::Sinatra::Base.class_eval do
+          include NewRelic::Agent::Instrumentation::Sinatra
+          alias route_eval_without_newrelic route_eval
+          alias route_eval route_eval_with_newrelic
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+if defined?(::Sunspot)
+  ::Sunspot.module_eval do
+    class << self
+      %w(index index!).each do |method|
+        add_method_tracer method, 'SolrClient/Sunspot/index'
+      end
+      add_method_tracer :commit, 'SolrClient/Sunspot/commit'
+
+      %w[search more_like_this].each do |method|
+        add_method_tracer method, 'SolrClient/Sunspot/query'
+      end
+      %w[remove remove! remove_by_id remove_by_id! remove_all remove_all!].each do |method|
+        add_method_tracer method, 'SolrClient/Sunspot/delete'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+if defined?(Unicorn::HttpServer)
+  Unicorn::HttpServer.class_eval do
+    NewRelic::Agent.logger.debug "Installing Unicorn worker hook."
+    old_worker_loop = instance_method(:worker_loop)
+    define_method(:worker_loop) do | worker |
+      NewRelic::Agent.after_fork(:force_reconnect => true)
+      old_worker_loop.bind(self).call(worker)
+    end
+  end
+end

data/lib/new_relic/agent/method_tracer.rb

@@ -0,0 +1,350 @@
+require 'new_relic/control'
+module NewRelic
+module Agent
+  # This module contains class methods added to support installing custom
+  # metric tracers and executing for individual metrics.
+  #
+  # == Examples
+  #
+  # When the agent initializes, it extends Module with these methods.
+  # However if you want to use the API in code that might get loaded
+  # before the agent is initialized you will need to require
+  # this file:
+  #
+  #     require 'new_relic/agent/method_tracer'
+  #     class A
+  #       include NewRelic::Agent::MethodTracer
+  #       def process
+  #         ...
+  #       end
+  #       add_method_tracer :process
+  #     end
+  #
+  # To instrument a class method:
+  #
+  #     require 'new_relic/agent/method_tracer'
+  #     class An
+  #       def self.process
+  #         ...
+  #       end
+  #       class << self
+  #         include NewRelic::Agent::MethodTracer
+  #         add_method_tracer :process
+  #       end
+  #     end
+
+  module MethodTracer
+
+    def self.included clazz #:nodoc:
+      clazz.extend ClassMethods
+      clazz.send :include, InstanceMethods
+    end
+
+    def self.extended clazz #:nodoc:
+      clazz.extend ClassMethods
+      clazz.extend InstanceMethods
+    end
+
+    module InstanceMethods
+      # Deprecated: original method preserved for API backward compatibility.
+      # Use either #trace_execution_scoped or #trace_execution_unscoped
+      def trace_method_execution(metric_names, push_scope, produce_metric, deduct_call_time_from_parent, &block) #:nodoc:
+        if push_scope
+          trace_execution_scoped(metric_names, :metric => produce_metric,
+                                                    :deduct_call_time_from_parent => deduct_call_time_from_parent, &block)
+        else
+          trace_execution_unscoped(metric_names, &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 code is inlined in #add_method_tracer.
+      # * <tt>metric_names</tt> is a single name or an array of names of metrics
+      # * <tt>:force => true</tt> will force the metric to be captured even when
+      #   tracing is disabled with NewRelic::Agent#disable_all_tracing
+      #
+      def trace_execution_unscoped(metric_names, options={})
+        return yield unless NewRelic::Agent.is_execution_traced?
+        t0 = Time.now
+        stats = Array(metric_names).map do | metric_name |
+          NewRelic::Agent.instance.stats_engine.get_stats_no_scope metric_name
+        end
+        begin
+          NewRelic::Agent.instance.push_trace_execution_flag(true) if options[:force]
+          yield
+        ensure
+          NewRelic::Agent.instance.pop_trace_execution_flag if options[:force]
+          duration = (Time.now - t0).to_f              # for some reason this is 3 usec faster than Time - Time
+          stats.each { |stat| stat.trace_call(duration) }
+        end
+      end
+
+      EMPTY_ARRAY = [].freeze
+
+      # Deprecated. Use #trace_execution_scoped, a version with an options hash.
+      def trace_method_execution_with_scope(metric_names, produce_metric, deduct_call_time_from_parent, scoped_metric_only=false, &block) #:nodoc:
+        trace_execution_scoped(metric_names,
+                             :metric => produce_metric,
+                             :deduct_call_time_from_parent => deduct_call_time_from_parent,
+                             :scoped_metric_only => scoped_metric_only, &block)
+      end
+
+      alias trace_method_execution_no_scope trace_execution_unscoped #:nodoc:
+
+      # Trace a given block with stats and keep track of the caller.
+      # See NewRelic::Agent::MethodTracer::ClassMethods#add_method_tracer for a description of the arguments.
+      # +metric_names+ is either a single name or an array of metric names.
+      # If more than one metric is passed, the +produce_metric+ option only applies to the first.  The
+      # others are always recorded.  Only the first metric is pushed onto the scope stack.
+      #
+      # Generally you pass an array of metric names if you want to record the metric under additional
+      # categories, but generally this *should never ever be done*.  Most of the time you can aggregate
+      # on the server.
+
+      def trace_execution_scoped(metric_names, options={})
+
+        return yield unless NewRelic::Agent.is_execution_traced? || options[:force]
+
+        produce_metric               = options[:metric] != false
+        deduct_call_time_from_parent = options[:deduct_call_time_from_parent] != false
+        scoped_metric_only           = produce_metric && options[:scoped_metric_only]
+        t0 = Time.now
+        if metric_names.instance_of? Array
+          first_name = metric_names.first
+          metric_stats = []
+          metric_stats << NewRelic::Agent.instance.stats_engine.get_stats(first_name, true, scoped_metric_only) if produce_metric
+          metric_names[1..-1].each do | name |
+            metric_stats << NewRelic::Agent.instance.stats_engine.get_stats_no_scope(name)
+          end
+        else
+          first_name = metric_names
+          if produce_metric
+            metric_stats = [NewRelic::Agent.instance.stats_engine.get_stats(first_name, true, scoped_metric_only)]
+          else
+            metric_stats = EMPTY_ARRAY
+          end
+        end
+
+        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'
+          NewRelic::Agent.instance.push_trace_execution_flag(true) if options[:force]
+          expected_scope = NewRelic::Agent.instance.stats_engine.push_scope(first_name, t0.to_f, deduct_call_time_from_parent)
+        rescue => e
+          NewRelic::Control.instance.log.error("Caught exception in trace_method_execution header. Metric name = #{first_name}, exception = #{e}")
+          NewRelic::Control.instance.log.error(e.backtrace.join("\n"))
+        end
+
+        begin
+          yield
+        ensure
+          t1 = Time.now
+          duration = (t1 - t0).to_f
+
+          begin
+            NewRelic::Agent.instance.pop_trace_execution_flag if options[:force]
+            if expected_scope
+              scope = NewRelic::Agent.instance.stats_engine.pop_scope expected_scope, duration, t1.to_f
+              exclusive = duration - scope.children_time
+              metric_stats.each { |stats| stats.trace_call(duration, exclusive) }
+            end
+          rescue => e
+            NewRelic::Control.instance.log.error("Caught exception in trace_method_execution footer. Metric name = #{first_name}, exception = #{e}")
+            NewRelic::Control.instance.log.error(e.backtrace.join("\n"))
+          end
+        end
+      end
+    end
+
+    module ClassMethods
+      # Add a method tracer to the specified method.
+      #
+      # === Common Options
+      #
+      # * <tt>:push_scope => false</tt> specifies this method tracer should not
+      #   keep track of the caller; it will not show up in controller breakdown
+      #   pie charts.
+      # * <tt>:metric => false</tt> specifies that no metric will be recorded.
+      #   Instead the call will show up in transaction traces as well as traces
+      #   shown in Developer Mode.
+      #
+      # === Uncommon Options
+      #
+      # * <tt>:scoped_metric_only => true</tt> indicates that the unscoped metric
+      #   should not be recorded.  Normally two metrics are potentially created
+      #   on every invocation: the aggregate method where statistics for all calls
+      #   of that metric are stored, and the "scoped metric" which records the
+      #   statistics for invocations in a particular scope--generally a controller
+      #   action.  This option indicates that only the second type should be recorded.
+      #   The effect is similar to <tt>:metric => false</tt> but in addition you
+      #   will also see the invocation in breakdown pie charts.
+      # * <tt>:deduct_call_time_from_parent => false</tt> indicates that the method invocation
+      #   time should never be deducted from the time reported as 'exclusive' in the
+      #   caller.  You would want to use this if you are tracing a recursive method
+      #   or a method that might be called inside another traced method.
+      # * <tt>:code_header</tt> and <tt>:code_footer</tt> specify ruby code that
+      #   is inserted into the tracer before and after the call.
+      # * <tt>:force = true</tt> will ensure the metric is captured even if called inside
+      #   an untraced execution call.  (See NewRelic::Agent#disable_all_tracing)
+      #
+      # === Overriding the metric name
+      #
+      # +metric_name_code+ is a string that is eval'd to get the
+      # name of the metric associated with the call, so if you want to
+      # use interpolaion evaluated at call time, then single quote
+      # the value like this:
+      #
+      #     add_method_tracer :foo, 'Custom/#{self.class.name}/foo'
+      #
+      # This would name the metric according to the class of the runtime
+      # intance, as opposed to the class where +foo+ is defined.
+      #
+      # If not provided, the metric name will be <tt>Custom/ClassName/method_name</tt>.
+      #
+      # === Examples
+      #
+      # Instrument +foo+ only for custom views--will not show up in transaction traces or caller breakdown graphs:
+      #
+      #     add_method_tracer :foo, :push_scope => false
+      #
+      # Instrument +foo+ just for transaction traces only:
+      #
+      #     add_method_tracer :foo, :metric => false
+      #
+      # Instrument +foo+ so it shows up in transaction traces and caller breakdown graphs
+      # for actions:
+      #
+      #     add_method_tracer :foo
+      #
+      # which is equivalent to:
+      #
+      #     add_method_tracer :foo, 'Custom/#{self.class.name}/foo', :push_scope => true, :metric => true
+      #
+      # Instrument the class method +foo+ with the metric name 'Custom/People/fetch':
+      #
+      #     class << self
+      #       add_method_tracer :foo, 'Custom/People/fetch'
+      #     end
+      #
+
+      def add_method_tracer(method_name, metric_name_code=nil, options = {})
+        # for backward compatibility:
+        if !options.is_a?(Hash)
+          options = {:push_scope => options}
+        end
+        # in case they omit the metric name code
+        if metric_name_code.is_a?(Hash)
+          options.merge(metric_name_code)
+        end
+        if (unrecognized = options.keys - [:force, :metric, :push_scope, :deduct_call_time_from_parent, :code_header, :code_footer, :scoped_metric_only]).any?
+          fail "Unrecognized options in add_method_tracer_call: #{unrecognized.join(', ')}"
+        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[:force] = false if options[:force].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"
+        # Default to the class where the method is defined.
+        metric_name_code = "Custom/#{self.name}/#{method_name.to_s}" unless metric_name_code
+
+        unless method_defined?(method_name) || private_method_defined?(method_name)
+          NewRelic::Control.instance.log.warn("Did not trace #{self.name}##{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]
+
+        header = ""
+        if !options[:force]
+          header << "return #{_untraced_method_name(method_name, metric_name_code)}(*args, &block) unless NewRelic::Agent.is_execution_traced?\n"
+        end
+        header << options[:code_header] if options[:code_header]
+        if options[:push_scope] == false
+          code = <<-CODE
+        def #{_traced_method_name(method_name, metric_name_code)}(*args, &block)
+          #{header}
+          t0 = Time.now
+          stats = NewRelic::Agent.instance.stats_engine.get_stats_no_scope "#{metric_name_code}"
+          begin
+            #{"NewRelic::Agent.instance.push_trace_execution_flag(true)\n" if options[:force]}
+            #{_untraced_method_name(method_name, metric_name_code)}(*args, &block)\n
+          ensure
+            #{"NewRelic::Agent.instance.pop_trace_execution_flag\n" if options[:force] }
+            duration = (Time.now - t0).to_f
+            stats.trace_call(duration)
+            #{options[:code_footer]}
+          end
+        end
+      CODE
+        else
+          code = <<-CODE
+      def #{_traced_method_name(method_name, metric_name_code)}(*args, &block)
+        #{options[:code_header]}
+        result = #{klass}.trace_execution_scoped("#{metric_name_code}",
+                  :metric => #{options[:metric]},
+                  :forced => #{options[:force]},
+                  :deduct_call_time_from_parent => #{options[:deduct_call_time_from_parent]},
+                  :scoped_metric_only => #{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.name}, method = #{method_name}, "+
+        "metric = '#{metric_name_code}'")
+      end
+
+      # For tests only 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) # :nodoc:
+        return unless NewRelic::Control.instance.agent_enabled?
+
+        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)
+    "#{_sanitize_name(method_name)}_without_trace_#{_sanitize_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_s('^a-zA-Z0-9', '_')
+      end
+    end
+  end
+end
+end