newrelic_rpm 3.4.2.1 → 3.5.0

data/test/new_relic/agent/configuration/manager_test.rb

@@ -67,15 +67,6 @@ module NewRelic::Agent::Configuration
       @manager.remove_config(source)
     end
 
-    def test_source_accessors_should_be_available_as_keys
-      source = TestSource.new
-      @manager.apply_config(source)
-
-      assert_equal 'some value', @manager[:test_config_accessor]
-
-      @manager.remove_config(source)
-    end
-
     def test_should_not_apply_removed_sources
       test_source = TestSource.new
       @manager.apply_config(test_source)
@@ -123,21 +114,30 @@ module NewRelic::Agent::Configuration
         .index(NewRelic::Agent::Configuration::ManualSource)
     end
 
-    def test_app_names_single
-      @manager.apply_config(:app_name => 'test')
-      assert_equal ['test'], @manager.app_names
-    end
+    def test_registering_a_callback
+      observed_value = 'old'
+      @manager.apply_config(:test => 'original')
 
-    def test_app_names_list
-      @manager.apply_config(:app_name => 'test0;test1;test2')
-      assert_equal ['test0', 'test1', 'test2'], @manager.app_names
+      @manager.register_callback(:test) do |value|
+        observed_value = value
+      end
+      assert_equal 'original', observed_value
+
+      @manager.apply_config(:test => 'new')
+      assert_equal 'new', observed_value
     end
 
-    def test_app_names_nil
-      # nil has special meaning, so we emulate with an object that
-      # will not respond as expected
-      @manager.apply_config(:app_name => Object.new)
-      assert_equal [], @manager.app_names
+    def test_callback_not_called_if_no_change
+      @manager.apply_config(:test => true, :other => false)
+      @manager.register_callback(:test) do |value|
+        state = 'wrong'
+      end
+      state = 'right'
+      config = {:test => true}
+      @manager.apply_config(config)
+      @manager.remove_config(config)
+
+      assert_equal 'right', state
     end
 
     class TestSource < ::Hash

data/test/new_relic/agent/configuration/server_source_test.rb

@@ -5,14 +5,31 @@ module NewRelic::Agent::Configuration
   class ServerSourceTest < Test::Unit::TestCase
     def setup
       config = {
-        'slow_sql.enabled'                         => true,
-        'transaction_tracer.transaction_threshold' => 'apdex_f',
-        'error_collector.enabled'                  => true,
-        'collect_errors'                           => false
+        'agent_config' => {
+          'slow_sql.enabled'                         => true,
+          'transaction_tracer.transaction_threshold' => 'apdex_f',
+          'transaction_tracer.record_sql'            => 'raw',
+          'error_collector.enabled'                  => true
+        },
+        'apdex_t'                                  => 1.0,
+        'collect_errors'                           => false,
+        'collect_traces'                           => true
       }
       @source = ServerSource.new(config)
     end
 
+    def test_should_set_apdex_t
+      assert_equal 1.0, @source[:apdex_t]
+    end
+
+    def test_should_set_agent_config_values
+      assert_equal 'raw', @source[:'transaction_tracer.record_sql']
+    end
+
+    def test_should_not_dot_the_agent_config_sub_hash
+      assert_nil @source[:'agent_config.slow_sql.enabled']
+    end
+
     def test_should_enable_tracer_as_configured
       assert @source[:'slow_sql.enabled']
     end

data/test/new_relic/agent/instrumentation/task_instrumentation_test.rb

@@ -77,8 +77,8 @@ class NewRelic::Agent::Instrumentation::TaskInstrumentationTest < Test::Unit::Te
       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_not_nil sample.params[:custom_params][:cpu_time], "cpu time nil: \n#{sample}"
+      assert sample.params[:custom_params][:cpu_time] >= 0, "cpu time: #{sample.params[:cpu_time]},\n#{sample}"
       assert_equal '10', sample.params[:request_params][:level]
     end
 

