newrelic_rpm 2.12.3 → 2.13.0.beta3

data/test/new_relic/agent/agent_test_controller.rb

@@ -10,12 +10,7 @@ class NewRelic::Agent::AgentTestController < NewRelic::Agent::SuperclassControll
   filter_parameter_logging :social_security_number
   
   @@headers_to_add = nil
-  
-#  def rescue_action(e) raise e end
-  
-  ActionController::Routing::Routes.draw do | map |
-    map.connect ':controller/:action.:format'
-  end
+
   def index
     sleep params['wait'].to_i if params['wait']
     render :text => params.inspect

data/test/new_relic/agent/busy_calculator_test.rb

@@ -1,3 +1,5 @@
+# Run faster standalone
+ENV['SKIP_RAILS'] = 'true'
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
 class NewRelic::Agent::BusyCalculatorTest < Test::Unit::TestCase
   attr_reader :now

data/test/new_relic/agent/collection_helper_test.rb

@@ -1,6 +1,6 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
 require 'ostruct'
-require 'active_record_fixtures'
+require 'active_record_fixtures' if defined?(::ActiveRecord)
 class NewRelic::Agent::CollectionHelperTest < Test::Unit::TestCase
   
   def setup
@@ -17,8 +17,8 @@ class NewRelic::Agent::CollectionHelperTest < Test::Unit::TestCase
     assert_equal val[0...256] + "...", normalize_params(val)
   end
   def test_array
-    new_array = normalize_params [ 1000 ] * 50
-    assert_equal 20, new_array.size
+    new_array = normalize_params [ 1000 ] * 2000
+    assert_equal 1024, new_array.size
     assert_equal '1000', new_array[0]
   end
   def test_boolean
@@ -115,11 +115,11 @@ class NewRelic::Agent::CollectionHelperTest < Test::Unit::TestCase
       #puts e.backtrace.join("\n")
       #puts "\n\n"
       clean_trace = strip_nr_from_backtrace(e.backtrace)
-      assert_equal 0, clean_trace.grep(/newrelic_rpm/).size, clean_trace.grep(/newrelic_rpm/)
-      assert_equal 0, clean_trace.grep(/trace/).size, clean_trace.grep(/trace/)
+      assert_equal 0, clean_trace.grep(/newrelic_rpm/).size, clean_trace.inspect
+      assert_equal 0, clean_trace.grep(/trace/).size, clean_trace.inspect
       assert_equal 3, clean_trace.grep(/find/).size, "should see three frames with 'find' in them (#{e}): \n#{clean_trace.join("\n")}"
     ensure
       ActiveRecordFixtures.teardown
     end
-  end
+  end if defined?(::ActiveRecord)
 end

data/test/new_relic/agent/error_collector_test.rb

@@ -1,17 +1,6 @@
+# Run faster standalone
+ENV['SKIP_RAILS'] = 'true'
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
-require 'test/unit'
-
-class FakeRequest
-  attr_reader :path
-  
-  def initialize(path)
-    @path = path
-  end
-  
-  def referer
-    "test_referer"
-  end
-end
 
 class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
   
@@ -25,15 +14,18 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
     @error_collector.notice_error(nil, :metric=> 'path', :request_params => {:x => 'y'})
     errors = @error_collector.harvest_errors([])
     
-    assert_equal errors.length, 1
+    assert_equal 0, errors.length
+
+    @error_collector.notice_error('Some error message', :metric=> 'path', :request_params => {:x => 'y'})
+    errors = @error_collector.harvest_errors([])
     
     err = errors.first
-    assert_equal '<no message>', err.message 
+    assert_equal 'Some error message', err.message 
     assert_equal 'y', err.params[:request_params][:x]
     assert_equal '', err.params[:request_uri]
     assert_equal '', err.params[:request_referer]
     assert_equal 'path', err.path 
-    assert_equal '<no exception>', err.exception_class
+    assert_equal 'Error', err.exception_class
 
   end
   def test_simple
