newrelic_rpm 2.13.5.beta4 → 2.13.6.beta1

data/test/new_relic/agent/{agent_controller_test.rb → agent_test_controller_test.rb}

@@ -1,6 +1,6 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
 require 'action_controller/test_case'
-class AgentControllerTest < ActionController::TestCase
+class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
   require 'action_controller/base'
   require 'new_relic/agent/agent_test_controller'
   
@@ -43,12 +43,13 @@ class AgentControllerTest < ActionController::TestCase
   
   def teardown
     Thread.current[:newrelic_ignore_controller] = nil
-    super
     NewRelic::Agent.shutdown
     NewRelic::Agent::AgentTestController.clear_headers
+    super
   end
   
   def test_mongrel_queue
+    NewRelic::Agent::AgentTestController.clear_headers        
     engine.clear_stats
     NewRelic::Control.instance.local_env.stubs(:mongrel).returns( stub('mongrel', :workers => stub('workers', :list => stub('list', :length => '10'))))
     
@@ -70,6 +71,7 @@ class AgentControllerTest < ActionController::TestCase
   end
 
   def test_new_queue_integration
+    NewRelic::Agent::AgentTestController.clear_headers    
     engine.clear_stats
     start = ((Time.now - 1).to_f * 1_000_000).to_i
     NewRelic::Agent::AgentTestController.set_some_headers 'HTTP_X_QUEUE_START'=> "t=#{start}"
@@ -89,6 +91,7 @@ class AgentControllerTest < ActionController::TestCase
   end
 
   def test_new_server_time_integration
+    NewRelic::Agent::AgentTestController.clear_headers    
     engine.clear_stats
     start = ((Time.now - 1).to_f * 1_000_000).to_i
     NewRelic::Agent::AgentTestController.set_some_headers 'HTTP_X_REQUEST_START'=> "t=#{start}"
@@ -298,7 +301,7 @@ class AgentControllerTest < ActionController::TestCase
   end
 
   def test_queue_headers_apache
-
+    NewRelic::Agent::AgentTestController.clear_headers    
     engine.clear_stats
     queue_length_stat = stats('Mongrel/Queue Length')
     queue_time_stat = stats('WebFrontend/QueueTime')

data/test/new_relic/agent/{error_collector_notice_error_test.rb → error_collector/notice_error_test.rb}

@@ -1,5 +1,5 @@
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
-class NewRelic::Agent::ErrorCollectorNoticeErrorTest < Test::Unit::TestCase
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper')) 
+class NewRelic::Agent::ErrorCollector::NoticeErrorTest < Test::Unit::TestCase
   require 'new_relic/agent/error_collector'
   include NewRelic::Agent::ErrorCollector::NoticeError
   

data/test/new_relic/agent/{active_record_instrumentation_test.rb → instrumentation/active_record_instrumentation_test.rb}

@@ -1,5 +1,5 @@
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
-class ActiveRecordInstrumentationTest < Test::Unit::TestCase
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper')) 
+class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::Unit::TestCase
   require 'active_record_fixtures'
   include NewRelic::Agent::Instrumentation::ControllerInstrumentation
   def setup

data/test/new_relic/agent/{metric_frame_test.rb → instrumentation/metric_frame_test.rb}

@@ -1,7 +1,6 @@
-require 'test/unit'
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper')) 
 
-class NewRelic::Agent::MetricFrameTest < Test::Unit::TestCase
+class NewRelic::Agent::Instrumentation::MetricFrameTest < Test::Unit::TestCase
 
   attr_reader :f
   def setup

data/test/new_relic/agent/{net_instrumentation_test.rb → instrumentation/net_instrumentation_test.rb}

@@ -1,6 +1,6 @@
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper')) 
 
-class NewRelic::Agent::NetInstrumentationTest < Test::Unit::TestCase
+class NewRelic::Agent::Instrumentation::NetInstrumentationTest < Test::Unit::TestCase
   include NewRelic::Agent::Instrumentation::ControllerInstrumentation
   def setup
     NewRelic::Agent.manual_start
