newrelic_rpm 3.4.1 → 3.4.2.beta1

data/test/new_relic/agent/error_collector/notice_error_test.rb

@@ -57,47 +57,51 @@ class NewRelic::Agent::ErrorCollector::NoticeErrorTest < Test::Unit::TestCase
   end
 
   def test_request_params_from_opts_positive
-    fake_control = mock('control')
-    self.expects(:control).returns(fake_control)
-    fake_control.expects(:capture_params).returns(true)
-    val = {:request_params => 'foo'}
-    assert_equal('foo', request_params_from_opts(val))
-    assert_equal({}, val, "should delete request_params key from hash")
+    with_config(:capture_params => true) do
+      val = {:request_params => 'foo'}
+      assert_equal('foo', request_params_from_opts(val))
+      assert_equal({}, val, "should delete request_params key from hash")
+    end
   end
 
   def test_request_params_from_opts_negative
-    fake_control = mock('control')
-    self.expects(:control).returns(fake_control)
-    fake_control.expects(:capture_params).returns(false)
-    val = {:request_params => 'foo'}
-    assert_equal(nil, request_params_from_opts(val))
-    assert_equal({}, val, "should delete request_params key from hash")
+    with_config(:capture_params => false) do
+      val = {:request_params => 'foo'}
+      assert_equal(nil, request_params_from_opts(val))
+      assert_equal({}, val, "should delete request_params key from hash")
+    end
   end
 
   def test_normalized_request_and_custom_params_base
     self.expects(:normalize_params).with(nil).returns(nil)
     self.expects(:normalize_params).with({}).returns({})
-    fake_control = mock('control')
-    self.expects(:control).returns(fake_control)
-    fake_control.expects(:capture_params).returns(true)
-    assert_equal({:request_params => nil, :custom_params => {}}, normalized_request_and_custom_params({}))
+    with_config(:capture_params => true) do
+      assert_equal({:request_params => nil, :custom_params => {}},
+                   normalized_request_and_custom_params({}))
+    end
   end
 
   def test_extract_source_base
-    @capture_source = true
-    self.expects(:sense_method).with(nil, 'source_extract')
-    assert_equal(nil, extract_source(nil))
+    with_config(:'error_collector.capture_source' => true) do
+      error_collector = NewRelic::Agent::ErrorCollector.new
+      error_collector.expects(:sense_method).with(nil, 'source_extract')
+      assert_equal(nil, error_collector.extract_source(nil))
+    end
   end
 
   def test_extract_source_disabled
-    @capture_source = false
-    assert_equal(nil, extract_source(mock('exception')))
+    with_config(:'error_collector.capture_source' => false) do
+      error_collector = NewRelic::Agent::ErrorCollector.new
+      assert_equal(nil, error_collector.extract_source(mock('exception')))
+    end
   end
 
   def test_extract_source_with_source
-    self.expects(:sense_method).with('happy', 'source_extract').returns('THE SOURCE')
-    @capture_source = true
-    assert_equal('THE SOURCE', extract_source('happy'))
+    with_config(:'error_collector.capture_source' => true) do
+      error_collector = NewRelic::Agent::ErrorCollector.new
+      error_collector.expects(:sense_method).with('happy', 'source_extract').returns('THE SOURCE')
+      assert_equal('THE SOURCE', error_collector.extract_source('happy'))
+    end
   end
 
   def test_extract_stack_trace
@@ -160,53 +164,56 @@ class NewRelic::Agent::ErrorCollector::NoticeErrorTest < Test::Unit::TestCase
 
   def test_should_exit_notice_error_disabled
     error = mocked_error
-    @enabled = false
-    assert should_exit_notice_error?(error)
+    with_error_collector_config(:'error_collector.enabled' => false) do |error_collector|
+      assert error_collector.should_exit_notice_error?(error)
+    end
   end
 
   def test_should_exit_notice_error_nil
     error = nil