data/test/new_relic/agent/mock_scope_listener.rb

@@ -18,6 +18,9 @@ class NewRelic::Agent::MockScopeListener
   end
 
   def notice_scope_empty(time)
+  end
 
+  def enabled?
+    true
   end
 end

data/test/new_relic/agent/new_relic_service_test.rb

@@ -1,6 +1,25 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
 
 class NewRelicServiceTest < Test::Unit::TestCase
+  def initialize(*_)
+    [ :HTTPSuccess,
+      :HTTPNotFound,
+      :HTTPRequestEntityTooLarge,
+      :HTTPUnsupportedMediaType ].each do |class_name|
+      extend_with_mock(class_name)
+    end
+    super
+  end
+
+  def extend_with_mock(class_name)
+    if !self.class.const_defined?(class_name)
+      klass = self.class.const_set(class_name,
+                Class.new(Object.const_get(:Net).const_get(class_name)))
+      klass.class_eval { include HTTPResponseMock }
+    end
+  end
+  protected :extend_with_mock
+
   def setup
     @server = NewRelic::Control::Server.new('somewhere.example.com',
                                             30303, '10.10.10.10')
@@ -30,16 +49,16 @@ class NewRelicServiceTest < Test::Unit::TestCase
 
   def test_connect_sets_redirect_host
     assert_equal 'somewhere.example.com', @service.collector.name
-    @service.connect    
+    @service.connect
     assert_equal 'localhost', @service.collector.name
   end
-  
+
   def test_connect_resets_cached_ip_address
     assert_equal '10.10.10.10', @service.collector.ip
-    @service.connect    
+    @service.connect
     assert_nil @service.collector.ip # 'localhost' resolves to nil
   end
-  
+
   def test_connect_uses_proxy_collector_if_no_redirect_host
     @http_handle.reset
     @http_handle.respond_to(:get_redirect_host, nil)
@@ -85,13 +104,13 @@ class NewRelicServiceTest < Test::Unit::TestCase
   def test_error_data
     @http_handle.respond_to(:error_data, 'too human')
     response = @service.error_data([])
-    assert_equal 'too human', response    
+    assert_equal 'too human', response
   end
 
   def test_transaction_sample_data
     @http_handle.respond_to(:transaction_sample_data, 'MPC1000')
     response = @service.transaction_sample_data([])
-    assert_equal 'MPC1000', response        
+    assert_equal 'MPC1000', response
   end
 
   def test_sql_trace_data
@@ -112,21 +131,37 @@ class NewRelicServiceTest < Test::Unit::TestCase
       @service.send(:invoke_remote, :bogus_method)
     end
   end
-  
+
   def test_should_connect_to_proxy_only_once_per_run
     @service.expects(:get_redirect_host).once
 
     @service.connect
     @http_handle.respond_to(:metric_data, '0')
     @service.metric_data(Time.now - 60, Time.now, {})
-    
+
     @http_handle.respond_to(:transaction_sample_data, '1')
     @service.transaction_sample_data([])
 
     @http_handle.respond_to(:sql_trace_data, '2')
     @service.sql_trace_data([])
   end
-  
+
+  # protocol 9
+  def test_should_raise_exception_on_413
+    @http_handle.respond_to(:metric_data, 'too big', 413)
+    assert_raise NewRelic::Agent::UnrecoverableServerException do
+      @service.metric_data(Time.now - 60, Time.now, {})
+    end
+  end
+
+  # protocol 9
+  def test_should_raise_exception_on_415
+    @http_handle.respond_to(:metric_data, 'too big', 415)
+    assert_raise NewRelic::Agent::UnrecoverableServerException do
+      @service.metric_data(Time.now - 60, Time.now, {})
+    end
+  end
+
   class HTTPHandle
     attr_accessor :read_timeout, :route_table
 
