wd_newrelic_rpm 3.3.4.1 → 3.5.5

data/test/new_relic/agent/thread_test.rb

@@ -0,0 +1,89 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+require 'new_relic/agent/thread'
+
+class ThreadTest < Test::Unit::TestCase
+
+  def test_sets_label
+    t = NewRelic::Agent::AgentThread.new("labelled") {}
+    assert_equal "labelled", t[:newrelic_label]
+  end
+
+  def test_bucket_thread_as_agent_when_profiling
+    t = NewRelic::Agent::AgentThread.new("labelled") {}
+    assert_equal :agent, NewRelic::Agent::AgentThread.bucket_thread(t, true)
+  end
+
+  def test_bucket_thread_as_agent_when_not_profiling
+    t = NewRelic::Agent::AgentThread.new("labelled") {}
+    assert_equal :ignore, NewRelic::Agent::AgentThread.bucket_thread(t, false)
+  end
+
+  def test_bucket_thread_as_request
+    t = ::Thread.new {}
+    frame = NewRelic::Agent::Instrumentation::MetricFrame.new
+    frame.request = "has a request"
+    t[:newrelic_metric_frame] = frame
+
+    assert_equal :request, NewRelic::Agent::AgentThread.bucket_thread(t, DONT_CARE)
+  end
+
+  def test_bucket_thread_as_background
+    t = ::Thread.new {}
+    frame = NewRelic::Agent::Instrumentation::MetricFrame.new
+    t[:newrelic_metric_frame] = frame
+
+    assert_equal :background, NewRelic::Agent::AgentThread.bucket_thread(t, DONT_CARE)
+  end
+
+  def test_bucket_thread_as_other_if_nil_frame
+    t = ::Thread.new {}
+    t[:newrelic_metric_frame] = nil
+
+    assert_equal :other, NewRelic::Agent::AgentThread.bucket_thread(t, DONT_CARE)
+  end
+
+  def test_bucket_thread_as_other
+    t = ::Thread.new {}
+    assert_equal :other, NewRelic::Agent::AgentThread.bucket_thread(t, DONT_CARE)
+  end
+
+  def test_runs_block
+    called = false
+
+    t = NewRelic::Agent::AgentThread.new("labelled") { called = true }
+    t.join
+
+    assert called
+  end
+
+  TRACE = [
+      "/Users/jclark/.rbenv/versions/1.9.3-p194/lib/ruby/gems/1.9.1/gems/eventmachine-0.12.10/lib/eventmachine.rb:100:in `catch'",
+      "/Users/jclark/.rbenv/versions/1.9.3-p194/lib/ruby/gems/1.9.1/gems/newrelic_rpm-3.5.3.452.dev/lib/new_relic/agent/agent.rb:200:in `start_worker_thread'",
+      "/Users/jclark/.rbenv/versions/1.9.3-p194/lib/ruby/gems/1.9.1/gems/thin-1.5.0/lib/thin/backends/base.rb:300:in `block (3 levels) in run'",
+    ]
+
+  def test_scrubs_backtrace_when_not_profiling_agent_code
+    result = NewRelic::Agent::AgentThread.scrub_backtrace(stub(:backtrace => TRACE), false)
+    assert_equal [TRACE[0], TRACE[2]], result
+  end
+
+  def test_doesnt_scrub_backtrace_when_profiling_agent_code
+    result = NewRelic::Agent::AgentThread.scrub_backtrace(stub(:backtrace => TRACE), true)
+    assert_equal TRACE, result
+  end
+
+  def test_scrub_backtrace_handles_errors_during_backtrace
+    dummy_thread = stub
+    dummy_thread.stubs(:backtrace).raises(StandardError.new('nah'))
+    assert_nothing_raised do
+      NewRelic::Agent::AgentThread.scrub_backtrace(dummy_thread, true)
+    end
+  end
+
+  def test_scrub_backtrace_handles_nil_backtrace
+    bt = NewRelic::Agent::AgentThread.scrub_backtrace(stub(:backtrace => nil), false)
+    assert_nil(bt)
+  end
+
+  DONT_CARE = true
+end

data/test/new_relic/agent/threaded_test.rb