-    @enabled = true
-    self.expects(:error_is_ignored?).with(error).returns(false)
-    # we increment it for the case that someone calls
-    # NewRelic::Agent.notice_error(foo) # foo is nil
-    # (which is probably not a good idea but is the existing api)
-    self.expects(:increment_error_count!)
-    assert should_exit_notice_error?(error)
+    with_error_collector_config(:'error_collector.enabled' => true) do |error_collector|
+      error_collector.expects(:error_is_ignored?).with(error).returns(false)
+      # we increment it for the case that someone calls
+      # NewRelic::Agent.notice_error(foo) # foo is nil
+      # (which is probably not a good idea but is the existing api)
+      error_collector.expects(:increment_error_count!)
+      assert error_collector.should_exit_notice_error?(error)
+    end
   end
 
   def test_should_exit_notice_error_positive
     error = mocked_error
-    @enabled = true
-    self.expects(:error_is_ignored?).with(error).returns(true)
-    assert should_exit_notice_error?(error)
+    with_error_collector_config(:'error_collector.enabled' => true) do |error_collector|
+      error_collector.expects(:error_is_ignored?).with(error).returns(true)
+      assert error_collector.should_exit_notice_error?(error)
+    end
   end
 
   def test_should_exit_notice_error_negative
     error = mocked_error
-    @enabled = true
-    self.expects(:error_is_ignored?).with(error).returns(false)
-    self.expects(:increment_error_count!)
-    assert !should_exit_notice_error?(error)
+    with_error_collector_config(:'error_collector.enabled' => true) do |error_collector|
+      error_collector.expects(:error_is_ignored?).with(error).returns(false)
+      error_collector.expects(:increment_error_count!)
+      assert !error_collector.should_exit_notice_error?(error)
+    end
   end
 
   def test_filtered_error_positive
-    @ignore = {'an_error' => true}
-    error = mocked_error
-    error_class = mock('error class')
-    error.expects(:class).returns(error_class)
-    error_class.expects(:name).returns('an_error')
-    assert filtered_error?(error)
+    with_error_collector_config(:'error_collector.ignore_errors' => 'an_error') do |error_collector|
+      error = mocked_error
+      error_class = mock('error class')
+      error.expects(:class).returns(error_class)
+      error_class.expects(:name).returns('an_error')
+      assert error_collector.filtered_error?(error)
+    end
   end
 
   def test_filtered_error_negative
-    @ignore = {}
     error = mocked_error
     error_class = mock('error class')
     error.expects(:class).returns(error_class)
     error_class.expects(:name).returns('an_error')
-    self.expects(:filtered_by_error_filter?).with(error).returns(false)
-    assert !filtered_error?(error)
+    assert !NewRelic::Agent::ErrorCollector.new.filtered_error?(error)
   end
 
   def test_filtered_by_error_filter_empty
@@ -251,7 +258,13 @@ class NewRelic::Agent::ErrorCollector::NoticeErrorTest < Test::Unit::TestCase
 
   def mocked_control
     fake_control = mock('control')
-    self.stubs(:control).returns(fake_control)
+    NewRelic::Control.stubs(:instance).returns(fake_control)
     fake_control
   end
+
+  def with_error_collector_config(config)
+    with_config(config) do
+      yield NewRelic::Agent::ErrorCollector.new
+    end
+  end
 end

data/test/new_relic/agent/error_collector_test.rb

@@ -156,20 +156,18 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
   end
 
   def test_obfuscates_error_messages_when_high_security_is_set
-    NewRelic::Control.instance['high_security'] = true
-    
-    @error_collector.notice_error(StandardError.new("YO SQL BAD: serect * flom test where foo = 'bar'"))
-    @error_collector.notice_error(StandardError.new("YO SQL BAD: serect * flom test where foo in (1,2,3,4,5)"))
+    with_config(:high_security => true) do
+      @error_collector.notice_error(StandardError.new("YO SQL BAD: serect * flom test where foo = 'bar'"))
+      @error_collector.notice_error(StandardError.new("YO SQL BAD: serect * flom test where foo in (1,2,3,4,5)"))
 
-    old_errors = []
-    errors = @error_collector.harvest_errors([])
+      old_errors = []
+      errors = @error_collector.harvest_errors([])
 