@@ -102,7 +94,7 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
     
     max_q_length = 20     # for some reason I can't read the constant in ErrorCollector
     
-    silence_stream(::STDERR) do
+    silence_stream(::STDOUT) do
      (max_q_length + 5).times do |n|
         @error_collector.notice_error(Exception.new("exception #{n}"), :metric => "path", :request_params => {:x => n}) 
       end
@@ -143,9 +135,9 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
   
   
   def test_exclude
-    @error_collector.ignore(["ActionController::RoutingError"])
+    @error_collector.ignore(["IOError"])
     
-    @error_collector.notice_error(ActionController::RoutingError.new("message"), :metric => 'path', :request_params => {:x => 'y'}) 
+    @error_collector.notice_error(IOError.new("message"), :metric => 'path', :request_params => {:x => 'y'}) 
     
     errors = @error_collector.harvest_errors([])
     
@@ -154,14 +146,14 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
   
   def test_exclude_block
     @error_collector.ignore_error_filter do |e|
-      if e.is_a? ActionController::RoutingError
+      if e.is_a? IOError
         nil
       else
         e
       end
     end
     
-    @error_collector.notice_error(ActionController::RoutingError.new("message"), :metric => 'path', :request_params => {:x => 'y'}) 
+    @error_collector.notice_error(IOError.new("message"), :metric => 'path', :request_params => {:x => 'y'}) 
     
     errors = @error_collector.harvest_errors([])
     

data/test/new_relic/agent/metric_data_test.rb

@@ -1,27 +1,24 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
-require 'test/unit'
-
 
 class NewRelic::Agent::MetricDataTest < Test::Unit::TestCase
   
-  
   # test to make sure the MetricData class can serialize to json
   def test_json
     spec = NewRelic::MetricSpec.new("controller", "metric#find")
     
-    import = ActiveSupport::JSON.decode(spec.to_json)
+    import = ::ActiveSupport::JSON.decode(spec.to_json)
     
     compare_spec(spec, import)
     
     stats = NewRelic::MethodTraceStats.new
     
-    import = ActiveSupport::JSON.decode(stats.to_json)
+    import = ::ActiveSupport::JSON.decode(stats.to_json)
     
     compare_stat(stats, import)
     
     metric_data = NewRelic::MetricData.new(spec, stats, 10)
     
-    import = ActiveSupport::JSON.decode(metric_data.to_json)
+    import = ::ActiveSupport::JSON.decode(metric_data.to_json)
     
     compare_metric_data(metric_data, import)
   end

data/test/new_relic/agent/rpm_agent_test.rb

@@ -1,138 +1,142 @@
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
-##require 'new_relic/agent/agent'
-##require 'new_relic/local_environment'
+ENV['SKIP_RAILS'] = 'true'
+require File.expand_path('../../../test_helper', __FILE__) 
 
-class RpmAgentTest < ActiveSupport::TestCase
+class RpmAgentTest < Test::Unit::TestCase # ActiveSupport::TestCase
+  extend TestContexts
   
   attr_reader :agent
   
-  # Fake out the agent to think mongrel is running
-  def setup
-    NewRelic::Agent.manual_start
-    @agent = NewRelic::Agent.instance
-  end
-  
-  def teardown
-    NewRelic::Agent.shutdown
-    NewRelic::Control.instance['app_name']=nil
-    NewRelic::Control.instance['dispatcher']=nil
-    NewRelic::Control.instance['dispatcher_instance_id']=nil
-  end
-  def test_agent_setup
-    assert NewRelic::Agent.instance.class == NewRelic::Agent::Agent
-    assert_raise RuntimeError do
-      NewRelic::Control.instance.init_plugin :agent_enabled => false
+  with_running_agent do
+    # Fake out the agent to think mongrel is running
+    
+    should "agent_setup" do
+      assert NewRelic::Agent.instance.class == NewRelic::Agent::Agent
+      assert_raise RuntimeError do
+        NewRelic::Control.instance.init_plugin :agent_enabled => false
+      end
     end