@@ -134,8 +169,17 @@ class NewRelicServiceTest < Test::Unit::TestCase
       reset
     end
 
-    def respond_to(method, payload)
-      register(HTTPResponse.new(Marshal.dump(payload))) do |request|
+    def respond_to(method, payload, code=200)
+      klass = HTTPSuccess
+      if code == 413
+        klass = HTTPRequestEntityTooLarge
+      elsif code == 415
+        klass = HTTPUnsupportedMediaType
+      elsif code >= 400
+        klass = HTTPServerError
+      end
+
+      register(klass.new(Marshal.dump(payload), code)) do |request|
         request.path.include?(method.to_s)
       end
     end
@@ -150,7 +194,7 @@ class NewRelicServiceTest < Test::Unit::TestCase
           return response
         end
       end
-      HTTPFailure.new('not found', 404)
+      HTTPNotFound.new('not found', 404)
     end
 
     def reset
@@ -172,9 +216,4 @@ class NewRelicServiceTest < Test::Unit::TestCase
       @headers[key]
     end
   end
-
-  HTTPResponse = Class.new(Net::HTTPOK)
-  HTTPResponse.class_eval { include HTTPResponseMock }
-  HTTPFailure = Class.new(Net::HTTPError)
-  HTTPFailure.class_eval { include HTTPResponseMock }
 end

data/test/new_relic/agent/pipe_channel_manager_test.rb

@@ -45,6 +45,7 @@ class NewRelic::Agent::PipeChannelManagerTest < Test::Unit::TestCase
       listener.stop
 
       assert_equal(3.0, engine.lookup_stats(metric).total_call_time)
+      engine.reset_stats
     end
 
     def test_listener_merges_transaction_traces
@@ -61,7 +62,9 @@ class NewRelic::Agent::PipeChannelManagerTest < Test::Unit::TestCase
         new_sampler = NewRelic::Agent::TransactionSampler.new
         sample = TransactionSampleTestHelper.run_sample_trace_on(new_sampler)
         new_sampler.store_force_persist(sample)
-        listener.pipes[667].write(:transaction_traces => new_sampler.harvest([], 0))
+        with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
+          listener.pipes[667].write(:transaction_traces => new_sampler.harvest([]))
+        end
       end
       Process.wait(pid)
       listener.stop

data/test/new_relic/agent/rpm_agent_test.rb

@@ -85,6 +85,7 @@ class NewRelic::Agent::RpmAgentTest < Test::Unit::TestCase # ActiveSupport::Test
     should "send_timeslice_data" do
       # this test fails due to a rubinius bug
       return if NewRelic::LanguageSupport.using_engine?('rbx')
+      @agent.service = NewRelic::FakeService.new
       @agent.service.expects(:metric_data).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)

data/test/new_relic/agent/stats_engine_test.rb

@@ -9,7 +9,7 @@ class NewRelic::Agent::StatsEngineTest < Test::Unit::TestCase
     puts e
     puts e.backtrace.join("\n")
   end
-  
+
   def teardown
     @engine.harvest_timeslice_data({},{})
     mocha_teardown
@@ -193,8 +193,8 @@ class NewRelic::Agent::StatsEngineTest < Test::Unit::TestCase
       ::Rubinius::Agent.stubs(:loopback).returns(agent)
     elsif NewRelic::LanguageSupport.using_version?('1.9')
       ::GC::Profiler.stubs(:enabled?).returns(true)
-      ::GC::Profiler.stubs(:total_time).returns(1.0, 4.0) 
-      ::GC.stubs(:count).returns(1, 3)      
+      ::GC::Profiler.stubs(:total_time).returns(1.0, 4.0)
+      ::GC.stubs(:count).returns(1, 3)
     elsif NewRelic::LanguageSupport.using_version?('1.8.7') &&
         RUBY_DESCRIPTION =~ /Ruby Enterprise Edition/
       ::GC.stubs(:time).returns(1000000, 4000000)