@@ -0,0 +1,65 @@
+class ThreadedTest < Test::Unit::TestCase
+  def setup
+    @original_thread_class = NewRelic::Agent::AgentThread
+    swap_thread_class(FakeThread)
+  end
+
+  def teardown
+    swap_thread_class(@original_thread_class)
+    @original_thread_class = nil
+
+    FakeThread.list.clear
+  end
+
+  def default_test
+    # no-op to keep quiet....
+  end
+
+  private
+
+  def swap_thread_class(klass)
+    NewRelic::Agent.send(:remove_const, "AgentThread") if NewRelic::Agent.const_defined?("AgentThread")
+    NewRelic::Agent.const_set("AgentThread", klass)
+  end
+end
+
+class FakeThread
+  @@list = []
+
+  def initialize(locals={}, &block)
+    @locals = locals
+    yield if block_given?
+  end
+
+  def self.current
+    {}
+  end
+
+  def self.list
+    @@list
+  end
+
+  def self.bucket_thread(thread, _)
+    thread[:bucket] 
+  end
+
+  def self.scrub_backtrace(thread, _)
+    thread[:scrubbed_backtrace] || thread.backtrace
+  end
+
+  def key?(key)
+    @locals.key?(key)
+  end
+
+  def [](key)
+    @locals[key]
+  end
+
+  def backtrace
+    @locals[:backtrace] || []
+  end
+
+  def join
+  end
+end
+

data/test/new_relic/agent/transaction_info_test.rb

@@ -3,11 +3,52 @@ require 'ostruct'
 
 class NewRelic::Agent::TransactionInfoTest < Test::Unit::TestCase
   def setup
-    @request = OpenStruct.new(:cookies => {'NRAGENT' => 'tk=1234<tag>evil</tag>5678'})
+    @request = OpenStruct.new(:cookies => {'NRAGENT' => 'tk=12345678'})
+    @request_with_embedded_tag = OpenStruct.new(:cookies => {'NRAGENT' => 'tk=1234<tag>evil</tag>5678'})
+    @request_with_embedded_utf8_encoded_js = OpenStruct.new(:cookies => {'NRAGENT' => "tk=1234&#34&#93&#41&#595678"})
+    @request_with_double_quotes = OpenStruct.new(:cookies => {'NRAGENT' => 'tk="""deadbeef"""'})
+    @request_with_single_quotes = OpenStruct.new(:cookies => {'NRAGENT' => "tk='''deadbeef'''"})
+    @request_with_multi_lt = OpenStruct.new(:cookies => {'NRAGENT' => 'tk=<<<deadbeef'})
+    @request_with_multi_gt = OpenStruct.new(:cookies => {'NRAGENT' => 'tk=>>>deadbeef'}) 
+    @request_with_bare_token = OpenStruct.new(:cookies => {'NRAGENT' => 0xdeadbeef})
+    @request_with_nil_token = OpenStruct.new(:cookies => {'NRAGENT' => nil})
   end
   
-  def test_get_token_gets_sanitized_token_from_cookie
-    assert_equal('1234&lt;tag&gt;evil&lt;/tag&gt;5678',
-                 NewRelic::Agent::TransactionInfo.get_token(@request))
+  def test_get_token_safe_token_returned_untouched
+    assert_equal("12345678", NewRelic::Agent::TransactionInfo.get_token(@request))
   end
+
+  def test_get_token_with_embedded_tags_sanitized
+  	assert_equal("",NewRelic::Agent::TransactionInfo.get_token(@request_with_embedded_tag))
+  end
+
+  def test_get_token_with_embedded_utf8_js_sanitized
+  	assert_equal("1234&amp;#34&amp;#93&amp;#41&amp;#595678",
+  		NewRelic::Agent::TransactionInfo.get_token(@request_with_embedded_utf8_encoded_js))	
+  end
+
+  def test_get_token_replaces_double_quoted_token_with_empty_string
+  	assert_equal("", NewRelic::Agent::TransactionInfo.get_token(@request_with_double_quotes))
+  end
+
+  def test_get_token_replaces_single_quoted_toket_with_empty_string
+  	assert_equal("", NewRelic::Agent::TransactionInfo.get_token(@request_with_single_quotes))
+  end
+
+  def test_get_token_replaces_token_started_with_multiple_Lt_with_empty_string
+  	assert_equal("", NewRelic::Agent::TransactionInfo.get_token(@request_with_multi_lt))
+  end
+
+  def test_get_token_replaces_token_started_with_multiple_gt_with_empty_string
+  	assert_equal("", NewRelic::Agent::TransactionInfo.get_token(@request_with_multi_gt))
+  end
+
+  def test_get_token_bare_value_replaced_with_nil
+  	assert_equal(nil,NewRelic::Agent::TransactionInfo.get_token(@request_with_bare_token))
+  end
+
+  def test_get_token_nil_token_returns_nil_token
+  	assert_equal(nil,NewRelic::Agent::TransactionInfo.get_token(@request_with_ni_token))
+  end
+
 end

