newrelic_rpm 3.6.0.83 → 3.6.1.85.beta

data/test/multiverse/suites/agent_only/marshaling_test.rb

@@ -4,6 +4,7 @@
 
 # https://newrelic.atlassian.net/wiki/display/eng/The+Terror+and+Glory+of+Transaction+Traces
 # https://newrelic.atlassian.net/browse/RUBY-914
+require 'ostruct'
 
 class MarshalingTest < Test::Unit::TestCase
   def setup
@@ -26,13 +27,14 @@ class MarshalingTest < Test::Unit::TestCase
     # create fake transaction trace
     time = Time.now.to_f
     @sampler.notice_first_scope_push time
-    @sampler.notice_transaction '/path', nil, {}
+    @sampler.notice_transaction nil, {}
     @sampler.notice_push_scope "a"
     @sampler.notice_push_scope "ab"
     sleep 1
     @sampler.notice_pop_scope "ab"
     @sampler.notice_pop_scope "a"
-    @sampler.notice_scope_empty
+    @sampler.notice_scope_empty(OpenStruct.new(:name => 'path',
+                                               :custom_parameters => {}))
 
     expected_sample = @sampler.instance_variable_get(:@slowest_sample)
 
@@ -81,7 +83,7 @@ class MarshalingTest < Test::Unit::TestCase
     @agent.sql_sampler.notice_sql("select * from test",
                                   "Database/test/select",
                                   nil, 1.5)
-    @agent.sql_sampler.notice_scope_empty
+    @agent.sql_sampler.notice_scope_empty('txn')
 
     @agent.service.connect
     @agent.send(:harvest_and_send_slowest_sql)

data/test/multiverse/suites/agent_only/rename_rule_test.rb

@@ -37,6 +37,8 @@ class RenameRuleTest < Test::Unit::TestCase
   end
 
   def teardown
+    NewRelic::Agent.instance.instance_variable_set(:@transaction_rules,
+                                       NewRelic::Agent::RulesEngine.new)
     NewRelic::Agent.shutdown
   end
 

data/test/multiverse/suites/agent_only/set_transaction_name_test.rb

@@ -0,0 +1,96 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+class SetTransactionNameTest < Test::Unit::TestCase
+  include NewRelic::Agent::MethodTracer
+
+  class TestTransactor
+    include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
+    def parent_txn
+      NewRelic::Agent.set_transaction_name('TestTransactor/parent')
+      yield if block_given?
+      child_txn
+    end
+    add_transaction_tracer :parent_txn
+
+    def child_txn
+      NewRelic::Agent.set_transaction_name('TestTransactor/child', :category => :task)
+    end
+    add_transaction_tracer :child_txn
+
+    newrelic_ignore :only => :ignored_txn
+    def ignored_txn
+      NewRelic::Agent.set_transaction_name('Ignore/me')
+    end
+  end
+
+  def setup
+    NewRelic::Agent.manual_start(:browser_key => 'browserKey', :application_id => 'appId',
+                                 :beacon => 'beacon', :episodes_file => 'this_is_my_file')
+    @transactor = TestTransactor.new
+    @stats_engine = NewRelic::Agent.instance.stats_engine
+  end
+
+  def teardown
+    NewRelic::Agent.shutdown
+  end
+
+  def test_apply_to_metric_names
+    @transactor.parent_txn
+    [ 'Controller/TestTransactor/parent',
+      'OtherTransaction/Background/TestTransactor/child',
+      [ 'OtherTransaction/Background/TestTransactor/child',
+        'Controller/TestTransactor/parent'],
+      'Apdex/TestTransactor/parent' ].each do |metric|
+      assert(@stats_engine.lookup_stats(*metric),
+             "Expected to find #{metric} in stats hash #{NewRelic::Agent.instance.stats_engine.instance_variable_get(:@stats_hash)}")
+    end
+  end
+
+  def test_apply_to_metric_scopes
+    @transactor.parent_txn do
+      trace_execution_scoped('Custom/something') {}
+    end
+    assert @stats_engine.lookup_stats('Custom/something',
+                                      'Controller/TestTransactor/parent')
+  end
+
+  def test_apply_to_traced_transactions
+    @transactor.parent_txn
+    assert_equal('Controller/TestTransactor/parent',
+                 NewRelic::Agent.instance.transaction_sampler.last_sample \
+                   .params[:path])
+  end
+
+  def test_apply_to_traced_errors
+    @transactor.parent_txn do
+      NewRelic::Agent.notice_error(RuntimeError.new('toot'))
+    end
+    assert_equal('Controller/TestTransactor/parent',
+                 NewRelic::Agent.instance.error_collector.errors.last.path)
+  end
+
+  def test_set_name_is_subject_to_txn_name_rules
+    rule = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => 'parent',
+                                                  'replacement'      => 'dad')
+    NewRelic::Agent.instance.transaction_rules << rule
+    @transactor.parent_txn
+    assert @stats_engine.lookup_stats('Controller/TestTransactor/dad')
+  end
+
+  def test_does_not_overwrite_name_when_set_by_RUM
+    @transactor.parent_txn do
+      NewRelic::Agent.browser_timing_header
+      NewRelic::Agent.browser_timing_footer
+      NewRelic::Agent.set_transaction_name('this/should/not/work')
+    end
+    assert_nil @stats_engine.lookup_stats('Controller/this/should/not/work')
+    assert @stats_engine.lookup_stats('Controller/TestTransactor/parent')
+  end
+
+  def test_ignoring_action
+    @transactor.ignored_txn
+    assert_nil @stats_engine.lookup_stats('Controller/Ignore/me')
+  end
+end