@@ -202,20 +202,25 @@ class NewRelic::Agent::StatsEngineTest < Test::Unit::TestCase
     else
       return true # no need to test if we're not collecting GC metrics
     end
-    
+
     engine = NewRelic::Agent.instance.stats_engine
-    scope = engine.push_scope "scope"
+    tracer = NewRelic::Agent::TransactionSampler.new
+    tracer.instance_variable_set(:@last_sample,
+                                 NewRelic::TransactionSample.new)
+    engine.transaction_sampler = tracer
     engine.start_transaction
+    scope = engine.push_scope "scope"
     engine.pop_scope scope, 0.01
     engine.end_transaction
-    
+
     gc_stats = engine.get_stats('GC/cumulative')
     assert_equal 2, gc_stats.call_count
     assert_equal 3.0, gc_stats.total_call_time
+    assert_equal(3.0, tracer.last_sample.params[:custom_params][:gc_time])
   ensure
     GC.enable unless NewRelic::LanguageSupport.using_engine?('jruby')
   end
-  
+
   private
   def check_time_approximate(expected, actual)
     assert((expected - actual).abs < 0.1, "Expected between #{expected - 0.1} and #{expected + 0.1}, got #{actual}")

data/test/new_relic/agent/transaction_sampler_test.rb

@@ -27,9 +27,8 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
     agent.stubs(:stats_engine).returns(stats_engine)
     @sampler = NewRelic::Agent::TransactionSampler.new
     stats_engine.transaction_sampler = @sampler
-    @test_config = { 'developer_mode' => true }
+    @test_config = { :'transaction_tracer.enabled' => true }
     NewRelic::Agent.config.apply_config(@test_config)
-    @sampler.configure!
   end
 
   def teardown
@@ -65,20 +64,6 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
     assert_equal(nil, @sampler.current_sample_id)
   end
 
-  def test_enable
-    assert_equal(nil, @sampler.instance_variable_get('@disabled'))
-    @sampler.enable
-    assert_equal(false, @sampler.instance_variable_get('@disabled'))
-    assert_equal(@sampler, NewRelic::Agent.instance.stats_engine.instance_variable_get('@transaction_sampler'))
-  end
-
-  def test_disable
-    assert_nil @sampler.instance_variable_get('@disabled')
-    @sampler.disable
-    assert @sampler.instance_variable_get('@disabled')
-    assert_nil NewRelic::Agent.instance.stats_engine.instance_variable_get('@transaction_sampler')
-  end
-
   def test_sampling_rate_equals_default
     @sampler.sampling_rate = 1
     assert_equal(1, @sampler.instance_variable_get('@sampling_rate'))
@@ -94,15 +79,16 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
   end
 
   def test_notice_first_scope_push_default
-    @sampler.expects(:disabled).returns(false)
     @sampler.expects(:start_builder).with(100.0)
     @sampler.notice_first_scope_push(Time.at(100))
   end
 
   def test_notice_first_scope_push_disabled
-    @sampler.expects(:disabled).returns(true)
-    @sampler.expects(:start_builder).never
-    @sampler.notice_first_scope_push(Time.at(100))
+    with_config(:'transaction_tracer.enabled' => false,
+                :developer_mode => false) do
+      @sampler.expects(:start_builder).never
+      @sampler.notice_first_scope_push(Time.at(100))
+    end
   end
 
   def test_notice_push_scope_no_builder
@@ -209,18 +195,20 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
   end
 
   def test_store_random_sample_no_random_sampling
-    @sampler.instance_eval { @random_sampling = false }
-    assert_equal(nil, @sampler.instance_variable_get('@random_sample'))
-    @sampler.store_random_sample(mock('sample'))
-    assert_equal(nil, @sampler.instance_variable_get('@random_sample'))
+    with_config(:'transaction_tracer.random_sample' => false) do
+      assert_equal(nil, @sampler.instance_variable_get('@random_sample'))
+      @sampler.store_random_sample(mock('sample'))
+      assert_equal(nil, @sampler.instance_variable_get('@random_sample'))
+    end
   end
 
   def test_store_random_sample_random_sampling
