honkster-newrelic_rpm 2.13.1

data/LICENSE

@@ -0,0 +1,37 @@
+Copyright (c) 2008-2009 New Relic, Inc.  All rights reserved.
+
+Certain inventions disclosed in this file may be claimed within
+patents owned or patent applications filed by New Relic, Inc. or third
+parties.
+
+Subject to the terms of this notice, New Relic grants you a
+nonexclusive, nontransferable license, without the right to
+sublicense, to (a) install and execute one copy of these files on any
+number of workstations owned or controlled by you and (b) distribute
+verbatim copies of these files to third parties.  As a condition to the
+foregoing grant, you must provide this notice along with each copy you
+distribute and you must not remove, alter, or obscure this notice. All
+other use, reproduction, modification, distribution, or other
+exploitation of these files is strictly prohibited, except as may be set
+forth in a separate written license agreement between you and New
+Relic.  The terms of any such license agreement will control over this
+notice.  The license stated above will be automatically terminated and
+revoked if you exceed its scope or violate any of the terms of this
+notice.
+
+This License does not grant permission to use the trade names,
+trademarks, service marks, or product names of New Relic, except as
+required for reasonable and customary use in describing the origin of
+this file and reproducing the content of this notice.  You may not
+mark or brand this file with any trade name, trademarks, service
+marks, or product names other than the original brand (if any)
+provided by New Relic.
+
+Unless otherwise expressly agreed by New Relic in a separate written
+license agreement, these files are provided AS IS, WITHOUT WARRANTY OF
+ANY KIND, including without any implied warranties of MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE, or NON-INFRINGEMENT.  As a
+condition to your use of these files, you are solely responsible for
+such use. New Relic will have no liability to you for direct,
+indirect, consequential, incidental, special, or punitive damages or
+for lost profits or data.

data/README.rdoc