data/test/new_relic/agent/transaction_sample_builder_test.rb

@@ -171,19 +171,20 @@ class NewRelic::Agent::TransationSampleBuilderTest < Test::Unit::TestCase
   end
   
   def test_trace_should_not_record_more_than_segment_limit
-    @builder.segment_limit = 3
-    8.times {|i| build_segment i.to_s }
-    assert_equal 3, @builder.sample.count_segments
+    with_config(:'transaction_tracer.limit_segments' => 3) do
+      8.times {|i| build_segment i.to_s }
+      assert_equal 3, @builder.sample.count_segments
+    end
   end
 
   # regression
   def test_trace_should_log_segment_reached_once
-    @builder.segment_limit = 3
-    NewRelic::Control.instance.log.expects(:debug).once
-    8.times {|i| build_segment i.to_s }
+    with_config(:'transaction_tracer.limit_segments' => 3) do
+      expects_logging(:debug, includes("Segment limit"))
+      8.times {|i| build_segment i.to_s }
+    end
   end
   
-  
   def validate_builder(check_names = true)
     validate_segment @builder.sample.root_segment, check_names
   end

data/test/new_relic/agent/transaction_sampler_test.rb

@@ -27,11 +27,14 @@ 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 = { :'transaction_tracer.enabled' => true }
+    NewRelic::Agent.config.apply_config(@test_config)
   end
 
   def teardown
     super
     Thread.current[:transaction_sample_builder] = nil
+    NewRelic::Agent.config.remove_config(@test_config)
   end
 
   def test_initialize
@@ -45,27 +48,10 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
       assert_equal(default_value, @sampler.instance_variable_get('@' + variable.to_s))
     end
 
-    segment_limit = @sampler.instance_variable_get('@segment_limit')
-    assert(segment_limit.is_a?(Numeric), "Segment limit should be numeric")
-    assert(segment_limit > 0, "Segment limit should be above zero")
-
-    stack_trace_threshold = @sampler.instance_variable_get('@stack_trace_threshold')
-    assert(stack_trace_threshold.is_a?((0.1).class), "Stack trace threshold should be a #{(0.1).class.inspect}, but is #{stack_trace_threshold.inspect}")
-    assert(stack_trace_threshold > 0.0, "Stack trace threshold should be above zero")
-
     lock = @sampler.instance_variable_get('@samples_lock')
     assert(lock.is_a?(Mutex), "Samples lock should be a mutex, is: #{lock.inspect}")
   end
 
-  def test_configure
-    control = NewRelic::Control.instance
-    control.merge_options('transaction_tracer' => {'stack_trace_threshold' => 5.0, 'limit_segments' => 20, 'explain_threshold' => 4.0})
-    @sampler.configure!
-    assert_equal 20, @sampler.instance_variable_get('@segment_limit')
-    assert_equal 5.0, @sampler.instance_variable_get('@stack_trace_threshold')
-    assert_equal 4.0, @sampler.instance_variable_get('@explain_threshold')
-  end
-
   def test_current_sample_id_default
     builder = mock('builder')
     builder.expects(:sample_id).returns(11111)
@@ -78,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'))
@@ -107,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
@@ -124,17 +97,15 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
   end
 
   def test_notice_push_scope_with_builder
-    NewRelic::Control.instance.expects(:developer_mode?).returns(false)
-    builder = mock('builder')
-    builder.expects(:trace_entry).with('a scope', 100.0)
-    @sampler.expects(:builder).returns(builder).twice
-
-    @sampler.notice_push_scope('a scope', Time.at(100))
+    with_config(:developer_mode => false) do
+      builder = mock('builder')
+      builder.expects(:trace_entry).with('a scope', 100.0)
+      @sampler.expects(:builder).returns(builder).twice
+      @sampler.notice_push_scope('a scope', Time.at(100))
+    end
   end
 
   def test_notice_push_scope_in_dev_mode
-    NewRelic::Control.instance.expects(:developer_mode?).returns(true)
-
     builder = mock('builder')
     builder.expects(:trace_entry).with('a scope', 100.0)
     @sampler.expects(:builder).returns(builder).twice
@@ -224,22 +195,23 @@ 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
-    NewRelic::Control.instance.expects(:developer_mode?).returns(true)
     sample = mock('sample')
     @sampler.expects(:truncate_samples)
     @sampler.store_sample_for_developer_mode(sample)
@@ -247,11 +219,11 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
   end
 
   def test_store_sample_for_developer_mode_no_dev