data/test/multiverse/suites/agent_only/testing_app.rb

@@ -18,4 +18,5 @@ class TestingApp
     [200, headers, [response]]
   end
 
+  include NewRelic::Agent::Instrumentation::Rack
 end

data/test/multiverse/suites/rails/error_tracing_test.rb

@@ -80,15 +80,11 @@ class ErrorsWithoutSSCTest < ActionDispatch::IntegrationTest
            'no ignore error filter should be set')
   end
 
-  if Rails::VERSION::MAJOR != 4
-    def test_error_collector_should_be_enabled
-      assert NewRelic::Agent.config[:agent_enabled]
-      assert NewRelic::Agent.config[:'error_collector.enabled']
-      assert @error_collector.enabled?
-      assert Rails.application.config.middleware.include?(NewRelic::Rack::ErrorCollector)
-    end
-  else
-    puts yellow("SKIPPED test_error_collector_should_be_enabled : not working in Rails 4")
+  def test_error_collector_should_be_enabled
+    assert NewRelic::Agent.config[:agent_enabled]
+    assert NewRelic::Agent.config[:'error_collector.enabled']
+    assert @error_collector.enabled?
+    assert Rails.application.config.middleware.include?(NewRelic::Rack::ErrorCollector)
   end
 
   def test_should_capture_error_raised_in_view
@@ -116,7 +112,7 @@ class ErrorsWithoutSSCTest < ActionDispatch::IntegrationTest
   end
 
   # Important choice of controllor_error, since this goes through both the
-  # metric_frame and the rack error collector, so risks multiple counting!
+  # transaction and the rack error collector, so risks multiple counting!
   def test_should_capture_multiple_errors
     40.times do
       get '/error/controller_error'
@@ -130,25 +126,17 @@ class ErrorsWithoutSSCTest < ActionDispatch::IntegrationTest
     assert_error_reported_once('this is a noticed error')
   end
 
-  if Rails::VERSION::MAJOR.to_i != 4
-    def test_should_capture_routing_error
-      get '/bad_route'
-      assert_error_reported_once('this is an uncaught routing error')
-    end
-  else
-    puts yellow("SKIPPED test_should_capture_routing_error : not working in Rails 4")
+  def test_should_capture_routing_error
+    get '/bad_route'
+    assert_error_reported_once('this is an uncaught routing error')
   end
 
-  if Rails::VERSION::MAJOR.to_i != 4
-    def test_should_capture_request_uri_and_params
-      get '/bad_route?eat=static'
-      assert_equal('/bad_route',
-                   @error_collector.errors[0].params[:request_uri])
-      assert_equal({'eat' => 'static'},
-                   @error_collector.errors[0].params[:request_params])
-    end
-  else
-    puts yellow("SKIPPED test_should_capture_request_uri_and_params : not working in Rails 4")
+  def test_should_capture_request_uri_and_params
+    get '/bad_route?eat=static'
+    assert_equal('/bad_route',
+                 @error_collector.errors[0].params[:request_uri])
+    assert_equal({'eat' => 'static'},
+                 @error_collector.errors[0].params[:request_params])
   end
 
   def test_should_not_notice_errors_from_ignored_action