-    @sampler.instance_eval { @random_sampling = true }
-    sample = mock('sample')
-    assert_equal(nil, @sampler.instance_variable_get('@random_sample'))
-    @sampler.store_random_sample(sample)
-    assert_equal(sample, @sampler.instance_variable_get('@random_sample'))
+    with_config(:'transaction_tracer.random_sample' => true) do
+      sample = mock('sample')
+      assert_equal(nil, @sampler.instance_variable_get('@random_sample'))
+      @sampler.store_random_sample(sample)
+      assert_equal(sample, @sampler.instance_variable_get('@random_sample'))
+    end
   end
 
   def test_store_sample_for_developer_mode_in_dev_mode
@@ -232,7 +220,6 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
 
   def test_store_sample_for_developer_mode_no_dev
     with_config(:developer_mode => false) do
-      @sampler.configure!
       sample = mock('sample')
       @sampler.store_sample_for_developer_mode(sample)
       assert_equal([], @sampler.instance_variable_get('@samples'))
@@ -305,13 +292,16 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
   end
 
   def test_notice_transaction_disabled
-    @sampler.expects(:disabled).returns(true)
-    @sampler.expects(:builder).never # since we're disabled
-    @sampler.notice_transaction('foo')
+    builder = mock('builder')
+    builder.expects(:set_transaction_info).never # since we're disabled
+    @sampler.stubs(:builder).returns(builder)
+    with_config(:'transaction_tracer.enabled' => false,
+                :developer_mode => false) do
+      @sampler.notice_transaction('foo')
+    end
   end
 
   def test_notice_transaction_no_builder
-    @sampler.expects(:disabled).returns(false)
     @sampler.expects(:builder).returns(nil).once
     @sampler.notice_transaction('foo')
   end
@@ -320,7 +310,6 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
     builder = mock('builder')
     builder.expects(:set_transaction_info).with('a path', 'a uri', {:some => :params})
     @sampler.expects(:builder).returns(builder).twice
-    @sampler.expects(:disabled).returns(false)
     @sampler.notice_transaction('a path', 'a uri', {:some => :params})
   end
 
@@ -450,8 +439,10 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
   end
 
   def test_harvest_when_disabled
-    @sampler.expects(:disabled).returns(true)
-    assert_equal([], @sampler.harvest)
+    with_config(:'transaction_tracer.enabled' => false,
+                :developer_mode => false) do
+      assert_equal([], @sampler.harvest)
+    end
   end
 
   def test_harvest_defaults
@@ -462,8 +453,7 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
       @last_sample = 'a sample'
     end
 
-    @sampler.expects(:disabled).returns(false)
-    @sampler.expects(:add_samples_to).with([], 2.0).returns([])
+    @sampler.expects(:add_samples_to).with([]).returns([])
 
     assert_equal([], @sampler.harvest)
 
@@ -476,8 +466,7 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
   def test_harvest_with_previous_samples
     with_config(:'transaction_tracer.limit_segments' => 2000) do
       sample = mock('sample')
-      @sampler.expects(:disabled).returns(false)
-      @sampler.expects(:add_samples_to).with([sample], 2.0).returns([sample])
+      @sampler.expects(:add_samples_to).with([sample]).returns([sample])
       sample.expects(:truncate).with(2000)
       assert_equal([sample], @sampler.harvest([sample]))
     end
@@ -516,16 +505,16 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
   end
 
   def test_add_random_sample_to_activated