-    NewRelic::Control.instance.stubs(:developer_mode?).returns(false)
-    @sampler.configure!
-    sample = mock('sample')
-    @sampler.store_sample_for_developer_mode(sample)
-    assert_equal([], @sampler.instance_variable_get('@samples'))
+    with_config(:developer_mode => false) do
+      sample = mock('sample')
+      @sampler.store_sample_for_developer_mode(sample)
+      assert_equal([], @sampler.instance_variable_get('@samples'))
+    end
   end
 
   def test_store_slowest_sample_new_is_slowest
@@ -320,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
@@ -335,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
 
@@ -430,19 +404,21 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
   end
 
   def test_append_backtrace_under_duration
-    @sampler.instance_eval { @stack_trace_threshold = 2.0 }
-    segment = mock('segment')
-    segment.expects(:[]=).with(:backtrace, any_parameters).never
-    @sampler.append_backtrace(mock('segment'), 1.0)
+    with_config(:'transaction_tracer.stack_trace_threshold' => 2.0) do
+      segment = mock('segment')
+      segment.expects(:[]=).with(:backtrace, any_parameters).never
+      @sampler.append_backtrace(mock('segment'), 1.0)
+    end
   end
 
   def test_append_backtrace_over_duration
-    @sampler.instance_eval { @stack_trace_threshold = 2.0 }
-    segment = mock('segment')
-    # note the mocha expectation matcher - you can't hardcode a
-    # backtrace so we match on any string, which should be okay.
-    segment.expects(:[]=).with(:backtrace, instance_of(String))
-    @sampler.append_backtrace(segment, 2.5)
+    with_config(:'transaction_tracer.stack_trace_threshold' => 2.0) do
+      segment = mock('segment')
+      # note the mocha expectation matcher - you can't hardcode a
+      # backtrace so we match on any string, which should be okay.
+      segment.expects(:[]=).with(:backtrace, instance_of(String))
+      @sampler.append_backtrace(segment, 2.5)
+    end
   end
 
   def test_notice_sql_recording_sql
@@ -463,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
@@ -475,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)
 
@@ -487,12 +464,12 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
   end
 
   def test_harvest_with_previous_samples
-    sample = mock('sample')
-    @sampler.expects(:disabled).returns(false)
-    @sampler.expects(:add_samples_to).with([sample], 2.0).returns([sample])
-    @sampler.instance_eval { @segment_limit = 2000 }
-    sample.expects(:truncate).with(2000)
-    assert_equal([sample], @sampler.harvest([sample]))
+    with_config(:'transaction_tracer.limit_segments' => 2000) do
+      sample = mock('sample')
+      @sampler.expects(:add_samples_to).with([sample]).returns([sample])
+      sample.expects(:truncate).with(2000)
+      assert_equal([sample], @sampler.harvest([sample]))
+    end
   end
 
   def test_add_random_sample_to_not_random_sampling
@@ -528,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
@@ -555,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
@@ -566,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
@@ -599,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
 
@@ -703,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
@@ -730,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
@@ -747,31 +730,38 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
   # sample traces, for example. It's unfortunate, but we can't
   # reliably turn off GC on all versions of ruby under test
   def test_harvest_slowest