@@ -33,7 +33,7 @@ class NewRelic::Agent::NetInstrumentationTest < Test::Unit::TestCase
       assert_match /<head>/, res.body
     end
     assert_equal %w[External/www.google.com/Net::HTTP/GET External/allOther External/www.google.com/all
-       External/www.google.com/Net::HTTP/GET:OtherTransaction/Background/NewRelic::Agent::NetInstrumentationTest/task].sort, metrics_without_gc.select{|m| m =~ /^External/}.sort
+       External/www.google.com/Net::HTTP/GET:OtherTransaction/Background/NewRelic::Agent::Instrumentation::NetInstrumentationTest/task].sort, metrics_without_gc.select{|m| m =~ /^External/}.sort
   end
 
   def test_transactional
@@ -45,7 +45,7 @@ class NewRelic::Agent::NetInstrumentationTest < Test::Unit::TestCase
       assert_match /<head>/, res.body
     end
     assert_equal %w[External/www.google.com/Net::HTTP/GET External/allWeb External/www.google.com/all
-       External/www.google.com/Net::HTTP/GET:Controller/NewRelic::Agent::NetInstrumentationTest/task].sort, metrics_without_gc.select{|m| m =~ /^External/}.sort
+       External/www.google.com/Net::HTTP/GET:Controller/NewRelic::Agent::Instrumentation::NetInstrumentationTest/task].sort, metrics_without_gc.select{|m| m =~ /^External/}.sort
   end
   def test_get__simple
     Net::HTTP.get URI.parse('http://www.google.com/index.html')

data/test/new_relic/agent/{queue_time_test.rb → instrumentation/queue_time_test.rb}

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper'))
 class NewRelic::Agent::Instrumentation::QueueTimeTest < Test::Unit::TestCase
   require 'new_relic/agent/instrumentation/queue_time'
   include NewRelic::Agent::Instrumentation::QueueTime

data/test/new_relic/agent/{task_instrumentation_test.rb → instrumentation/task_instrumentation_test.rb}

@@ -1,9 +1,6 @@
-# Run faster standalone
-ENV['SKIP_RAILS'] = 'true'
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper'))
 
-require File.expand_path('../../../test_helper', __FILE__) 
-
-class TaskInstrumentationTest < Test::Unit::TestCase
+class NewRelic::Agent::Instrumentation::TaskInstrumentationTest < Test::Unit::TestCase
   include NewRelic::Agent::Instrumentation::ControllerInstrumentation
   extend TestContexts
   attr_accessor :agent
@@ -12,33 +9,33 @@ class TaskInstrumentationTest < Test::Unit::TestCase
     
     should "run" do
       run_task_inner 0
-      stat_names = %w[Controller/TaskInstrumentationTest/inner_task_0
+      stat_names = %w[Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0
                     HttpDispatcher
-                    Apdex Apdex/TaskInstrumentationTest/inner_task_0].sort
+                    Apdex Apdex/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0].sort
       expected_but_missing = stat_names - @agent.stats_engine.metrics
       assert_equal 0, expected_but_missing.size, @agent.stats_engine.metrics.map  { |n|
         stat = @agent.stats_engine.get_stats_no_scope(n)
       "#{'%-26s' % n}: #{stat.call_count} calls @ #{stat.average_call_time} sec/call"
       }.join("\n  ") + "\nmissing: #{expected_but_missing.inspect}"
       assert_equal 0, @agent.stats_engine.get_stats_no_scope('Controller').call_count