-    @sampler.instance_eval { @random_sampling = true }
-    sample = mock('sample')
-    @sampler.instance_eval {
-      @harvest_count = 3
-      @sampling_rate = 1
-      @random_sample = sample
-    }
-    result = []
-    @sampler.add_random_sample_to(result)
-    assert_equal([sample], result, "should add the random sample to the array")
+    with_config(:'transaction_tracer.random_sample' => true, :sample_rate => 1) do
+      sample = mock('sample')
+      @sampler.instance_eval {
+        @harvest_count = 3
+        @random_sample = sample
+      }
+      result = []
+      @sampler.add_random_sample_to(result)
+      assert_equal([sample], result, "should add the random sample to the array")
+    end
   end
 
   def test_add_random_sample_to_sampling_rate_zero
@@ -543,10 +532,9 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
 
   def test_add_samples_to_no_data
     result = []
-    slow_threshold = 2.0
     @sampler.instance_eval { @slowest_sample = nil }
     @sampler.expects(:add_random_sample_to).with([])
-    assert_equal([], @sampler.add_samples_to(result, slow_threshold))
+    assert_equal([], @sampler.add_samples_to(result))
   end
 
   def test_add_samples_to_one_result
@@ -554,30 +542,31 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
     sample.expects(:duration).returns(1).at_least_once
     sample.stubs(:force_persist).returns(false)
     result = [sample]
-    slow_threshold = 2.0
     @sampler.instance_eval { @slowest_sample = nil }
     @sampler.expects(:add_random_sample_to).with([sample])
-    assert_equal([sample], @sampler.add_samples_to(result, slow_threshold))
+    assert_equal([sample], @sampler.add_samples_to(result))
   end
 
   def test_add_samples_to_adding_slowest
     sample = mock('sample')
     sample.expects(:duration).returns(2.5).at_least_once
     result = []
-    slow_threshold = 2.0
-    @sampler.instance_eval { @slowest_sample = sample }
+    @sampler.instance_variable_set(:@slowest_sample, sample)
     @sampler.expects(:add_random_sample_to).with([sample])
-    assert_equal([sample], @sampler.add_samples_to(result, slow_threshold))
+    with_config(:'transaction_tracer.transaction_threshold' => 2) do
+      assert_equal([sample], @sampler.add_samples_to(result))
+    end
   end
 
   def test_add_samples_to_under_threshold
     result = []
-    slow_threshold = 2.0
     sample = mock('sample')
     sample.expects(:duration).returns(1.0).at_least_once
     @sampler.instance_eval { @slowest_sample = sample }
     @sampler.expects(:add_random_sample_to).with([])
-    assert_equal([], @sampler.add_samples_to(result, slow_threshold))
+    with_config(:'transaction_tracer.transaction_threshold' => 2.0) do
+      assert_equal([], @sampler.add_samples_to(result))
+    end
   end
 
   def test_add_samples_to_two_sample_enter_one_sample_leave
@@ -587,69 +576,72 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
     faster_sample.expects(:duration).returns(5.0).at_least_once
     faster_sample.stubs(:force_persist).returns(false)
     result = [faster_sample]
-    slow_threshold = 2.0
     @sampler.instance_eval { @slowest_sample = slower_sample }
     @sampler.expects(:add_random_sample_to).with([slower_sample])
-    assert_equal([slower_sample], @sampler.add_samples_to(result, slow_threshold))
+    assert_equal([slower_sample], @sampler.add_samples_to(result))
   end
 
   def test_add_samples_to_keep_older_slower_sample
     slower_sample = mock('slower')
     slower_sample.expects(:duration).returns(10.0).at_least_once
     slower_sample.stubs(:force_persist).returns(false)
-    
+
     faster_sample = mock('faster')
     faster_sample.expects(:duration).returns(5.0).at_least_once
     result = [slower_sample]
-    slow_threshold = 2.0
     @sampler.instance_eval { @slowest_sample = faster_sample }
     @sampler.expects(:add_random_sample_to).with([slower_sample])
-    assert_equal([slower_sample], @sampler.add_samples_to(result, slow_threshold))
+    assert_equal([slower_sample], @sampler.add_samples_to(result))
   end