-    assert_equal('YO SQL BAD: serect * flom test where foo = ?',
-                 errors[0].message)
-    assert_equal('YO SQL BAD: serect * flom test where foo in (?,?,?,?,?)',
-                 errors[1].message)
-    
-    NewRelic::Control.instance['high_security'] = nil
+      assert_equal('YO SQL BAD: serect * flom test where foo = ?',
+                   errors[0].message)
+      assert_equal('YO SQL BAD: serect * flom test where foo in (?,?,?,?,?)',
+                   errors[1].message)
+    end
   end
 
   private

data/test/new_relic/agent/new_relic_service_test.rb

@@ -15,6 +15,13 @@ class NewRelicServiceTest < Test::Unit::TestCase
     @http_handle.respond_to(:connect, connect_response)
   end
 
+  def test_initialize_uses_correct_license_key_settings
+    with_config(:license_key => 'abcde') do
+      service = NewRelic::Agent::NewRelicService.new
+      assert_equal 'abcde', service.instance_variable_get(:@license_key)
+    end
+  end
+
   def test_connect_sets_agent_id_and_config_data
     response = @service.connect
     assert_equal 1, response['agent_run_id']
@@ -94,9 +101,10 @@ class NewRelicServiceTest < Test::Unit::TestCase
   end
 
   def test_request_timeout
-    NewRelic::Control.instance['timeout'] = 600
-    service = NewRelic::Agent::NewRelicService.new('abcdef', @server)
-    assert_equal 600, service.request_timeout
+    with_config(:timeout => 600) do
+      service = NewRelic::Agent::NewRelicService.new('abcdef', @server)
+      assert_equal 600, service.request_timeout
+    end
   end
 
   def test_should_throw_received_errors

data/test/new_relic/agent/pipe_channel_manager_test.rb

@@ -4,6 +4,8 @@ require 'new_relic/agent/pipe_channel_manager'
 
 class NewRelic::Agent::PipeChannelManagerTest < Test::Unit::TestCase
   def setup
+    @test_config = { 'developer_mode' => true }
+    NewRelic::Agent.config.apply_config(@test_config)
     NewRelic::Agent::PipeChannelManager.listener.close_all_pipes
     NewRelic::Agent.manual_start
   end
@@ -11,26 +13,27 @@ class NewRelic::Agent::PipeChannelManagerTest < Test::Unit::TestCase
   def teardown
     NewRelic::Agent::PipeChannelManager.listener.stop
     NewRelic::Agent.shutdown
+    NewRelic::Agent.config.remove_config(@test_config)
   end
-  
+
   def test_registering_a_pipe
-    NewRelic::Agent::PipeChannelManager.listener.wake.in.expects(:<<).with('.')    
+    NewRelic::Agent::PipeChannelManager.listener.wake.in.expects(:<<).with('.')
     NewRelic::Agent::PipeChannelManager.register_report_channel(1)
     pipe = NewRelic::Agent::PipeChannelManager.channels[1]
-    
+
     assert pipe.out.kind_of?(IO)
     assert pipe.in.kind_of?(IO)
 
     NewRelic::Agent::PipeChannelManager.listener.close_all_pipes
   end
-  
+
   if NewRelic::LanguageSupport.can_fork? && !NewRelic::LanguageSupport.using_version?('1.9.1')
     def test_listener_merges_timeslice_metrics
       metric = 'Custom/test/method'
       engine = NewRelic::Agent.agent.stats_engine
       engine.get_stats_no_scope(metric).record_data_point(1.0)
-      
-      listener = start_listener_with_pipe(666)    
+
+      listener = start_listener_with_pipe(666)
 
       pid = Process.fork do
         NewRelic::Agent.after_fork
@@ -40,19 +43,19 @@ class NewRelic::Agent::PipeChannelManagerTest < Test::Unit::TestCase
       end
       Process.wait(pid)
       listener.stop
-      
-      assert_equal(3.0, engine.lookup_stats(metric).total_call_time)    
+
+      assert_equal(3.0, engine.lookup_stats(metric).total_call_time)
     end
 
     def test_listener_merges_transaction_traces
-      sampler = NewRelic::Agent.agent.transaction_sampler    
+      sampler = NewRelic::Agent.agent.transaction_sampler
       TransactionSampleTestHelper.run_sample_trace_on(sampler)
       NewRelic::Agent.agent.merge_data_from([nil, [sampler.samples], nil])
 
       assert_equal(1, NewRelic::Agent.agent.unsent_traces_size)