@@ -181,13 +169,13 @@ class ErrorsWithoutSSCTest < ActionDispatch::IntegrationTest
  protected
 
   def assert_errors_reported(message, queued_count, total_count=queued_count, txn_name=nil)
-    error_count = NewRelic::Agent::Agent.instance.stats_engine.get_stats("Errors/all")
+    error_count = NewRelic::Agent::Agent.instance.stats_engine.lookup_stats("Errors/all")
     assert_equal(total_count, error_count.call_count,
                  'Incorrect call count on Errors/all')
 
     if txn_name
       error_count = NewRelic::Agent::Agent.instance.stats_engine \
-        .get_stats("Errors/#{txn_name}")
+        .lookup_stats("Errors/#{txn_name}")
       assert_equal(total_count, error_count.call_count,
                    "Incorrect call count on Errors/#{txn_name}")
     end

data/test/multiverse/suites/rails/queue_time_test.rb

@@ -27,6 +27,12 @@ class QueueTimeTest < ActionDispatch::IntegrationTest
     NewRelic::Agent::Agent.instance_variable_set(:@instance, @agent)
     NewRelic::Agent.manual_start
 
+    # ActiveSupport testing keeps blowing away my subscribers on
+    # teardown for some reason.  Have to keep putting it back.
+    NewRelic::Agent.instance.events.subscribe(:before_call) do |env|
+      NewRelic::Agent::TransactionInfo.reset(::Rack::Request.new(env))
+    end
+
     @agent.finish_setup({})
   end
 
@@ -48,8 +54,8 @@ class QueueTimeTest < ActionDispatch::IntegrationTest
   end
 
   def get_queued(header="HTTP_X_REQUEST_START")
-    get('/queue/queued', nil,
-        header => "t=#{(Time.now.to_i * 1_000_000) - 1_000}")
+    value = "t=#{(Time.now.to_i * 1_000_000) - 1_000}"
+    get('/queue/queued', nil, header => value)
   end
 
   def extract_queue_time_from_response

data/test/multiverse/suites/rails/view_instrumentation_test.rb

@@ -79,11 +79,15 @@ class ViewControllerTest < ActionController::TestCase
   tests ViewsController
   def setup
     super
+    NewRelic::Agent.manual_start
     @controller = ViewsController.new
-    # ActiveSupport testing keeps blowing away my subscriber on
+    # ActiveSupport testing keeps blowing away my subscribers on
     # teardown for some reason.  Have to keep putting it back.
     if Rails::VERSION::MAJOR.to_i == 4
-      NewRelic::Agent::Instrumentation::ActionViewSubscriber.subscribe
+      NewRelic::Agent::Instrumentation::ActionViewSubscriber \
+        .subscribe(/render_.+\.action_view$/)
+      NewRelic::Agent::Instrumentation::ActionControllerSubscriber \
+        .subscribe(/^process_action.action_controller$/)
     end
   end
 end
@@ -212,4 +216,3 @@ class FileRenderTest < ViewControllerTest
     assert_equal 'View/file/Rendering', text_segment.metric_name
   end
 end
-

data/test/multiverse/suites/resque/instrumentation_test.rb

@@ -92,7 +92,7 @@ class ResqueTest < Test::Unit::TestCase
   end
 
   def wait_for_jobs
-    time_for_jobs = 5
+    time_for_jobs = 10
     begin
       Timeout.timeout(time_for_jobs) do
         loop do

data/test/multiverse/suites/sinatra/sinatra_error_tracing_test.rb

@@ -28,6 +28,7 @@ class SinatraErrorTracingTest < Test::Unit::TestCase
     ::NewRelic::Agent.manual_start
     @error_collector = ::NewRelic::Agent.instance.error_collector
 
+    @error_collector.errors.clear
     assert(@error_collector.enabled?,
            'error collector should be enabled')
   end
@@ -39,4 +40,11 @@ class SinatraErrorTracingTest < Test::Unit::TestCase
 
     assert_equal(1, @error_collector.errors.size)
   end
+
+  def test_ignores_notfound_errors_by_default
+    get '/ignored_boom'
+    assert_equal 404, last_response.status
+    assert_match %r{Sinatra doesn&rsquo;t know this ditty\.}, last_response.body
+    assert_equal(0, @error_collector.errors.size)
+  end
 end

data/test/new_relic/agent/agent/connect_test.rb

@@ -8,6 +8,7 @@ require 'ostruct'
 
 class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
   include NewRelic::Agent::Agent::Connect