-    
+
   def test_keep_force_persist
     sample1 = mock('regular')
     sample1.stubs(:duration).returns(10)
     sample1.stubs(:force_persist).returns(false)
-    
+
     sample2 = mock('force_persist')
     sample2.stubs(:duration).returns(1)
     sample2.stubs(:force_persist).returns(true)
-    
-    result = @sampler.add_samples_to([sample1,sample2], 2.0)
-    
+
+    result = @sampler.add_samples_to([sample1,sample2])
+
     assert_equal 2, result.length
     assert_equal sample1, result[0]
     assert_equal sample2, result[1]
-  end  
+  end
 
   def test_start_builder_default
     Thread.current[:record_tt] = true
-    @sampler.expects(:disabled).returns(false)
     NewRelic::Agent.expects(:is_execution_traced?).returns(true)
     @sampler.send(:start_builder)
-    assert(Thread.current[:transaction_sample_builder].is_a?(NewRelic::Agent::TransactionSampleBuilder), "should set up a new builder by default")
+    assert(Thread.current[:transaction_sample_builder] \
+             .is_a?(NewRelic::Agent::TransactionSampleBuilder),
+           "should set up a new builder by default")
   end
 
   def test_start_builder_disabled
     Thread.current[:transaction_sample_builder] = 'not nil.'
-    @sampler.expects(:disabled).returns(true)
-    @sampler.send(:start_builder)
-    assert_equal(nil, Thread.current[:transaction_sample_builder], "should clear the transaction builder when disabled")
+    with_config(:'transaction_tracer.enabled' => false,
+                :developer_mode => false) do
+      @sampler.send(:start_builder)
+      assert_equal(nil, Thread.current[:transaction_sample_builder],
+                   "should clear the transaction builder when disabled")
+    end
   end
 
   def test_start_builder_dont_replace_existing_builder
     fake_builder = mock('transaction sample builder')
     Thread.current[:transaction_sample_builder] = fake_builder
-    @sampler.expects(:disabled).returns(false)
     @sampler.send(:start_builder)
-    assert_equal(fake_builder, Thread.current[:transaction_sample_builder], "should not overwrite an existing transaction sample builder")
+    assert_equal(fake_builder, Thread.current[:transaction_sample_builder],
+                 "should not overwrite an existing transaction sample builder")
     Thread.current[:transaction_sample_builder] = nil
   end
 
   def test_builder
     Thread.current[:transaction_sample_builder] = 'shamalamadingdong, brother.'
-    assert_equal('shamalamadingdong, brother.', @sampler.send(:builder), 'should return the value from the thread local variable')
+    assert_equal('shamalamadingdong, brother.', @sampler.send(:builder),
+                 'should return the value from the thread local variable')
     Thread.current[:transaction_sample_builder] = nil
   end
 
@@ -691,9 +683,10 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
 
     @sampler.notice_pop_scope "a"
     @sampler.notice_scope_empty
-    sample = @sampler.harvest([],0.0).first
-    assert_equal "ROOT{a{b,c{d}}}", sample.to_s_compact
-
+    with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
+      sample = @sampler.harvest([]).first
+      assert_equal "ROOT{a{b,c{d}}}", sample.to_s_compact
+    end
   end
 
   def test_sample__gc_stats
@@ -718,8 +711,10 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
     @sampler.notice_pop_scope "a"
     @sampler.notice_scope_empty
 
-    sample = @sampler.harvest([],0.0).first
-    assert_equal "ROOT{a{b,c{d}}}", sample.to_s_compact
+    with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
+      sample = @sampler.harvest([]).first
+      assert_equal "ROOT{a{b,c{d}}}", sample.to_s_compact
+    end
   ensure
     MockGCStats.mock_values = []
   end
@@ -741,25 +736,29 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
     run_sample_trace
     run_sample_trace
 