@@ -0,0 +1,172 @@
+= New Relic RPM
+
+New Relic RPM is a Ruby performance management system, developed by
+New Relic, Inc (http://www.newrelic.com).  RPM provides you with deep
+information about the performance of your Ruby on Rails or Merb
+application as it runs in production. The New Relic Agent is
+dual-purposed as a either a Rails plugin or a Gem, hosted on
+github[http://github.com/newrelic/rpm/tree/master] and Rubyforge.
+
+The New Relic Agent runs in one of two modes:
+
+==== Production Mode
+
+Low overhead instrumentation that captures detailed information on
+your application running in production and transmits them to
+rpm.newrelic.com where you can monitor them in real time.
+
+==== Developer Mode
+
+A Rack middleware that maps /newrelic to an application for showing
+detailed performance metrics on a page by page basis.  Installed
+automatically in Rails applications.
+
+== Supported Environments
+
+* Ruby 1.8.6, 1.8.7 or 1.9.1, including REE
+* JRuby 1.3 minimum
+* Rails 1.2.6 or later for Production Mode
+* Rails 2.2 or later for Developer Mode
+* Merb 1.0 or later
+* Sinatra
+* Rack
+
+Any Rack based framework should work but may not be tested.  Install
+RPM as a gem and add the Developer Mode middleware if desired.  Report
+any problems to support@newrelic.com.
+
+You can also monitor non-web applications. Refer to the "Other
+Environments" section under "Getting Started".
+
+= Getting Started
+
+Install the RPM agent as a gem.  If you are using Rails you can
+install the gem as a plug-in--details below.
+
+   gem install newrelic_rpm
+
+To monitor your applications in production, create an account at
+http://newrelic.com/get-RPM.html.  There you can
+sign up for a free Lite account or one of our paid subscriptions.
+
+Once you receive the welcome e-mail with a license key and
++newrelic.yml+ file, copy the +newrelic.yml+ file into your app config
+directory.
+
+All agent configuration is done in the +newrelic.yml+ file.  This file
+is by default read from the +config+ directory of the application root
+and is subsequently searched for in the application root directory,
+and then in a <tt>~/.newrelic</tt> directory
+
+=== Rails Installation
+
+You can install the agent as a plug-in or a Gem.  To install the agent
+as a Rails plug-in, do the following:
+
+    script/plugin install http://newrelic.rubyforge.org/svn/newrelic_rpm
+   
+If using the Agent as a gem, edit +environment.rb+ and add to the initalizer block:
+
+    config.gem "newrelic_rpm" 
+
+=== Merb Installation
+
+To monitor a merb app install the newrelic_rpm gem and add
+
+    dependency 'newrelic_rpm'
+
+to your init.rb file.
+
+=== Sinatra Installation 
+
+To use RPM with a Sinatra app, add
+    require 'newrelic_rpm'
+in your Sinatra app, below the Sinatra require directive.
+
+Then make sure you set RACK_ENV to the environment corresponding to the
+configuration definitions in the newrelic.yml file; i.e., development,
+staging, production, etc.
+
+To use Developer Mode in Sinatra, add NewRelic::Rack::DeveloperMode to 
+the middleware stack.  See the +config.ru+ sample below.
+
+=== Other Environments
+
+You can use RPM to monitor any Ruby application.  Add 
+    require 'newrelic_rpm'
+to your startup sequence and then manually start the agent using
+    NewRelic::Agent.manual_start
+
+To instrument Rack based applications, refer to the docs in
+NewRelic::Agent::Instrumentation::Rack.
+
+Refer to the docs in NewRelic for details on how to monitor other web
+frameworks, background jobs, and daemons.
+
+Also, see if your environment is already supported by the
+rpm_contrib[http://newrelic.github.com/rpm_contrib] gem.
+
+== Developer Mode
+
+When running the RPM Developer Mode, the RPM Agent will track the
+performance of every HTTP request serviced by your application, and
+store in memory this information for the last 100 HTTP transactions.
+
+To view this performance information, including detailed SQL statement
+analysis, open +/newrelic+ in your web application.  For instance if
+you are running mongrel or thin on port 3000, enter the following into
+your browser:
+
+    http://localhost:3000/newrelic
+
+Developer Mode is only initialized if the +developer_mode+ setting in
+the newrelic.yml file is set to true.  By default, it is turned off in
+all environments but +development+.
+
+==== Developer Mode in Rails
+
+Developer Mode is available automatically in Rails Applications
+based on Rails 2.3 and later.  No additional configuration is
+required.
+
+For earlier versions of Rails that support Rack, you can use
+a +config.ru+ as below.
+
+==== Developer Mode in Rack Applications
+
+Developer Mode is available for any Rack based application such as
+Sinatra by installing the NewRelic::Rack::DeveloperMode
+middleware. This middleware passes all requests that do not start with
+/newrelic.
+
+Here's an example entry for Developer Mode in a +config.ru+ file:
+
+    require 'new_relic/rack_app'
+    use NewRelic::Rack::DeveloperMode
+
+
+== Production Mode
+
+When your application runs in the production environment, the New
+Relic agent runs in production mode. It connects to the New Relic RPM
+service and sends deep performance data to the RPM service for your
+analysis. To view this data, log in to http://rpm.newrelic.com.
+
+NOTE: You must have a valid account and license key to view this data
+online.  Refer to instructions in *Getting Started*, below.
+
+
+= Support
+
+Reach out to us--and to fellow RPM users--at
+support.newrelic.com[http://support.newrelic.com/discussions/support].
+There you'll find documentation, FAQs, and forums where you can submit
+suggestions and discuss RPM with New Relic staff and other users.
+
+Find a bug?  E-mail support@newrelic.com, or post it to
+support.newrelic.com[http://support.newrelic.com/discussions/support].
+
+Thank you, and may your application scale to infinity plus one.  
+
+Lew Cirne, Founder and CEO<br/>
+New Relic, Inc.

data/bin/mongrel_rpm

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'rack'
+require 'rack/handler/mongrel'
+require 'optparse'
+
+port = 3000
+options = { }
+appname = nil
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{File.basename($0)} [options] [app_name]"
+  opts.on("-p", "--port=port", Integer, "default: #{port}") { | port | }
+  opts.on("--[no-]logging", "turn off request logging" ) { | l | options[:logging] = l }
+  opts.on("--license=rpm_license_key", "override license key" ) { | l | options[:license_key] = l }
+  opts.on("--install", "install a newrelic.yml template" ) { | l | options[:install] = true }
+  opts.separator ""
+  opts.separator "app_name is the name of the application where the metrics will be stored"
+  opts.separator ""
+  # The rackup file references this var
+  appname = opts.parse!(ARGV.clone).first
+end
+
+options[:app_name] = appname if appname
+
+ru_file = File.expand_path(File.join(File.dirname(__FILE__), "..", "lib", "new_relic", "rack", "mongrel_rpm.ru"))
+rackup_code = File.read ru_file
+builder = Rack::Builder.new { eval rackup_code, binding, ru_file }
+
+options = { :Host => '127.0.0.1', :Port => port }
+Rack::Handler::Mongrel.run(builder.to_app, options) do | server |
+  NewRelic::Control.instance.log! "Started Mongrel listening for '#{NewRelic::Control.instance.app_names.join(" and ")}' data at #{server.host}:#{server.port}" 
+end
+

data/bin/newrelic

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# executes one of the commands in the new_relic/commands directory
+# pass the name of the command as an argument
+
+$LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), '..','lib'))
+require 'new_relic/command'
+begin
+  NewRelic::Command.run
+rescue NewRelic::Command::CommandFailure => failure
+  STDERR.puts failure.message
+  STDERR.puts failure.options if failure.options
+  exit 1
+end

data/bin/newrelic_cmd

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+# This command has been renamed "newrelic"
+# executes one of the commands in the new_relic/commands directory
+# pass the name of the command as an argument
+load File.dirname(__FILE__) + '/newrelic'

data/cert/cacert.pem

@@ -0,0 +1,34 @@
+-----BEGIN CERTIFICATE-----
+MIIC5zCCAlACAQEwDQYJKoZIhvcNAQEFBQAwgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0IFZhbGlkYXRp
+b24gTmV0d29yazEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAzBgNVBAsTLFZhbGlDZXJ0IENs
+YXNzIDEgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9yaXR5MSEwHwYDVQQDExhodHRwOi8vd3d3LnZh
+bGljZXJ0LmNvbS8xIDAeBgkqhkiG9w0BCQEWEWluZm9AdmFsaWNlcnQuY29tMB4XDTk5MDYyNTIy
+MjM0OFoXDTE5MDYyNTIyMjM0OFowgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0IFZhbGlkYXRpb24gTmV0
+d29yazEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAzBgNVBAsTLFZhbGlDZXJ0IENsYXNzIDEg
+UG9saWN5IFZhbGlkYXRpb24gQXV0aG9yaXR5MSEwHwYDVQQDExhodHRwOi8vd3d3LnZhbGljZXJ0
+LmNvbS8xIDAeBgkqhkiG9w0BCQEWEWluZm9AdmFsaWNlcnQuY29tMIGfMA0GCSqGSIb3DQEBAQUA
+A4GNADCBiQKBgQDYWYJ6ibiWuqYvaG9YLqdUHAZu9OqNSLwxlBfw8068srg1knaw0KWlAdcAAxIi
+GQj4/xEjm84H9b9pGib+TunRf50sQB1ZaG6m+FiwnRqP0z/x3BkGgagO4DrdyFNFCQbmD3DD+kCm
+DuJWBQ8YTfwggtFzVXSNdnKgHZ0dwN0/cQIDAQABMA0GCSqGSIb3DQEBBQUAA4GBAFBoPUn0LBwG
+lN+VYH+Wexf+T3GtZMjdd9LvWVXoP+iOBSoh8gfStadS/pyxtuJbdxdA6nLWI8sogTLDAHkY7FkX
+icnGah5xyf23dKUlRWnFSKsZ4UWKJWsZ7uW7EvV/96aNUcPwnXS3qT6gpf+2SQMT2iLM7XGCK5nP
+Orf1LXLI
+-----END CERTIFICATE-----
+
+-----BEGIN CERTIFICATE-----
+MIIC5zCCAlACAQEwDQYJKoZIhvcNAQEFBQAwgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0IFZhbGlkYXRp
+b24gTmV0d29yazEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAzBgNVBAsTLFZhbGlDZXJ0IENs
+YXNzIDIgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9yaXR5MSEwHwYDVQQDExhodHRwOi8vd3d3LnZh
+bGljZXJ0LmNvbS8xIDAeBgkqhkiG9w0BCQEWEWluZm9AdmFsaWNlcnQuY29tMB4XDTk5MDYyNjAw
+MTk1NFoXDTE5MDYyNjAwMTk1NFowgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0IFZhbGlkYXRpb24gTmV0
+d29yazEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAzBgNVBAsTLFZhbGlDZXJ0IENsYXNzIDIg
+UG9saWN5IFZhbGlkYXRpb24gQXV0aG9yaXR5MSEwHwYDVQQDExhodHRwOi8vd3d3LnZhbGljZXJ0
+LmNvbS8xIDAeBgkqhkiG9w0BCQEWEWluZm9AdmFsaWNlcnQuY29tMIGfMA0GCSqGSIb3DQEBAQUA
+A4GNADCBiQKBgQDOOnHK5avIWZJV16vYdA757tn2VUdZZUcOBVXc65g2PFxTXdMwzzjsvUGJ7SVC
+CSRrCl6zfN1SLUzm1NZ9WlmpZdRJEy0kTRxQb7XBhVQ7/nHk01xC+YDgkRoKWzk2Z/M/VXwbP7Rf
+ZHM047QSv4dk+NoS/zcnwbNDu+97bi5p9wIDAQABMA0GCSqGSIb3DQEBBQUAA4GBADt/UG9vUJSZ
+SWI4OB9L+KXIPqeCgfYrx+jFzug6EILLGACOTb2oWH+heQC1u+mNr0HZDzTuIYEZoDJJKPTEjlbV
+UjP9UNV+mWwD5MlM/Mtsq2azSiGM5bUMMj4QssxsodyamEwCW/POuZ6lcg5Ktz885hZo+L7tdEy8
+W9ViH0Pd
+-----END CERTIFICATE-----
+

data/install.rb

@@ -0,0 +1,9 @@
+if __FILE__ == $0 || $0 =~ /script\/plugin/
+  $LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), 'lib'))
+  require 'new_relic/command'  
+  begin
+    NewRelic::Command::Install.new(:quiet => true, :app_name => 'My Application').run
+  rescue NewRelic::Command::CommandFailure => e
+    $stderr.puts e.message
+  end
+end