+  include TransactionSampleTestHelper
 
   def setup
     @connected = nil
@@ -108,7 +109,7 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
   def test_configure_transaction_tracer_with_random_sampling
     with_config(:'transaction_tracer.transaction_threshold' => 5,
                 :'transaction_tracer.random_sample' => true) do
-      sample = TransactionSampleTestHelper.make_sql_transaction
+      sample = make_sql_transaction
       @transaction_sampler.store_sample(sample)
 
       assert_equal sample, @transaction_sampler.instance_variable_get(:@random_sample)

data/test/new_relic/agent/agent/start_test.rb

@@ -7,16 +7,6 @@ class NewRelic::Agent::Agent::StartTest < Test::Unit::TestCase
   require 'new_relic/agent/agent'
   include NewRelic::Agent::Agent::Start
 
-  def setup
-    ENV['NEW_RELIC_APP_NAME'] = 'start_test'
-    NewRelic::Agent.reset_config
-  end
-
-  def teardown
-    ENV['NEW_RELIC_APP_NAME'] = nil
-    NewRelic::Agent.reset_config
-  end
-
   def test_already_started_positive
     dummy_logger = mock
     dummy_logger.expects(:error).with("Agent Started Already!")

data/test/new_relic/agent/agent_logger_test.rb

@@ -154,4 +154,19 @@ class AgentLoggerTest < Test::Unit::TestCase
 
     assert_equal stdout, logger.instance_variable_get(:@log)
   end
+
+  def test_null_logger_works_with_impolite_gems_that_add_stuff_to_kernel
+    Kernel.module_eval do
+      def debug; end
+    end
+
+    logger = NewRelic::Agent::AgentLogger.new(@config.merge(:agent_enabled => false))
+    assert_nothing_raised do
+      logger.debug('hi!')
+    end
+  ensure
+    Kernel.module_eval do
+      remove_method :debug
+    end
+  end
 end

data/test/new_relic/agent/agent_test_controller.rb

@@ -60,8 +60,12 @@ class NewRelic::Agent::AgentTestController < NewRelic::Agent::SuperclassControll
   end
 
   def self.set_some_headers(hash_of_headers)
-    @@headers_to_add ||= {}
-    @@headers_to_add.merge!(hash_of_headers)
+    if ::Rails::VERSION::MAJOR.to_i == 4
+      NewRelic::Agent.instance.events.notify(:before_call, hash_of_headers)
+    else
+      @@headers_to_add ||= {}
+      @@headers_to_add.merge!(hash_of_headers)
+    end
   end
 
   def self.clear_headers

data/test/new_relic/agent/agent_test_controller_test.rb

@@ -44,6 +44,12 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
       newrelic_ignore_apdex :only => :action_to_ignore_apdex
     end
     @engine = @agent.stats_engine
+
+    # ActiveSupport testing keeps blowing away my subscribers on
+    # teardown for some reason.  Have to keep putting it back.
+    NewRelic::Agent.instance.events.subscribe(:before_call) do |env|
+      NewRelic::Agent::TransactionInfo.reset(::Rack::Request.new(env))
+    end
   end
 
   # Normally you can do this with #setup but for some reason in rails 2.0.2
@@ -77,17 +83,7 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
     assert_equal 1, engine.get_stats_no_scope('Mongrel/Queue Length').call_count
     assert_equal 9, engine.get_stats_no_scope('Mongrel/Queue Length').total_call_time
     assert_equal 0, engine.get_stats_no_scope('WebFrontend/Mongrel/Average Queue Time').call_count
-  end
-
-  def test_heroku_queue
-    engine.clear_stats
-    NewRelic::Agent::AgentTestController.set_some_headers 'HTTP_X_HEROKU_QUEUE_DEPTH'=>'15'
-    get :index
-    assert_equal 1, stats('HttpDispatcher').call_count
-    assert_equal 1, engine.get_stats_no_scope('Mongrel/Queue Length').call_count
-    assert_equal 15, engine.get_stats_no_scope('Mongrel/Queue Length').total_call_time
-    assert_equal 0, engine.get_stats_no_scope('WebFrontend/Mongrel/Average Queue Time').call_count
-  end
+  end if ::Rails::VERSION::MAJOR.to_i <= 3
 
   def test_new_queue_integration
     # make this test deterministic
@@ -120,7 +116,8 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
     engine.clear_stats
     get :action_inline
     assert_equal 'foofah', @response.body