-    slowest = @sampler.harvest(nil, 0)[0]
-    first_duration = slowest.duration
-    assert((first_duration >= 0.1),
-           "expected sample duration >= 0.1, but was: #{slowest.duration.inspect}")
+    with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
+      slowest = @sampler.harvest(nil)[0]
+      first_duration = slowest.duration
+      assert((first_duration >= 0.1),
+             "expected sample duration >= 0.1, but was: #{slowest.duration.inspect}")
 
-    run_sample_trace { sleep 0.0001 }
-    not_as_slow = @sampler.harvest(slowest, 0)[0]
-    assert((not_as_slow == slowest), "Should re-harvest the same transaction since it should be slower than the new transaction - expected #{slowest.inspect} but got #{not_as_slow.inspect}")
+      run_sample_trace { sleep 0.0001 }
+      not_as_slow = @sampler.harvest(slowest)[0]
+      assert((not_as_slow == slowest), "Should re-harvest the same transaction since it should be slower than the new transaction - expected #{slowest.inspect} but got #{not_as_slow.inspect}")
 
-    run_sample_trace { sleep(first_duration + 0.1) }
+      run_sample_trace { sleep(first_duration + 0.1) }
 
-    new_slowest = @sampler.harvest(slowest, 0)[0]
-    assert((new_slowest != slowest), "Should not harvest the same trace since the new one should be slower")
-    assert((new_slowest.duration >= first_duration + 0.1), "Slowest duration must be >= #{first_duration + 0.1}, but was: #{new_slowest.duration.inspect}")
+      new_slowest = @sampler.harvest(slowest)[0]
+      assert((new_slowest != slowest), "Should not harvest the same trace since the new one should be slower")
+      assert((new_slowest.duration >= first_duration + 0.1), "Slowest duration must be >= #{first_duration + 0.1}, but was: #{new_slowest.duration.inspect}")
+    end
   end
 
   def test_prepare_to_send
     run_sample_trace { sleep 0.002 }
-    sample = @sampler.harvest(nil, 0)[0]
+    sample = with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
+      @sampler.harvest(nil)[0]
+    end
 
     ready_to_send = sample.prepare_to_send
     assert sample.duration == ready_to_send.duration
@@ -804,8 +803,10 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
     @sampler.notice_scope_empty
 
     assert_equal 0, @sampler.scope_depth
-    sample = @sampler.harvest(nil, 0.0).first
-    assert_equal "ROOT{a}", sample.to_s_compact
+    with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
+      sample = @sampler.harvest(nil).first
+      assert_equal "ROOT{a}", sample.to_s_compact
+    end
   end
 
   def test_double_scope_stack_empty
@@ -818,7 +819,9 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
     @sampler.notice_scope_empty
     @sampler.notice_scope_empty
 
-    assert_not_nil @sampler.harvest(nil, 0)[0]
+    with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
+      assert_not_nil @sampler.harvest(nil)[0]
+    end
   end
 
 
@@ -844,7 +847,7 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
       assert segment[:backtrace]
     end
   end
-  
+
   def test_stack_trace__scope
     with_config(:'transaction_tracer.stack_trace_threshold' => 0) do
       t = Time.now
@@ -907,7 +910,9 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
         @sampler.notice_transaction('/path', nil, {:param => 'hi'})
         @sampler.notice_scope_empty
 
-        tt = @sampler.harvest(nil,0)[0]
+        tt = with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
+          @sampler.harvest(nil)[0]
+        end
 
         assert_equal (capture) ? 1 : 0, tt.params[:request_params].length
       end
@@ -916,7 +921,6 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
 
   def test_should_not_collect_segments_beyond_limit
     with_config(:'transaction_tracer.limit_segments' => 3) do
-      @sampler.configure!
       run_sample_trace do
         @sampler.notice_push_scope 'a1'
         @sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'hallah'", nil, 0)