-      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/TaskInstrumentationTest/inner_task_0').call_count
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0').call_count
     end
     
     should "run_recursive" do
       run_task_inner(3)
       assert_equal 1, @agent.stats_engine.lookup_stats(
-                          'Controller/TaskInstrumentationTest/inner_task_0',
-                          'Controller/TaskInstrumentationTest/inner_task_1').call_count
+                          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0',
+                          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_1').call_count
       assert_equal 1, @agent.stats_engine.lookup_stats(
-                          'Controller/TaskInstrumentationTest/inner_task_1',
-                          'Controller/TaskInstrumentationTest/inner_task_2').call_count
+                          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_1',
+                          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_2').call_count
       assert_equal 1, @agent.stats_engine.lookup_stats(
-                          'Controller/TaskInstrumentationTest/inner_task_2',
-                          'Controller/TaskInstrumentationTest/inner_task_3').call_count
-      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/TaskInstrumentationTest/inner_task_0').call_count
-      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/TaskInstrumentationTest/inner_task_1').call_count
-      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/TaskInstrumentationTest/inner_task_2').call_count
-      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/TaskInstrumentationTest/inner_task_3').call_count
+                          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_2',
+                          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_3').call_count
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0').call_count
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_1').call_count
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_2').call_count
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_3').call_count
       assert_equal 0, @agent.stats_engine.get_stats_no_scope('Controller').call_count
     end
     
@@ -48,19 +45,19 @@ class TaskInstrumentationTest < Test::Unit::TestCase
         stat = @agent.stats_engine.get_stats_no_scope(n)
         #      puts "#{'%-26s' % n}: #{stat.call_count} calls @ #{stat.average_call_time} sec/call"
       end
-      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/TaskInstrumentationTest/outer_task').call_count
-      assert_equal 2, @agent.stats_engine.get_stats_no_scope('Controller/TaskInstrumentationTest/inner_task_0').call_count
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/outer_task').call_count
+      assert_equal 2, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0').call_count
     end
     
     should "reentrancy" do
       assert_equal 0, NewRelic::Agent::BusyCalculator.busy_count
       run_task_inner(1)
-      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/TaskInstrumentationTest/inner_task_0').call_count
-      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/TaskInstrumentationTest/inner_task_1').call_count
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0').call_count
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_1').call_count
       compare_metrics %w[
-      Controller/TaskInstrumentationTest/inner_task_0:Controller/TaskInstrumentationTest/inner_task_1
-      Controller/TaskInstrumentationTest/inner_task_0
-      Controller/TaskInstrumentationTest/inner_task_1
+      Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0:Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_1
+      Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0
+      Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_1
       ], @agent.stats_engine.metrics.grep(/^Controller/)
     end
     
@@ -74,9 +71,9 @@ class TaskInstrumentationTest < Test::Unit::TestCase
         stat = @agent.stats_engine.get_stats_no_scope(n)
         #      puts "#{'%-26s' % n}: #{stat.call_count} calls @ #{stat.average_call_time} sec/call"
       end
-      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/TaskInstrumentationTest/outer_task').call_count
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/outer_task').call_count
       assert_equal 0, @agent.stats_engine.get_stats_no_scope('Controller').call_count
-      assert_equal 2, @agent.stats_engine.get_stats_no_scope('Controller/TaskInstrumentationTest/inner_task_0').call_count
+      assert_equal 2, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0').call_count
       assert_equal 0, @agent.transaction_sampler.scope_depth, "existing unfinished sample"
       sample = @agent.transaction_sampler.last_sample
       assert_not_nil sample
@@ -92,7 +89,7 @@ class TaskInstrumentationTest < Test::Unit::TestCase
         NewRelic::Agent.abort_transaction!
       end
       # We record the controller metric still, but abort any transaction recording.
-      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/TaskInstrumentationTest/hello').call_count
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/hello').call_count
       assert_nil @agent.transaction_sampler.last_sample
     end
     should "block" do
@@ -106,7 +103,7 @@ class TaskInstrumentationTest < Test::Unit::TestCase
         #puts "#{'%-26s' % n}: #{stat.call_count} calls @ #{stat.average_call_time} sec/call"
       end
       assert_equal @agent, NewRelic::Agent.instance