-  end
-  
-  def test_public_apis
-    assert_raise RuntimeError do
-      NewRelic::Agent.set_sql_obfuscator(:unknown) do |sql|
-        puts sql
+    
+    should "public_apis" do
+      assert_raise RuntimeError do
+        NewRelic::Agent.set_sql_obfuscator(:unknown) do |sql|
+          puts sql
+        end
+      end
+      
+      ignore_called = false
+      NewRelic::Agent.ignore_error_filter do |e|
+        ignore_called = true
+        nil
       end
+      NewRelic::Agent.notice_error(StandardError.new("message"), :request_params => {:x => "y"})
+      assert ignore_called   
+      NewRelic::Agent.instance.error_collector.instance_variable_set '@ignore_filter', nil
     end
     
-    ignore_called = false
-    NewRelic::Agent.ignore_error_filter do |e|
-      ignore_called = true
-      nil
+    should "startup_shutdown" do
+      @agent = NewRelic::Agent::ShimAgent.instance
+      @agent.shutdown
+      assert (not @agent.started?)
+      @agent.start 
+      assert !@agent.started?
+      # this installs the real agent:
+      NewRelic::Agent.manual_start
+      @agent = NewRelic::Agent.instance
+      assert @agent != NewRelic::Agent::ShimAgent.instance
+      assert @agent.started?
+      @agent.shutdown
+      assert !@agent.started?
+      @agent.start
+      assert @agent.started?
     end