data/lib/new_relic/agent.rb

@@ -0,0 +1,382 @@
+# = New Relic RPM Agent
+#
+# New Relic RPM is a performance monitoring application for Ruby
+# applications running in production.  For more information on RPM
+# please visit http://www.newrelic.com.
+#
+# The New Relic Agent can be installed in Rails applications to gather
+# runtime performance metrics, traces, and errors for display in a
+# Developer Mode UI (mapped to /newrelic in your application server)
+# or for monitoring and analysis at http://rpm.newrelic.com with just
+# about any Ruby application.
+#
+# == Getting Started
+# For instructions on installation and setup, see
+# the README[link:./files/README_rdoc.html] file.
+#
+# == Using with Rack/Metal
+#
+# To instrument Rack middlwares or Metal apps, refer to the docs in
+# NewRelic::Agent::Instrumentation::Rack.
+#
+# == Agent API
+#
+# For details on the Agent API, refer to NewRelic::Agent.
+#
+# == Customizing RPM
+#
+# For detailed information on customizing the RPM Agent
+# please visit our {support and documentation site}[http://support.newrelic.com].
+#
+module NewRelic
+  # == Agent APIs
+  # This module contains the public API methods for the Agent.
+  #
+  # For adding custom instrumentation to method invocations, refer to
+  # the docs in the class NewRelic::Agent::MethodTracer.
+  #
+  # For information on how to customize the controller
+  # instrumentation, or to instrument something other than Rails so
+  # that high level dispatcher actions or background tasks show up as
+  # first class operations in RPM, refer to
+  # NewRelic::Agent::Instrumentation::ControllerInstrumentation and
+  # NewRelic::Agent::Instrumentation::ControllerInstrumentation::ClassMethods.
+  #
+  # Methods in this module as well as documented methods in
+  # NewRelic::Agent::MethodTracer and
+  # NewRelic::Agent::Instrumentation::ControllerInstrumentation are
+  # available to applications.  When the agent is not enabled the
+  # method implementations are stubbed into no-ops to reduce overhead.
+  #
+  # Methods and classes in other parts of the agent are not guaranteed
+  # to be available between releases.
+  #
+  # Refer to the online docs at support.newrelic.com to see how to
+  # access the data collected by custom instrumentation, or e-mail
+  # support at New Relic for help.
+  module Agent
+    extend self
+
+    require 'new_relic/version'
+    require 'new_relic/local_environment'
+    require 'new_relic/stats'
+    require 'new_relic/metrics'
+    require 'new_relic/metric_spec'
+    require 'new_relic/metric_data'
+    require 'new_relic/metric_parser'
+    require 'new_relic/collection_helper'
+    require 'new_relic/transaction_analysis'
+    require 'new_relic/transaction_sample'
+    require 'new_relic/url_rule'
+    require 'new_relic/noticed_error'
+    require 'new_relic/histogram'
+    require 'new_relic/timer_lib'
+
+    require 'new_relic/agent/chained_call'
+    require 'new_relic/agent/agent'
+    require 'new_relic/agent/shim_agent'
+    require 'new_relic/agent/method_tracer'
+    require 'new_relic/agent/worker_loop'
+    require 'new_relic/agent/stats_engine'
+    require 'new_relic/agent/transaction_sampler'
+    require 'new_relic/agent/error_collector'
+    require 'new_relic/agent/busy_calculator'
+    require 'new_relic/agent/sampler'
+
+    require 'new_relic/agent/instrumentation/controller_instrumentation'
+
+    require 'new_relic/agent/samplers/cpu_sampler'
+    require 'new_relic/agent/samplers/memory_sampler'
+    require 'new_relic/agent/samplers/object_sampler'
+    require 'new_relic/agent/samplers/delayed_job_lock_sampler'
+    require 'set'
+    require 'thread'
+    require 'resolv'
+
+    # An exception that is thrown by the server if the agent license is invalid.
+    class LicenseException < StandardError; end
+
+    # An exception that forces an agent to stop reporting until its mongrel is restarted.
+    class ForceDisconnectException < StandardError; end
+
+    # An exception that forces an agent to restart.
+    class ForceRestartException < StandardError; end
+
+    # Used to blow out of a periodic task without logging a an error, such as for routine
+    # failures.
+    class ServerConnectionException < StandardError; end
+
+    # Used for when a transaction trace or error report has too much
+    # data, so we reset the queue to clear the extra-large item
+    class PostTooBigException < ServerConnectionException; end
+
+    # Reserved for future use.  Meant to represent a problem on the server side.
+    class ServerError < StandardError; end
+
+    class BackgroundLoadingError < StandardError; end
+
+    @agent = nil
+
+    # The singleton Agent instance.  Used internally.
+    def agent #:nodoc:
+      raise "Plugin not initialized!" if @agent.nil?
+      @agent
+    end
+
+    def agent= new_instance #:nodoc:
+      @agent = new_instance
+    end
+
+    alias instance agent #:nodoc:
+
+    # Get or create a statistics gatherer that will aggregate numerical data
+    # under a metric name.
+    #
+    # +metric_name+ should follow a slash separated path convention.  Application
+    # specific metrics should begin with "Custom/".
+    #
+    # Return a NewRelic::Stats that accepts data
+    # via calls to add_data_point(value).
+    def get_stats(metric_name, use_scope=false)
+      @agent.stats_engine.get_stats(metric_name, use_scope)
+    end
+
+    alias get_stats_no_scope get_stats
+
+    # Get the logger for the agent.  Available after the agent has initialized.
+    # This sends output to the agent log file.
+    def logger
+      NewRelic::Control.instance.log
+    end
+
+    # Call this to manually start the Agent in situations where the Agent does
+    # not auto-start.
+    #
+    # When the app environment loads, so does the Agent. However, the
+    # Agent will only connect to RPM if a web front-end is found. If
+    # you want to selectively monitor ruby processes that don't use
+    # web plugins, then call this method in your code and the Agent
+    # will fire up and start reporting to RPM.
+    #
+    # Options are passed in as overrides for values in the
+    # newrelic.yml, such as app_name.  In addition, the option +log+
+    # will take a logger that will be used instead of the standard
+    # file logger.  The setting for the newrelic.yml section to use
+    # (ie, RAILS_ENV) can be overridden with an :env argument.
+    #
+    def manual_start(options={})
+      raise unless Hash === options
+      NewRelic::Control.instance.init_plugin({ :agent_enabled => true, :sync_startup => true }.merge(options))
+    end
+
+    # Register this method as a callback for processes that fork
+    # jobs.
+    #
+    # If the master/parent connects to the agent prior to forking the
+    # agent in the forked process will use that agent_run.  Otherwise
+    # the forked process will establish a new connection with the
+    # server.
+    #
+    # Use this especially when you fork the process to run background
+    # jobs or other work.  If you are doing this with a web dispatcher
+    # that forks worker processes then you will need to force the
+    # agent to reconnect, which it won't do by default.  Passenger and
+    # Unicorn are already handled, nothing special needed for them.
+    #
+    # Options:
+    # * <tt>:force_reconnect => true</tt> to force the spawned process to
+    #   establish a new connection, such as when forking a long running process.
+    #   The default is false--it will only connect to the server if the parent
+    #   had not connected.
+    # * <tt>:keep_retrying => false</tt> if we try to initiate a new
+    #   connection, this tells me to only try it once so this method returns
+    #   quickly if there is some kind of latency with the server.
+    def after_fork(options={})
+      agent.after_fork(options)
+    end
+
+    # Clear out any unsent metric data.
+    def reset_stats
+      agent.reset_stats
+    end
+
+    # Shutdown the agent.  Call this before exiting.  Sends any queued data
+    # and kills the background thread.
+    def shutdown
+      agent.shutdown
+    end
+
+    # Add instrumentation files to the agent.  The argument should be
+    # a glob matching ruby scripts which will be executed at the time
+    # instrumentation is loaded.  Since instrumentation is not loaded
+    # when the agent is not running it's better to use this method to
+    # register instrumentation than just loading the files directly,
+    # although that probably also works.
+    def add_instrumentation file_pattern
+      NewRelic::Control.instance.add_instrumentation file_pattern
+    end
+
+    # This method sets the block sent to this method as a sql
+    # obfuscator.  The block will be called with a single String SQL
+    # statement to obfuscate.  The method must return the obfuscated
+    # String SQL.  If chaining of obfuscators is required, use type =
+    # :before or :after
+    #
+    # type = :before, :replace, :after
+    #
+    # Example:
+    #
+    #    NewRelic::Agent.set_sql_obfuscator(:replace) do |sql|
+    #       my_obfuscator(sql)
+    #    end
+    #
+    def set_sql_obfuscator(type = :replace, &block)
+      agent.set_sql_obfuscator type, &block
+    end
+
+
+    # This method sets the state of sql recording in the transaction
+    # sampler feature. Within the given block, no sql will be recorded
+    #
+    # usage:
+    #
+    #   NewRelic::Agent.disable_sql_recording do
+    #     ...
+    #   end
+    #
+    def disable_sql_recording
+      state = agent.set_record_sql(false)
+      begin
+        yield
+      ensure
+        agent.set_record_sql(state)
+      end
+    end
+
+    # This method disables the recording of transaction traces in the given
+    # block.  See also #disable_all_tracing
+    def disable_transaction_tracing
+      state = agent.set_record_tt(false)
+      begin
+        yield
+      ensure
+        agent.set_record_tt(state)
+      end
+    end
+
+    # Cancel the collection of the current transaction in progress, if
+    # any.  Only affects the transaction started on this thread once
+    # it has started and before it has completed.
+    def abort_transaction!
+      # The class may not be loaded if the agent is disabled
+      if defined? NewRelic::Agent::Instrumentation::MetricFrame
+        NewRelic::Agent::Instrumentation::MetricFrame.abort_transaction!
+      end
+    end
+
+    # Yield to the block without collecting any metrics or traces in
+    # any of the subsequent calls.  If executed recursively, will keep
+    # track of the first entry point and turn on tracing again after
+    # leaving that block.  This uses the thread local
+    # +newrelic_untrace+
+    def disable_all_tracing
+      agent.push_trace_execution_flag(false)
+      yield
+    ensure
+      agent.pop_trace_execution_flag
+    end
+
+    # Check to see if we are capturing metrics currently on this thread.
+    def is_execution_traced?
+      Thread.current[:newrelic_untraced].nil? || Thread.current[:newrelic_untraced].last != false
+    end
+
+    # Set a filter to be applied to errors that RPM will track.  The
+    # block should evalute to the exception to track (which could be
+    # different from the original exception) or nil to ignore this
+    # exception.
+    #
+    # The block is yielded to with the exception to filter.
+    #
+    # Return the new block or the existing filter Proc if no block is passed.
+    #
+    def ignore_error_filter(&block)
+      agent.error_collector.ignore_error_filter(&block)
+    end
+
+    # Record the given error in RPM.  It will be passed through the
+    # #ignore_error_filter if there is one.
+    #
+    # * <tt>exception</tt> is the exception which will be recorded.  May also be
+    #   an error message.
+    # Options:
+    # * <tt>:uri</tt> => The request path, minus any request params or query string.
+    # * <tt>:referer</tt> => The URI of the referer
+    # * <tt>:metric</tt> => The metric name associated with the transaction
+    # * <tt>:request_params</tt> => Request parameters, already filtered if necessary
+    # * <tt>:custom_params</tt> => Custom parameters
+    #
+    # Anything left over is treated as custom params.
+    #
+    def notice_error(exception, options={})
+      NewRelic::Agent::Instrumentation::MetricFrame.notice_error(exception, options)
+    end
+
+    # Add parameters to the current transaction trace (and traced error if any)
+    # on the call stack.
+    #
+    def add_custom_parameters(params)
+      NewRelic::Agent::Instrumentation::MetricFrame.add_custom_parameters(params)
+    end
+
+    # The #add_request_parameters method is aliased to #add_custom_parameters
+    # and is now deprecated.
+    alias add_request_parameters add_custom_parameters #:nodoc:
+
+    # Yield to a block that is run with a database metric name
+    # context.  This means the Database instrumentation will use this
+    # for the metric name if it does not otherwise know about a model.
+    # This is re-entrant.
+    #
+    # * <tt>model</tt> is the DB model class
+    # * <tt>method</tt> is the name of the finder method or other
+    #   method to identify the operation with.
+    def with_database_metric_name(model, method, &block)
+      if frame = NewRelic::Agent::Instrumentation::MetricFrame.current
+        frame.with_database_metric_name(model, method, &block)
+      else
+        yield
+      end
+    end
+
+    # Record a web transaction from an external source.  This will
+    # process the response time, error, and score an apdex value.
+    #
+    # First argument is a float value, time in seconds.  Option
+    # keys are strings.
+    #
+    # == Identifying the transaction
+    # * <tt>'uri' => uri</tt> to record the value for a given web request.
+    #   If not provided, just record the aggregate dispatcher and apdex scores.
+    # * <tt>'metric' => metric_name</tt> to record with a general metric name
+    #   like +OtherTransaction/Background/Class/method+.  Ignored if +uri+ is
+    #   provided.
+    #
+    # == Error options
+    # Provide one of the following:
+    # * <tt>'is_error' => true</tt> if an unknown error occurred
+    # * <tt>'error_message' => msg</tt> if an error message is available
+    # * <tt>'exception' => exception</tt> if a ruby exception is recorded
+    #
+    # == Misc options
+    # Additional information captured in errors
+    # * <tt>'referer' => referer_url</tt>
+    # * <tt>'request_params' => hash</tt> to record a set of name/value pairs as the
+    #   request parameters.
+    # * <tt>'custom_params' => hash</tt> to record extra information in traced errors
+    #
+    def record_transaction(response_sec, options = {})
+      agent.record_transaction(response_sec, options)
+    end
+  end
+end