-    compare_metrics %w[Controller/new_relic/agent/agent_test/action_inline], engine.metrics.grep(/^Controller/)
+    compare_metrics(%w[Controller/new_relic/agent/agent_test/action_inline],
+                    engine.metrics.grep(/^Controller/))
   end
 
   def test_metric__ignore
@@ -130,6 +127,9 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
     compare_metrics [], engine.metrics
   end
 
+  # Rails 4 does all error tracking in Rack, not testable here
+  # see the rails Multiverse suit for Rails 4 error tests
+  if ::Rails::VERSION::MAJOR.to_i <= 3
   def test_controller_rescued_error
     engine.clear_stats
     assert_raise RuntimeError do
@@ -195,6 +195,7 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
     assert_equal 0, apdex.apdex_t, 'tol'
     assert_equal 0, apdex.apdex_s, 'satisfied'
   end
+  end
 
   def test_metric__ignore_base
     engine.clear_stats
@@ -228,15 +229,18 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
     assert_nil Thread.current[:newrelic_ignore_controller]
   end
 
-  def test_metric__dispatched
+  def test_records_metric_dispite_ignore_state_when_forced
     engine = @agent.stats_engine
     get :entry_action
     assert_nil Thread.current[:newrelic_ignore_controller]
+    # explicitly ignored
     assert_nil engine.lookup_stats('Controller/agent_test/entry_action')
     assert_nil engine.lookup_stats('Controller/agent_test_controller/entry_action')
     assert_nil engine.lookup_stats('Controller/AgentTestController/entry_action')
+    # implicitly ignored because parent action ignored
     assert_nil engine.lookup_stats('Controller/NewRelic::Agent::AgentTestController/internal_action')
     assert_nil engine.lookup_stats('Controller/NewRelic::Agent::AgentTestController_controller/internal_action')
+    # forced to be recorded, overrides parent ignore state
     assert_not_nil engine.lookup_stats('Controller/NewRelic::Agent::AgentTestController/internal_traced_action')
   end
 
@@ -245,24 +249,15 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
     assert_match /bar/, @response.body
   end
 
-  def test_controller_params
-    assert agent.transaction_sampler
-    num_samples = NewRelic::Agent.instance.transaction_sampler.samples.length
-    assert_equal "[FILTERED]", @controller._filter_parameters({'social_security_number' => 'test'})['social_security_number']
-    get :index, 'social_security_number' => "001-555-1212"
-    samples = agent.transaction_sampler.samples
-    assert_equal num_samples + 1, samples.length
-    assert_equal "[FILTERED]", samples.last.params[:request_params]["social_security_number"]
-  end
-
-  def test_controller_params
+  def test_request_params
     s = with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
       agent.transaction_sampler.reset!
       get :index, 'number' => "001-555-1212"
       agent.transaction_sampler.harvest(nil)
     end
     assert_equal 1, s.size
-    assert_equal 5, s.first.params.size
+    assert_equal('001-555-1212',
+                 s.first.params[:request_params]['number'])
   end
 
   def test_busy_calculation_correctly_calculates_based_acccumlator
@@ -337,50 +332,6 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
 
   end
 
-  def test_queue_headers_heroku
-    # make this test deterministic
-    Time.stubs(:now => Time.at(1360973845))
-
-    engine.clear_stats
-    NewRelic::Agent::AgentTestController.clear_headers
-
-    queue_length_stat = stats('Mongrel/Queue Length')
-    queue_time_stat = stats('WebFrontend/QueueTime')
-
-    # heroku version
-    request_start = ((Time.now.to_f - 0.5) * 1e6).to_i.to_s
-    NewRelic::Agent::AgentTestController.set_some_headers({'HTTP_X_QUEUE_START' => "t=#{request_start}", 'HTTP_X_HEROKU_QUEUE_DEPTH' => '0'})
-    get :index
-    assert_equal(0, queue_length_stat.total_call_time, 'queue should be empty')
-    assert_equal(1, queue_time_stat.call_count, 'should have seen the queue header once')
-    assert(queue_time_stat.total_call_time > 0.1, "Queue time should be longer than 100ms")
-    assert(queue_time_stat.total_call_time < 10, "Queue time should be under 10 seconds (sanity check)")
-  end
-
-  def test_queue_headers_heroku_queue_length
-    # make this test deterministic
-    Time.stubs(:now => Time.at(1360973845))
-
-    engine.clear_stats
-    NewRelic::Agent::AgentTestController.clear_headers
-
-    queue_length_stat = stats('Mongrel/Queue Length')
-    queue_time_stat = stats('WebFrontend/QueueTime')
-
-    # heroku version with queue length > 0
-    request_start = ((Time.now.to_f - 0.5) * 1e6).to_i.to_s
-    NewRelic::Agent::AgentTestController.set_some_headers({'HTTP_X_QUEUE_START' => "t=#{request_start}", 'HTTP_X_HEROKU_QUEUE_DEPTH' => '3'})
-    get :index
-
-    assert_equal(1, queue_length_stat.call_count, 'queue should have been seen once')
-    assert_equal(1, queue_time_stat.call_count, 'should have seen the queue header once')
-    assert(queue_time_stat.total_call_time > 0.1, "Queue time should be longer than 100ms")
-    assert(queue_time_stat.total_call_time < 10, "Queue time should be under 10 seconds (sanity check)")
-    assert_equal(3, queue_length_stat.total_call_time, 'queue should be 3 long')
-
-    NewRelic::Agent::AgentTestController.clear_headers
-  end
-
   private
   def stats(name)
     engine.get_stats_no_scope(name)