-      
+
       listener = start_listener_with_pipe(667)
-      
+
       pid = Process.fork do
         NewRelic::Agent.after_fork
         new_sampler = NewRelic::Agent::TransactionSampler.new
@@ -62,10 +65,10 @@ class NewRelic::Agent::PipeChannelManagerTest < Test::Unit::TestCase
       end
       Process.wait(pid)
       listener.stop
-      
+
       assert_equal(2, NewRelic::Agent.agent.unsent_traces_size)
     end
-    
+
     def test_listener_merges_error_traces
       sampler = NewRelic::Agent.agent.error_collector
       sampler.notice_error(Exception.new("message"), :uri => '/myurl/',
@@ -74,9 +77,9 @@ class NewRelic::Agent::PipeChannelManagerTest < Test::Unit::TestCase
       NewRelic::Agent.agent.merge_data_from([nil, nil, [sampler.errors]])
 
       assert_equal(1, NewRelic::Agent.agent.unsent_errors_size)
-      
+
       listener = start_listener_with_pipe(668)
-      
+
       pid = Process.fork do
         NewRelic::Agent.after_fork
         new_sampler = NewRelic::Agent::ErrorCollector.new
@@ -115,7 +118,7 @@ class NewRelic::Agent::PipeChannelManagerTest < Test::Unit::TestCase
       end
     end
   end
-  
+
   def start_listener_with_pipe(pipe_id)
     listener = NewRelic::Agent::PipeChannelManager.listener
     listener.start

data/test/new_relic/agent/rpm_agent_test.rb

@@ -34,21 +34,23 @@ class NewRelic::Agent::RpmAgentTest < Test::Unit::TestCase # ActiveSupport::Test
     end
 
     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?
-      NewRelic::Agent.shutdown
+      with_config(:agent_enabled => true) 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?
+        NewRelic::Agent.shutdown
+      end
     end
 
     should "manual_start" do
@@ -67,16 +69,16 @@ class NewRelic::Agent::RpmAgentTest < Test::Unit::TestCase # ActiveSupport::Test
     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
+      assert_equal "testjobs", NewRelic::Agent.config.app_names[0]
+      assert_equal "mailer", NewRelic::Control.instance.local_env.dispatcher_instance_id
       NewRelic::Agent.shutdown
     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
+      assert_equal "testjobs", NewRelic::Agent.config.app_names[0]
+      assert_equal "mailer", NewRelic::Control.instance.local_env.dispatcher_instance_id
       NewRelic::Agent.shutdown
     end
 

data/test/new_relic/agent/sql_sampler_test.rb

@@ -1,7 +1,6 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
 
 class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
-  
   def setup
     agent = NewRelic::Agent.instance
     stats_engine = NewRelic::Agent::StatsEngine.new
@@ -10,17 +9,17 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
     @connection = stub('ActiveRecord connection', :execute => 'result')
     NewRelic::Agent::Database.stubs(:get_connection).returns(@connection)
   end
-  
+
   def test_notice_first_scope_push
-    assert_nil @sampler.transaction_data    
+    assert_nil @sampler.transaction_data
     @sampler.notice_first_scope_push nil
     assert_not_nil @sampler.transaction_data
     @sampler.notice_scope_empty
     assert_nil @sampler.transaction_data
   end
-  
+
   def test_notice_sql_no_transaction
-    assert_nil @sampler.transaction_data    
+    assert_nil @sampler.transaction_data
     @sampler.notice_sql "select * from test", "Database/test/select", nil, 10
   end
 
@@ -33,45 +32,45 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
     assert_not_nil @sampler.transaction_data
     assert_equal 2, @sampler.transaction_data.sql_data.size
   end
-  
+
   def test_harvest_slow_sql
     data = NewRelic::Agent::TransactionSqlData.new
     data.set_transaction_info("WebTransaction/Controller/c/a", "/c/a", {},
                               'guid')
     data.sql_data.concat [
-      NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.5), 
-      NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.2), 
+      NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.5),
+      NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.2),
       NewRelic::Agent::SlowSql.new("select * from test2", "Database/test2/select", {}, 1.1)
     ]
     @sampler.harvest_slow_sql data