-      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/TaskInstrumentationTest/hello').call_count
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/hello').call_count
       sample = @agent.transaction_sampler.last_sample
       assert_not_nil sample
       assert_equal 'Redrocks', sample.params[:request_params][:account]
@@ -134,14 +131,14 @@ class TaskInstrumentationTest < Test::Unit::TestCase
       errors = @agent.error_collector.harvest_errors([])
       assert_equal 1, errors.size
       error = errors.first
-      assert_equal "Controller/TaskInstrumentationTest/run_task_exception", error.path
+      assert_equal "Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/run_task_exception", error.path
       assert_not_nil error.params[:stack_trace]
       assert_not_nil error.params[:custom_params]
     end
     
     should "instrument_bg" do
       run_background_job
-      stat_names = %w[OtherTransaction/Background/TaskInstrumentationTest/run_background_job
+      stat_names = %w[OtherTransaction/Background/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/run_background_job
                     OtherTransaction/Background/all
                     OtherTransaction/all].sort
       
@@ -185,4 +182,4 @@ class TaskInstrumentationTest < Test::Unit::TestCase
   add_transaction_tracer :run_task_outer, :name => 'outer_task', :params => '{ :level => args[0] }'
   # Eventually we need th change this to :category => :task
   add_transaction_tracer :run_background_job, :category => 'OtherTransaction/Background'
-end
+end

data/test/new_relic/agent/method_tracer/class_methods/add_method_tracer_test.rb

@@ -0,0 +1,165 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','..','test_helper'))
+
+require 'set'
+module NewRelic
+  module Agent
+    class Agent
+      module MethodTracer
+        module ClassMethods
+          class AddMethodTracerTest < Test::Unit::TestCase
+            #  require 'new_relic/agent/method_tracer'
+            include NewRelic::Agent::MethodTracer::ClassMethods::AddMethodTracer
+
+            def test_validate_options_nonhash
+              assert_raise(TypeError) do
+                validate_options([])
+              end
+            end
+
+            def test_validate_options_defaults
+              self.expects(:check_for_illegal_keys!)
+              self.expects(:set_deduct_call_time_based_on_metric).with(DEFAULT_SETTINGS)
+              self.expects(:check_for_push_scope_and_metric)
+              validate_options({})
+            end
+
+            def test_validate_options_override
+              opts = {:push_scope => false, :metric => false, :force => true}
+              self.expects(:check_for_illegal_keys!)
+              self.expects(:check_for_push_scope_and_metric)
+              val = validate_options(opts)
+              assert val.is_a?(Hash)
+              assert (val[:push_scope] == false), val.inspect
+              assert (val[:metric] == false), val.inspect
+              assert (val[:force] == true), val.inspect
+            end
+
+            def test_default_metric_name_code
+              self.expects(:name).returns("TEST_CLASS")
+              assert_equal 'Custom/TEST_CLASS/test_method', default_metric_name_code('test_method')
+            end
+
+            def test_method_exists_positive
+              self.expects(:method_defined?).returns(true)
+              assert method_exists?('test_method')
+            end
+
+            def test_method_exists_negative
+              self.expects(:method_defined?).returns(false)
+              self.expects(:private_method_defined?).returns(false)
+              self.expects(:name).returns('TEST_CLASS')
+              fake_log = mock('log')
+              self.expects(:log).returns(fake_log)
+              fake_log.expects(:warn).with("Did not trace TEST_CLASS#test_method because that method does not exist")
+              assert !method_exists?('test_method')
+            end
+
+            def test_set_deduct_call_time_based_on_metric_positive
+              opts = {:metric => true}
+              val = set_deduct_call_time_based_on_metric(opts)
+              assert val.is_a?(Hash)
+              assert val[:deduct_call_time_from_parent]
+            end
+
+            def test_set_deduct_call_time_based_on_metric_negative
+              opts = {:metric => false}
+              val = set_deduct_call_time_based_on_metric(opts)
+              assert val.is_a?(Hash)
+              assert !val[:deduct_call_time_from_parent]
+            end
+
+            def test_set_deduct_call_time_based_on_metric_non_nil
+              opts = {:deduct_call_time_from_parent => true, :metric => false}
+              val = set_deduct_call_time_based_on_metric(opts)
+              assert val.is_a?(Hash)
+              assert val[:deduct_call_time_from_parent]
+            end
+
+            def test_set_deduct_call_time_based_on_metric_opposite
+              opts = {:deduct_call_time_from_parent => false, :metric => true}
+              val = set_deduct_call_time_based_on_metric(opts)
+              assert val.is_a?(Hash)
+              assert !val[:deduct_call_time_from_parent]
+            end
+
+            def test_unrecognized_keys_positive
+              assert_equal [:unrecognized, :keys].to_set, unrecognized_keys([:hello, :world], {:unrecognized => nil, :keys => nil}).to_set
+            end
+
+            def test_unrecognized_keys_negative
+              assert_equal [], unrecognized_keys([:hello, :world], {:hello => nil, :world => nil})
+            end
+
+            def test_any_unrecognized_keys_positive
+              assert any_unrecognized_keys?([:one], {:one => nil, :two => nil})
+            end
+
+            def test_any_unrecognized_keys_negative
+              assert !any_unrecognized_keys?([:one], {:one => nil})
+            end
+
+            def test_check_for_illegal_keys_positive
+              assert_raise(RuntimeError) do
+                check_for_illegal_keys!({:unknown_key => nil})
+              end
+            end
+
+            def test_check_for_illegal_keys_negative
+              test_keys = Hash[ALLOWED_KEYS.map {|x| [x, nil]}]
+              check_for_illegal_keys!(test_keys)
+            end
+
+            def test_traced_method_exists_positive
+              self.expects(:_traced_method_name)
+              self.expects(:method_defined?).returns(true)
+              fake_log = mock('log')
+              self.expects(:log).returns(fake_log)
+              fake_log.expects(:warn).with('Attempt to trace a method twice with the same metric: Method = test_method, Metric Name = Custom/Test/test_method')
+              assert traced_method_exists?('test_method', 'Custom/Test/test_method')
+            end
+
+            def test_traced_method_exists_negative
+              self.expects(:_traced_method_name)
+              self.expects(:method_defined?).returns(false)
+              assert !traced_method_exists?(nil, nil)
+            end
+            
+            def test_assemble_code_header_forced
+              opts = {:force => true, :code_header => 'CODE HEADER'}
+              assert_equal "CODE HEADER", assemble_code_header('test_method', 'Custom/Test/test_method', opts)
+            end
+
+            def test_assemble_code_header_unforced
+              self.expects(:_untraced_method_name).returns("method_name_without_tracing")
+              opts = {:force => false, :code_header => 'CODE HEADER'}
+              assert_equal "return method_name_without_tracing(*args, &block) unless NewRelic::Agent.is_execution_traced?\nCODE HEADER", assemble_code_header('test_method', 'Custom/Test/test_method', opts)
+            end
+
+            def test_check_for_push_scope_and_metric_positive
+              check_for_push_scope_and_metric({:push_scope => true})
+              check_for_push_scope_and_metric({:metric => true})
+            end
+
+            def test_check_for_push_scope_and_metric_negative
+              assert_raise(RuntimeError) do
+                check_for_push_scope_and_metric({:push_scope => false, :metric => false})
+              end
+            end
+
+            def test_code_to_eval_scoped
+              self.expects(:validate_options).returns({:push_scope => true})
+              self.expects(:method_with_push_scope).with('test_method', 'Custom/Test/test_method', {:push_scope => true})
+              code_to_eval('test_method', 'Custom/Test/test_method', {})
+            end
+
+            def test_code_to_eval_unscoped
+              self.expects(:validate_options).returns({:push_scope => false})
+              self.expects(:method_without_push_scope).with('test', 'Custom/Test/test', {:push_scope => false})
+              code_to_eval('test', 'Custom/Test/test', {})
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/test/new_relic/agent/{method_tracer_trace_execution_scoped_test.rb → method_tracer/instance_methods/trace_execution_scoped_test.rb}

@@ -1,5 +1,5 @@
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
-class NewRelic::Agent::MethodTracer::TraceExecutionScopedTest < Test::Unit::TestCase
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','..','test_helper')) 
+class NewRelic::Agent::MethodTracer::InstanceMethods::TraceExecutionScopedTest < Test::Unit::TestCase
   require 'new_relic/agent/method_tracer'
   include NewRelic::Agent::MethodTracer::InstanceMethods::TraceExecutionScoped
   

data/test/new_relic/agent/method_tracer_test.rb

@@ -45,19 +45,24 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
   attr_reader :stats_engine
   
   def setup
-    super
     NewRelic::Agent.manual_start
     @stats_engine = NewRelic::Agent.instance.stats_engine
     @stats_engine.clear_stats
     @scope_listener = NewRelic::Agent::MockScopeListener.new
     @old_sampler = NewRelic::Agent.instance.transaction_sampler
     @stats_engine.transaction_sampler = @scope_listener
+    super
   end
 
   def teardown
     @stats_engine.transaction_sampler = @old_sampler
     @stats_engine.clear_stats
-    self.class.remove_method_tracer :method_to_be_traced, @metric_name if @metric_name
+    begin
+      self.class.remove_method_tracer :method_to_be_traced, @metric_name if @metric_name
+    rescue RuntimeError
+      # ignore 'no tracer' errors from remove method tracer
+    end
+    
     @metric_name = nil
     super
   end
@@ -98,6 +103,13 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
     t1 = Time.now
     method_to_be_traced 1,2,3,true,METRIC
     elapsed = Time.now - t1
+
+    begin
+      self.class.remove_method_tracer :method_to_be_traced, METRIC
+    rescue RuntimeError
+      # ignore 'no tracer' errors from remove method tracer
+    end        
+
     
     stats = @stats_engine.get_stats(METRIC)
     check_time stats.total_call_time, elapsed
@@ -122,13 +134,17 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
     
     stats = @stats_engine.get_stats("Custom/#{self.class.name}/simple_method")
     assert stats.call_count == 1
-    
   end
 
   def test_method_traced?
     assert !self.class.method_traced?(:method_to_be_traced, METRIC)
     self.class.add_method_tracer :method_to_be_traced, METRIC
     assert self.class.method_traced?(:method_to_be_traced, METRIC)
+    begin
+      self.class.remove_method_tracer :method_to_be_traced, METRIC
+    rescue RuntimeError
+      # ignore 'no tracer' errors from remove method tracer
+    end                  
   end
   
   def test_tt_only
@@ -172,6 +188,12 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
     method_to_be_traced 1,2,3,true,METRIC
     elapsed = Time.now - t1
     
+    begin
+      self.class.remove_method_tracer :method_to_be_traced, METRIC
+    rescue RuntimeError
+      # ignore 'no tracer' errors from remove method tracer
+    end                  
+    
     stats = @stats_engine.get_stats(METRIC)
     check_time stats.total_call_time, elapsed
     assert stats.call_count == 1
@@ -186,6 +208,12 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
     t1 = Time.now
     method_to_be_traced 1,2,3,true,expected_metric
     elapsed = Time.now - t1
+
+    begin
+      self.class.remove_method_tracer :method_to_be_traced, metric_code
+    rescue RuntimeError
+      # ignore 'no tracer' errors from remove method tracer
+    end      
     
     stats = @stats_engine.get_stats(expected_metric)
     check_time stats.total_call_time, elapsed