-    NewRelic::Agent.notice_error(ActionController::RoutingError.new("message"), :request_params => {:x => "y"})
-    assert ignore_called   
-    NewRelic::Agent.instance.error_collector.instance_variable_set '@ignore_filter', nil
-  end
-  
-  def test_startup_shutdown
-    @agent = NewRelic::Agent::ShimAgent.instance
-    @agent.shutdown
-    assert (not @agent.started?)
-    @agent.start 
-    assert !@agent.started?
-    # this installs the real agent:
-    NewRelic::Agent.manual_start
-    @agent = NewRelic::Agent.instance
-    assert @agent != NewRelic::Agent::ShimAgent.instance
-    assert @agent.started?
-    @agent.shutdown
-    assert !@agent.started?
-    @agent.start
-    assert @agent.started?
-  end
-  
-  def test_manual_start
-    NewRelic::Agent.instance.expects(:connect).once
-    NewRelic::Agent.instance.expects(:start_worker_thread).once
-    NewRelic::Agent.instance.instance_variable_set '@started', nil
-    NewRelic::Agent.manual_start :monitor_mode => true, :license_key => ('x' * 40)
-  end
-  
-  def test_post_fork_handler
-    NewRelic::Agent.manual_start :monitor_mode => true, :license_key => ('x' * 40)
-    NewRelic::Agent.after_fork    
-    NewRelic::Agent.after_fork    
-  end
-  def test_manual_overrides
-    NewRelic::Agent.manual_start :app_name => "testjobs", :dispatcher_instance_id => "mailer"
-    assert_equal "testjobs", NewRelic::Control.instance.app_names[0]
-    assert_equal "mailer", NewRelic::Control.instance.dispatcher_instance_id
-  end
-  def test_restart
-    NewRelic::Agent.manual_start :app_name => "noapp", :dispatcher_instance_id => ""
-    NewRelic::Agent.manual_start :app_name => "testjobs", :dispatcher_instance_id => "mailer"
-    assert_equal "testjobs", NewRelic::Control.instance.app_names[0]
-    assert_equal "mailer", NewRelic::Control.instance.dispatcher_instance_id
-  end
-  
-  def test_send_timeslice_data
-    @agent.expects(:invoke_remote).returns({NewRelic::MetricSpec.new("/A/b/c") => 1, NewRelic::MetricSpec.new("/A/b/c", "/X") => 2, NewRelic::MetricSpec.new("/A/b/d") => 3 }.to_a)
-    @agent.send :harvest_and_send_timeslice_data
-    assert_equal 3, @agent.metric_ids.size
-    assert_equal 3, @agent.metric_ids[NewRelic::MetricSpec.new("/A/b/d") ], @agent.metric_ids.inspect
-  end
-  def test_set_record_sql
-    @agent.set_record_sql(false)
-    assert !Thread::current[:record_sql]
-    NewRelic::Agent.disable_sql_recording do
-      assert_equal false, Thread::current[:record_sql]
+    
+    should "manual_start" do
+      NewRelic::Agent.instance.expects(:connect).once
+      NewRelic::Agent.instance.expects(:start_worker_thread).once
+      NewRelic::Agent.instance.instance_variable_set '@started', nil
+      NewRelic::Agent.manual_start :monitor_mode => true, :license_key => ('x' * 40)
+    end
+    
+    should "post_fork_handler" do
+      NewRelic::Agent.manual_start :monitor_mode => true, :license_key => ('x' * 40)
+      NewRelic::Agent.after_fork    
+      NewRelic::Agent.after_fork    
+    end
+    should "manual_overrides" do
+      NewRelic::Agent.manual_start :app_name => "testjobs", :dispatcher_instance_id => "mailer"
+      assert_equal "testjobs", NewRelic::Control.instance.app_names[0]
+      assert_equal "mailer", NewRelic::Control.instance.dispatcher_instance_id
+    end
+    
+    should "restart" do
+      NewRelic::Agent.manual_start :app_name => "noapp", :dispatcher_instance_id => ""
+      NewRelic::Agent.manual_start :app_name => "testjobs", :dispatcher_instance_id => "mailer"
+      assert_equal "testjobs", NewRelic::Control.instance.app_names[0]
+      assert_equal "mailer", NewRelic::Control.instance.dispatcher_instance_id
+    end
+    
+    should "send_timeslice_data" do
+      @agent.expects(:invoke_remote).returns({NewRelic::MetricSpec.new("/A/b/c") => 1, NewRelic::MetricSpec.new("/A/b/c", "/X") => 2, NewRelic::MetricSpec.new("/A/b/d") => 3 }.to_a)
+      @agent.send :harvest_and_send_timeslice_data
+      assert_equal 3, @agent.metric_ids.size
+      assert_equal 3, @agent.metric_ids[NewRelic::MetricSpec.new("/A/b/d") ], @agent.metric_ids.inspect
+    end
+    should "set_record_sql" do
+      @agent.set_record_sql(false)
+      assert !Thread::current[:record_sql]
       NewRelic::Agent.disable_sql_recording do
         assert_equal false, Thread::current[:record_sql]
+        NewRelic::Agent.disable_sql_recording do
+          assert_equal false, Thread::current[:record_sql]
+        end
+        assert_equal false, Thread::current[:record_sql]
       end
-      assert_equal false, Thread::current[:record_sql]
+      assert !Thread::current[:record_sql], Thread::current[:record_sql]
+      @agent.set_record_sql(nil)
     end
-    assert !Thread::current[:record_sql], Thread::current[:record_sql]
-  ensure
-    @agent.set_record_sql(nil)
-  end
-  
-  def test_version
-    assert_match /\d\.\d+\.\d+/, NewRelic::VERSION::STRING
-  end
-  
-  def test_invoke_remote__ignore_non_200_results
-    NewRelic::Agent::Agent.class_eval do
-      public :invoke_remote
+    
+    should "version" do
+      assert_match /\d\.\d+\.\d+/, NewRelic::VERSION::STRING
     end
-    response_mock = mock()
-    Net::HTTP.any_instance.stubs(:request).returns(response_mock)
-    response_mock.stubs(:message).returns("bogus error")
     