-      
+
     assert_equal 2, @sampler.sql_traces.size
   end
-  
+
   def test_sql_aggregation
-    sql_trace = NewRelic::Agent::SqlTrace.new("select * from test", 
+    sql_trace = NewRelic::Agent::SqlTrace.new("select * from test",
             NewRelic::Agent::SlowSql.new("select * from test",
                 "Database/test/select", {}, 1.2),
         "tx_name", "uri")
-      
+
     sql_trace.aggregate NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.5), "slowest_tx_name", "slow_uri"
     sql_trace.aggregate NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.1), "other_tx_name", "uri2"
-    
+
     assert_equal 3, sql_trace.call_count
     assert_equal "slowest_tx_name", sql_trace.path
     assert_equal "slow_uri", sql_trace.url
     assert_equal 1.5, sql_trace.max_call_time
   end
-  
+
   def test_harvest
     data = NewRelic::Agent::TransactionSqlData.new
     data.set_transaction_info("WebTransaction/Controller/c/a", "/c/a", {},
                               'guid')
-    data.sql_data.concat [NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.5), 
-                          NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.2), 
+    data.sql_data.concat [NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.5),
+                          NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.2),
                           NewRelic::Agent::SlowSql.new("select * from test2", "Database/test2/select", {}, 1.1)]
     @sampler.harvest_slow_sql data
-      
+
     sql_traces = @sampler.harvest
     assert_equal 2, sql_traces.size
   end
@@ -83,10 +82,10 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
       data.sql_data << NewRelic::Agent::SlowSql.new("select * from test#{(i+97).chr}",
                                                     "Database/test#{(i+97).chr}/select", {}, i)
     end
-    
+
     @sampler.harvest_slow_sql data
     result = @sampler.harvest
-    
+
     assert_equal(10, result.size)
     assert_equal(14, result.sort{|a,b| b.max_call_time <=> a.max_call_time}.first.total_call_time)
   end
@@ -96,13 +95,13 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
     data.set_transaction_info("WebTransaction/Controller/c/a", "/c/a", {},
                               'guid')
     queries = [
-               NewRelic::Agent::SlowSql.new("select  * from test where foo in (1, 2)  ", "Database/test/select", {}, 1.5), 
-               NewRelic::Agent::SlowSql.new("select * from test where foo in (1,2, 3 ,4,  5,6, 'snausage')", "Database/test/select", {}, 1.2), 
+               NewRelic::Agent::SlowSql.new("select  * from test where foo in (1, 2)  ", "Database/test/select", {}, 1.5),
+               NewRelic::Agent::SlowSql.new("select * from test where foo in (1,2, 3 ,4,  5,6, 'snausage')", "Database/test/select", {}, 1.2),
                NewRelic::Agent::SlowSql.new("select * from test2 where foo in (1,2)", "Database/test2/select", {}, 1.1)
               ]
     data.sql_data.concat(queries)
     @sampler.harvest_slow_sql data
-      
+
     sql_traces = @sampler.harvest
     assert_equal 2, sql_traces.size
   end
@@ -117,19 +116,19 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
     data.set_transaction_info("WebTransaction/Controller/c/a", "/c/a", {},
                               'guid')
     queries = [
-               NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.5), 
-               NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.2), 
+               NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.5),
+               NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.2),
                NewRelic::Agent::SlowSql.new("select * from test2", "Database/test2/select", {}, 1.1)
               ]
     data.sql_data.concat(queries)
-    @sampler.harvest_slow_sql data   
+    @sampler.harvest_slow_sql data
     sql_traces = @sampler.harvest
     assert_equal(["header0", "header1", "header2"],
                  sql_traces[0].params[:explain_plan][0].sort)
     assert_equal(["header0", "header1", "header2"],
                  sql_traces[1].params[:explain_plan][0].sort)
     assert_equal(["foo0", "foo1", "foo2"],
-                 sql_traces[0].params[:explain_plan][1][0].sort)    
+                 sql_traces[0].params[:explain_plan][1][0].sort)
     assert_equal(["bar0", "bar1", "bar2"],
                  sql_traces[1].params[:explain_plan][1][0].sort)
   end