-    run_sample_trace
-    run_sample_trace
-    run_sample_trace { sleep 0.1 }
-    run_sample_trace
-    run_sample_trace
-
-    slowest = @sampler.harvest(nil, 0)[0]
-    assert((slowest.duration >= 0.09), "expected sample duration >= 0.09, but was: #{slowest.duration.inspect}")
-    # this assert is here to make sure the test remains valid
-    assert((slowest.duration <= 0.15), "expected sample duration <= 0.15, 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.16 }
-    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 >= 0.15), "Slowest duration must be >= 0.15, but was: #{new_slowest.duration.inspect}")
+    run_sample_trace(0,0.1)
+    run_sample_trace(0,0.1)
+    # two second duration
+    run_sample_trace(0,2)
+    run_sample_trace(0,0.1)
+    run_sample_trace(0,0.1)
+
+    with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
+
+      slowest = @sampler.harvest(nil)[0]
+      first_duration = slowest.duration
+      assert((first_duration.round >= 2),
+             "expected sample duration = 2, but was: #{slowest.duration.inspect}")
+
+      # 1 second duration
+      run_sample_trace(0,1)
+      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(0,10)
+
+      new_slowest = @sampler.harvest(slowest)[0]
+      assert((new_slowest != slowest), "Should not harvest the same trace since the new one should be slower")
+      assert_equal(new_slowest.duration.round, 10, "Slowest duration must be = 10, 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
@@ -816,8 +806,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
@@ -830,7 +822,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
 
 
@@ -847,39 +841,36 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
   end
 
   def test_stack_trace__sql
-    @sampler.stack_trace_threshold = 0
-
-    @sampler.notice_first_scope_push Time.now.to_f
-
-    @sampler.notice_sql("test", nil, 1)
-
-    segment = @sampler.send(:builder).current_segment
+    with_config(:'transaction_tracer.stack_trace_threshold' => 0) do
+      @sampler.notice_first_scope_push Time.now.to_f
+      @sampler.notice_sql("test", nil, 1)
+      segment = @sampler.send(:builder).current_segment
 
-    assert segment[:sql]
-    assert segment[:backtrace]
+      assert segment[:sql]
+      assert segment[:backtrace]
+    end
   end
-  
+
   def test_stack_trace__scope
-    @sampler.stack_trace_threshold = 0
-    t = Time.now
-    @sampler.notice_first_scope_push t.to_f
-    @sampler.notice_push_scope 'Bill', (t+1).to_f
+    with_config(:'transaction_tracer.stack_trace_threshold' => 0) do
+      t = Time.now
+      @sampler.notice_first_scope_push t.to_f
+      @sampler.notice_push_scope 'Bill', (t+1).to_f
 
-    segment = @sampler.send(:builder).current_segment
-    assert segment[:backtrace]
+      segment = @sampler.send(:builder).current_segment
+      assert segment[:backtrace]
+    end
   end
 
   def test_nil_stacktrace
-    @sampler.stack_trace_threshold = 2
-
-    @sampler.notice_first_scope_push Time.now.to_f
-
-    @sampler.notice_sql("test", nil, 1)
-
-    segment = @sampler.send(:builder).current_segment
+    with_config(:'transaction_tracer.stack_trace_threshold' => 2) do
+      @sampler.notice_first_scope_push Time.now.to_f
+      @sampler.notice_sql("test", nil, 1)
+      segment = @sampler.send(:builder).current_segment
 
-    assert segment[:sql]
-    assert_nil segment[:backtrace]
+      assert segment[:sql]
+      assert_nil segment[:backtrace]
+    end
   end
 
   def test_big_sql
@@ -917,40 +908,38 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
 
   def test_param_capture
     [true, false].each do |capture|
-      NewRelic::Control.instance.stubs(:capture_params).returns(capture)
-      @sampler.notice_first_scope_push Time.now.to_f
-      @sampler.notice_transaction('/path', nil, {:param => 'hi'})
-      @sampler.notice_scope_empty
+      with_config(:capture_params => capture) do
+        @sampler.notice_first_scope_push Time.now.to_f
+        @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
+        assert_equal (capture) ? 1 : 0, tt.params[:request_params].length
+      end
     end
   end
-  
+
   def test_should_not_collect_segments_beyond_limit
-    NewRelic::Control.instance.merge_options('transaction_tracer' => {
-                                               'limit_segments' => 3,
-                                             })
-    @sampler.configure!
-    run_sample_trace do
-      @sampler.notice_push_scope 'a1'
-      @sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'hallah'", nil, 0)
-      @sampler.notice_push_scope 'a11'
-      @sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'semolina'", nil, 0)
-      @sampler.notice_pop_scope "a11"
-      @sampler.notice_pop_scope "a1"
-    end
-    assert_equal 3, @sampler.samples[0].count_segments
-    NewRelic::Control.instance.merge_options('transaction_tracer' => {
-                                               'limit_segments' => 4000,
-                                             })
-  end
-  
+    with_config(:'transaction_tracer.limit_segments' => 3) do
+      run_sample_trace do
+        @sampler.notice_push_scope 'a1'
+        @sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'hallah'", nil, 0)
+        @sampler.notice_push_scope 'a11'
+        @sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'semolina'", nil, 0)
+        @sampler.notice_pop_scope "a11"
+        @sampler.notice_pop_scope "a1"
+      end
+      assert_equal 3, @sampler.samples[0].count_segments
+    end
+  end
+
   private
-  
-  def run_sample_trace
-    @sampler.notice_first_scope_push Time.now.to_f
+
+  def run_sample_trace(start = Time.now.to_f, stop = nil)
+    @sampler.notice_first_scope_push start
     @sampler.notice_transaction '/path', nil, {}
     @sampler.notice_push_scope "a"
     @sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'wheat'", nil, 0)
@@ -962,6 +951,6 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
     @sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'french'", nil, 0)
     @sampler.notice_pop_scope "ac"
     @sampler.notice_pop_scope "a"
-    @sampler.notice_scope_empty
+    @sampler.notice_scope_empty stop || Time.now.to_f
   end
 end