data/test/new_relic/agent/autostart_test.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+require 'new_relic/agent/autostart'
+
+class AutostartTest < Test::Unit::TestCase
+
+  def test_typically_the_agent_should_autostart
+    assert ::NewRelic::Agent::Autostart.agent_should_start?
+  end
+
+  def test_agent_wont_autostart_if_RAILS_CONSOLE_constant_is_defined
+    assert !defined?(::Rails::Console), "precondition: Rails::Console shouldn't be defined"
+    Rails.const_set(:Console, true)
+    assert ! ::NewRelic::Agent::Autostart.agent_should_start?, "Agent shouldn't autostart in Rails Console session"
+  ensure
+    Rails.send(:remove_const, :Console)
+  end
+
+  def test_agent_wont_start_if_dollar_0_is_irb
+    @orig_dollar_0, $0 = $0, '/foo/bar/irb'
+    assert ! ::NewRelic::Agent::Autostart.agent_should_start?, "Agent shouldn't autostart when process is invoked by irb"
+  ensure
+    $0 = @orig_dollar_0
+  end
+
+  RAILS_DEFAULT_RAKE_TASKS = %w| about assets:clean assets:clobber
+  assets:environment assets:precompile db:create db:drop db:fixtures:load
+  db:migrate db:migrate:status db:rollback db:schema:cache:clear
+  db:schema:cache:dump db:schema:dump db:schema:load db:seed db:setup
+  db:structure:dump db:version doc:app log:clear middleware notes notes:custom
+  rails:template rails:update routes secret spec spec:controllers spec:helpers
+  spec:models spec:rcov stats test test:all test:all:db test:recent test:single
+  test:uncommitted time:zones:all tmp:clear tmp:create |.each do |task|
+
+    define_method("test_agent_wont_autostart_if_top_level_rake_task_is_#{task}") do
+      Rake.stubs(:application => stub(:top_level_tasks => [task]))
+      assert ! ::NewRelic::Agent::Autostart.agent_should_start?, "Agent shouldn't start during #{task.inspect} rake task"
+    end
+  end
+
+
+  MyConst = true
+  def test_blacklisted_constants_can_be_configured
+    with_config('autostart.blacklisted_constants' => "IRB,::AutostartTest::MyConst") do
+      assert ! ::NewRelic::Agent::Autostart.agent_should_start?, "Agent shouldn't autostart when environment contains blacklisted constant"
+    end
+  end
+
+  def test_blacklisted_executable_can_be_configured
+    @orig_dollar_0, $0 = $0, '/foo/bar/baz'
+    with_config('autostart.blacklisted_executables' => 'boo,baz') do
+      assert ! ::NewRelic::Agent::Autostart.agent_should_start?, "Agent shouldn't autostart when process is invoked by blacklisted executable"
+    end
+  ensure
+    $0 = @orig_dollar_0
+  end
+
+  def test_blacklisted_rake_tasks_can_be_configured
+    with_config('autostart.blacklisted_rake_tasks' => 'foo,bar,baz:bang') do
+      Rake.stubs(:application => stub(:top_level_tasks => ['biz', 'baz:bang']))
+      assert ! ::NewRelic::Agent::Autostart.agent_should_start?, "Agent shouldn't during blacklisted rake task"
+    end
+  end
+end