@@ -145,48 +144,48 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
     assert_equal(NewRelic::Agent.instance.transaction_sampler.builder.sample.guid,
                  NewRelic::Agent.instance.sql_sampler.transaction_data.guid)
   end
-  
+
   def test_should_not_collect_explain_plans_when_disabled
-    NewRelic::Control.instance['transaction_tracer'] = { 'explain_enabled' => false }
-    data = NewRelic::Agent::TransactionSqlData.new
-    data.set_transaction_info("WebTransaction/Controller/c/a", "/c/a", {},
-                              'guid')
-    
-    queries = [
-               NewRelic::Agent::SlowSql.new("select * from test",
-                                            "Database/test/select", {}, 1.5)
-              ]
-    data.sql_data.concat(queries)
-    @sampler.harvest_slow_sql data   
-    sql_traces = @sampler.harvest
-    assert_equal(nil, sql_traces[0].params[:explain_plan])
-    NewRelic::Control.instance['transaction_tracer'] = { 'explain_enabled' => true }
+    with_config(:'transaction_tracer.explain_enabled' => false) do
+      data = NewRelic::Agent::TransactionSqlData.new
+      data.set_transaction_info("WebTransaction/Controller/c/a", "/c/a", {},
+                                'guid')
+
+      queries = [
+                 NewRelic::Agent::SlowSql.new("select * from test",
+                                              "Database/test/select", {}, 1.5)
+                ]
+      data.sql_data.concat(queries)
+      @sampler.harvest_slow_sql data
+      sql_traces = @sampler.harvest
+      assert_equal(nil, sql_traces[0].params[:explain_plan])
+    end
   end
 
   def test_sql_id_fits_in_a_mysql_int_11
-    sql_trace = NewRelic::Agent::SqlTrace.new("select * from test", 
+    sql_trace = NewRelic::Agent::SqlTrace.new("select * from test",
             NewRelic::Agent::SlowSql.new("select * from test",
                 "Database/test/select", {}, 1.2),
         "tx_name", "uri")
-    
+
     assert -2147483648 <= sql_trace.sql_id, "sql_id too small"
     assert 2147483647 >= sql_trace.sql_id, "sql_id too large"
   end
 
   def test_sends_obfuscated_queries_when_configured
-    NewRelic::Control.instance['transaction_tracer'] = { 'record_sql' => 'obfuscated' }
-    
-    data = NewRelic::Agent::TransactionSqlData.new
-    data.set_transaction_info("WebTransaction/Controller/c/a", "/c/a", {},
-                              'guid')
-    data.sql_data.concat([NewRelic::Agent::SlowSql.new("select * from test where foo = 'bar'",
-                                                       "Database/test/select", {}, 1.5), 
-                          NewRelic::Agent::SlowSql.new("select * from test where foo in (1,2,3,4,5)",
-                                                       "Database/test/select", {}, 1.2)])
-    @sampler.harvest_slow_sql(data)      
-    sql_traces = @sampler.harvest
+    with_config(:'transaction_tracer.record_sql' => 'obfuscated') do
+      data = NewRelic::Agent::TransactionSqlData.new
+      data.set_transaction_info("WebTransaction/Controller/c/a", "/c/a", {},
+                                'guid')
+      data.sql_data.concat([NewRelic::Agent::SlowSql.new("select * from test where foo = 'bar'",
+                                                         "Database/test/select", {}, 1.5),
+                            NewRelic::Agent::SlowSql.new("select * from test where foo in (1,2,3,4,5)",
+                                                         "Database/test/select", {}, 1.2)])
+      @sampler.harvest_slow_sql(data)
+      sql_traces = @sampler.harvest
 
-    assert_equal('select * from test where foo = ?', sql_traces[0].sql)
-    assert_equal('select * from test where foo in (?,?,?,?,?)', sql_traces[1].sql)        
+      assert_equal('select * from test where foo = ?', sql_traces[0].sql)
+      assert_equal('select * from test where foo in (?,?,?,?,?)', sql_traces[1].sql)
+    end
   end
 end