-    for code in %w[500 504 400 302 503] do 
-      assert_raise NewRelic::Agent::ServerConnectionException, "Ignore #{code}" do
-        response_mock.stubs(:code).returns(code)
-        NewRelic::Agent.agent.invoke_remote  :get_data_report_period, 0
+    should "invoke_remote__ignore_non_200_results" do
+      NewRelic::Agent::Agent.class_eval do
+        public :invoke_remote
+      end
+      response_mock = mock()
+      Net::HTTP.any_instance.stubs(:request).returns(response_mock)
+      response_mock.stubs(:message).returns("bogus error")
+      
+      for code in %w[500 504 400 302 503] do 
+        assert_raise NewRelic::Agent::ServerConnectionException, "Ignore #{code}" do
+          response_mock.stubs(:code).returns(code)
+          NewRelic::Agent.agent.invoke_remote  :get_data_report_period, 0
+        end
       end
     end
-  end
-  def test_invoke_remote__throw_other_errors
-    NewRelic::Agent::Agent.class_eval do
-      public :invoke_remote
+    should "invoke_remote__throw_other_errors" do
+      NewRelic::Agent::Agent.class_eval do
+        public :invoke_remote
+      end
+      response_mock = Net::HTTPSuccess.new  nil, nil, nil
+      response_mock.stubs(:body).returns("")
+      Marshal.stubs(:load).raises(RuntimeError, "marshal issue")
+      Net::HTTP.any_instance.stubs(:request).returns(response_mock)
+      assert_raise RuntimeError do
+        NewRelic::Agent.agent.invoke_remote  :get_data_report_period, 0xFEFE
+      end
     end
-    response_mock = Net::HTTPSuccess.new  nil, nil, nil
-    response_mock.stubs(:body).returns("")
-    Marshal.stubs(:load).raises(RuntimeError, "marshal issue")
-    Net::HTTP.any_instance.stubs(:request).returns(response_mock)
-    assert_raise RuntimeError do
-      NewRelic::Agent.agent.invoke_remote  :get_data_report_period, 0xFEFE
+    
+    context "with transaction api" do
+      should "reject empty arguments" do
+        assert_raises RuntimeError do
+          NewRelic::Agent.record_transaction 0.5
+        end
+      end
+      should "record a transaction" do
+        NewRelic::Agent.record_transaction 0.5, 'uri' => "/users/create?foo=bar"
+      end
+      
     end
   end
 end

data/test/new_relic/agent/task_instrumentation_test.rb

@@ -1,165 +1,160 @@
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+# Run faster standalone
+ENV['SKIP_RAILS'] = 'true'
+
+require File.expand_path('../../../test_helper', __FILE__) 
 
 class TaskInstrumentationTest < Test::Unit::TestCase
   include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+  extend TestContexts
   attr_accessor :agent
-  def setup
-    super
-    NewRelic::Agent.manual_start
-    @agent = NewRelic::Agent.instance
-    @agent.transaction_sampler.send :clear_builder
-    @agent.transaction_sampler.reset!
-    @agent.stats_engine.clear_stats
-  end
-  def teardown
-    NewRelic::Agent.shutdown
-    super
-  end
   
-  def test_run
-    run_task_inner 0
-    stat_names = %w[Controller/TaskInstrumentationTest/inner_task_0
+  with_running_agent do
+    
+    should "run" do
+      run_task_inner 0
+      stat_names = %w[Controller/TaskInstrumentationTest/inner_task_0
                     HttpDispatcher
                     Apdex Apdex/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)
+      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
-  end
-  
-  def test_run_recursive
-    run_task_inner(3)
-    assert_equal 1, @agent.stats_engine.lookup_stats(
+      }.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
+    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
-    assert_equal 1, @agent.stats_engine.lookup_stats(
+      assert_equal 1, @agent.stats_engine.lookup_stats(
                           'Controller/TaskInstrumentationTest/inner_task_1',
                           'Controller/TaskInstrumentationTest/inner_task_2').call_count
-    assert_equal 1, @agent.stats_engine.lookup_stats(
+      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
-    assert_equal 0, @agent.stats_engine.get_stats_no_scope('Controller').call_count
-  end
-  
-  def test_run_nested
-    run_task_outer(3)
-    @agent.stats_engine.metrics.sort.each do |n|
-      stat = @agent.stats_engine.get_stats_no_scope(n)
-      #      puts "#{'%-26s' % n}: #{stat.call_count} calls @ #{stat.average_call_time} sec/call"
+      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
+      assert_equal 0, @agent.stats_engine.get_stats_no_scope('Controller').call_count
     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
-  end
-  
-  def test_reentrancy
-    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
-    compare_metrics %w[
+    
+    should "run_nested" do
+      run_task_outer(3)
+      @agent.stats_engine.metrics.sort.each do |n|
+        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
+    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
+      compare_metrics %w[
       Controller/TaskInstrumentationTest/inner_task_0:Controller/TaskInstrumentationTest/inner_task_1
       Controller/TaskInstrumentationTest/inner_task_0
       Controller/TaskInstrumentationTest/inner_task_1
       ], @agent.stats_engine.metrics.grep(/^Controller/)
-  end
-  
-  def test_transaction
-    assert_equal 0, @agent.transaction_sampler.scope_depth, "existing unfinished sample"
-    assert_nil @agent.transaction_sampler.last_sample
-    assert_equal @agent.transaction_sampler, @agent.stats_engine.instance_variable_get("@transaction_sampler")
-    run_task_outer(10)
-    assert_equal 0, @agent.transaction_sampler.scope_depth, "existing unfinished sample"
-    @agent.stats_engine.metrics.sort.each do |n|
-      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 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 0, @agent.transaction_sampler.scope_depth, "existing unfinished sample"
-    sample = @agent.transaction_sampler.last_sample
-    assert_not_nil sample
-    assert_not_nil sample.params[:cpu_time], "cpu time nil: \n#{sample}"
-    assert sample.params[:cpu_time] >= 0, "cpu time: #{sample.params[:cpu_time]},\n#{sample}"
-    assert_equal '10', sample.params[:request_params][:level]
-  end
-  
-  def test_abort
-    @acct = 'Redrocks'
-    perform_action_with_newrelic_trace(:name => 'hello', :force => true, :params => { :account => @acct}) do
-      RAILS_DEFAULT_LOGGER.info "Hello world"
-      NewRelic::Agent.abort_transaction!
+    
+    should "transaction" do
+      assert_equal 0, @agent.transaction_sampler.scope_depth, "existing unfinished sample"
+      assert_nil @agent.transaction_sampler.last_sample
+      assert_equal @agent.transaction_sampler, @agent.stats_engine.instance_variable_get("@transaction_sampler")
+      run_task_outer(10)
+      assert_equal 0, @agent.transaction_sampler.scope_depth, "existing unfinished sample"
+      @agent.stats_engine.metrics.sort.each do |n|
+        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 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 0, @agent.transaction_sampler.scope_depth, "existing unfinished sample"
+      sample = @agent.transaction_sampler.last_sample
+      assert_not_nil sample
+      assert_not_nil sample.params[:cpu_time], "cpu time nil: \n#{sample}"
+      assert sample.params[:cpu_time] >= 0, "cpu time: #{sample.params[:cpu_time]},\n#{sample}"
+      assert_equal '10', sample.params[:request_params][:level]
     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_nil @agent.transaction_sampler.last_sample
-  end
-  
-  def test_block
-    assert_equal @agent, NewRelic::Agent.instance
-    @acct = 'Redrocks'
-    perform_action_with_newrelic_trace(:name => 'hello', :force => true, :params => { :account => @acct}) do
-      RAILS_DEFAULT_LOGGER.info "Hello world"
+    
+    should "abort" do
+      @acct = 'Redrocks'
+      perform_action_with_newrelic_trace(:name => 'hello', :force => true, :params => { :account => @acct}) do
+        self.class.inspect
+        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_nil @agent.transaction_sampler.last_sample
     end
-    @agent.stats_engine.metrics.sort.each do |n|
-      stat = @agent.stats_engine.get_stats_no_scope(n)
-      #puts "#{'%-26s' % n}: #{stat.call_count} calls @ #{stat.average_call_time} sec/call"
+    should "block" do
+      assert_equal @agent, NewRelic::Agent.instance
+      @acct = 'Redrocks'
+      perform_action_with_newrelic_trace(:name => 'hello', :force => true, :params => { :account => @acct}) do
+        self.class.inspect
+      end
+      @agent.stats_engine.metrics.sort.each do |n|
+        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 @agent, NewRelic::Agent.instance
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/TaskInstrumentationTest/hello').call_count
+      sample = @agent.transaction_sampler.last_sample
+      assert_not_nil sample
+      assert_equal 'Redrocks', sample.params[:request_params][:account]
+      
     end
-    assert_equal @agent, NewRelic::Agent.instance
-    assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/TaskInstrumentationTest/hello').call_count
-    sample = @agent.transaction_sampler.last_sample
-    assert_not_nil sample
-    assert_equal 'Redrocks', sample.params[:request_params][:account]
     
-  end
-  
-  def test_error_handling
-    @agent.error_collector.ignore_error_filter
-    @agent.error_collector.harvest_errors([])
-    @agent.error_collector.expects(:notice_error).once
-    assert_equal @agent.error_collector, NewRelic::Agent.instance.error_collector
-    assert_raise RuntimeError do
-      run_task_exception
+    should "error_handling" do
+      @agent.error_collector.ignore_error_filter
+      @agent.error_collector.harvest_errors([])
+      @agent.error_collector.expects(:notice_error).once
+      assert_equal @agent.error_collector, NewRelic::Agent.instance.error_collector
+      assert_raise RuntimeError do
+        run_task_exception
+      end
     end
-  end
-  
-  def test_custom_params
-    @agent.error_collector.stubs(:enabled).returns(true)
-    @agent.error_collector.ignore_error_filter
-    @agent.error_collector.harvest_errors([])
-    assert_equal @agent.error_collector, NewRelic::Agent.instance.error_collector
-    assert_raise RuntimeError do
-      run_task_exception
+    
+    should "custom_params" do
+      @agent.error_collector.stubs(:enabled).returns(true)
+      @agent.error_collector.ignore_error_filter
+      @agent.error_collector.harvest_errors([])
+      assert_equal @agent.error_collector, NewRelic::Agent.instance.error_collector
+      assert_raise RuntimeError do
+        run_task_exception
+      end
+      errors = @agent.error_collector.harvest_errors([])
+      assert_equal 1, errors.size
+      error = errors.first
+      assert_equal "Controller/TaskInstrumentationTest/run_task_exception", error.path
+      assert_not_nil error.params[:stack_trace]
+      assert_not_nil error.params[:custom_params]
     end
-    errors = @agent.error_collector.harvest_errors([])
-    assert_equal 1, errors.size
-    error = errors.first
-    assert_equal "Controller/TaskInstrumentationTest/run_task_exception", error.path
-    assert_not_nil error.params[:stack_trace]
-    assert_not_nil error.params[:custom_params]
-  end
-  
-  def test_instrument_bg
-    run_background_job
-    stat_names = %w[OtherTransaction/Background/TaskInstrumentationTest/run_background_job
+    
+    should "instrument_bg" do
+      run_background_job
+      stat_names = %w[OtherTransaction/Background/TaskInstrumentationTest/run_background_job
                     OtherTransaction/Background/all
                     OtherTransaction/all].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)
+      
+      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 1, @agent.stats_engine.get_stats_no_scope('OtherTransaction/all').call_count
-    assert_equal 1, @agent.stats_engine.get_stats_no_scope('OtherTransaction/Background/all').call_count
+      }.join("\n  ") + "\nmissing: #{expected_but_missing.inspect}"
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('OtherTransaction/all').call_count
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('OtherTransaction/Background/all').call_count
+    end
   end
+  
   private
   
   def run_task_inner(n)
@@ -190,4 +185,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