wd_newrelic_rpm 3.3.4.1 → 3.5.5

data/test/new_relic/agent/pipe_channel_manager_test.rb

@@ -0,0 +1,131 @@
+require 'timeout'
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
+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
+
+  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.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)
+
+      pid = Process.fork do
+        NewRelic::Agent.after_fork
+        new_engine = NewRelic::Agent::StatsEngine.new
+        new_engine.get_stats_no_scope(metric).record_data_point(2.0)
+        listener.pipes[666].write(:stats => new_engine.harvest_timeslice_data({}, {}))
+      end
+      Process.wait(pid)
+      listener.stop
+
+      assert_equal(3.0, engine.lookup_stats(metric).total_call_time)
+      engine.reset_stats
+    end
+
+    def test_listener_merges_transaction_traces
+      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
+        sample = TransactionSampleTestHelper.run_sample_trace_on(new_sampler)
+        new_sampler.store_force_persist(sample)
+        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
+
+      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/',
+                           :metric => 'path', :referer => 'test_referer',
+                           :request_params => {:x => 'y'})
+      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
+        new_sampler.notice_error(Exception.new("new message"), :uri => '/myurl/',
+                                 :metric => 'path', :referer => 'test_referer',
+                                 :request_params => {:x => 'y'})
+        listener.pipes[668].write(:error_traces => new_sampler.harvest_errors([]))
+      end
+      Process.wait(pid)
+      listener.stop
+
+      assert_equal(2, NewRelic::Agent.agent.unsent_errors_size)
+    end
+
+    def test_close_pipe_on_EOF_string
+      listener = start_listener_with_pipe(669)
+
+      pid = Process.fork do
+        listener.pipes[669].write('EOF')
+      end
+      Process.wait(pid)
+      listener.stop
+
+      assert(!NewRelic::Agent::PipeChannelManager.channels[669] ||
+             NewRelic::Agent::PipeChannelManager.channels[669].closed?)
+    end
+
+    def test_manager_does_not_crash_when_given_bad_data
+      listener = start_listener_with_pipe(670)
+      assert_nothing_raised do
+        pid = Process.fork do
+          listener.pipes[670].in << 'some unloadable garbage'
+        end
+        Process.wait(pid)
+        listener.stop
+      end
+    end
+  end
+
+  def start_listener_with_pipe(pipe_id)
+    listener = NewRelic::Agent::PipeChannelManager.listener
+    listener.start
+    listener.register_pipe(pipe_id)
+    listener
+  end
+end

data/test/new_relic/agent/pipe_service_test.rb

@@ -0,0 +1,113 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
+
+class PipeServiceTest < Test::Unit::TestCase
+  def setup
+    NewRelic::Agent::PipeChannelManager.listener.stop    
+    NewRelic::Agent::PipeChannelManager.register_report_channel(:pipe_service_test)
+    @service = NewRelic::Agent::PipeService.new(:pipe_service_test)
+  end
+  
+  def test_constructor
+    assert_equal :pipe_service_test, @service.channel_id
+  end
+  
+  def test_connect_returns_nil
+    assert_nil @service.connect({}) 
+  end
+  
+  if NewRelic::LanguageSupport.can_fork? &&
+      !NewRelic::LanguageSupport.using_version?('1.9.1')
+
+    def test_metric_data
+      received_data = data_from_forked_process do
+        metric_data0 = generate_metric_data('Custom/something')
+        @service.metric_data(0.0, 0.1, metric_data0)
+      end
+
+      assert_equal 'Custom/something', received_data[:stats].keys.sort[0].name
+    end
+
+    def test_transaction_sample_data
+      received_data = data_from_forked_process do
+        @service.transaction_sample_data(['txn'])
+      end
+
+      assert_equal ['txn'], received_data[:transaction_traces]
+    end
+
+    def test_error_data
+      received_data = data_from_forked_process do
+        @service.error_data(['err'])
+      end
+      assert_equal ['err'], received_data[:error_traces]
+    end
+
+    def test_sql_trace_data
+      received_data = data_from_forked_process do
+        @service.sql_trace_data(['sql'])
+      end
+      assert_equal ['sql'], received_data[:sql_traces]
+    end
+
+    def test_multiple_writes_to_pipe
+      pid = Process.fork do
+        metric_data0 = generate_metric_data('Custom/something')
+        @service.metric_data(0.0, 0.1, metric_data0)
+        @service.transaction_sample_data(['txn0'])
+        @service.error_data(['err0'])
+        @service.sql_trace_data(['sql0'])      
+        @service.shutdown(Time.now)
+      end
+      Process.wait(pid)
+      
+      received_data = read_from_pipe
+      
+      assert_equal 'Custom/something', received_data[:stats].keys.sort[0].name
+      assert_equal ['txn0'], received_data[:transaction_traces]
+      assert_equal ['err0'], received_data[:error_traces].sort
+    end
+
+    def test_shutdown_sends_EOF
+      received_data = data_from_forked_process do
+        @service.shutdown(Time.now)
+      end
+      assert_equal 'EOF', received_data[:EOF]
+    end
+    
+    def test_shutdown_closes_pipe
+      data_from_forked_process do
+        @service.shutdown(Time.now)
+        assert NewRelic::Agent::PipeChannelManager \
+          .channels[:pipe_service_test].closed?
+      end
+    end
+  end
+  
+  def generate_metric_data(metric_name, data=1.0)
+    engine = NewRelic::Agent::StatsEngine.new
+    engine.get_stats_no_scope(metric_name).record_data_point(data)
+    engine.harvest_timeslice_data({}, {}).values
+  end
+
+  def read_from_pipe
+    pipe = NewRelic::Agent::PipeChannelManager.channels[:pipe_service_test]
+    pipe.in.close
+    data = {}
+    while payload = pipe.out.gets("\n\n")
+      got = Marshal.load(payload)
+      if got == 'EOF'
+        got = {:EOF => 'EOF'}
+      end
+      data.merge!(got)
+    end
+    data
+  end
+
+  def data_from_forked_process
+    pid = Process.fork do
+      yield
+    end
+    Process.wait(pid)
+    read_from_pipe
+  end
+end

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,26 +69,30 @@ 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
 
     should "send_timeslice_data" do
       # this test fails due to a rubinius bug
       return if NewRelic::LanguageSupport.using_engine?('rbx')
-      @agent.expects(:invoke_remote).returns({NewRelic::MetricSpec.new("/A/b/c") => 1, NewRelic::MetricSpec.new("/A/b/c", "/X") => 2, NewRelic::MetricSpec.new("/A/b/d") => 3 }.to_a)
+      @agent.service = NewRelic::FakeService.new
+      @agent.service.expects(:metric_data).returns([ [{'name' => '/A/b/c'}, 1],
+                                                     [{'name' => '/A/b/c', 'scope' => '/X'}, 2],
+                                                     [{'name' => '/A/b/d'}, 3] ])
       @agent.send :harvest_and_send_timeslice_data
       assert_equal 3, @agent.metric_ids.size
-      assert_equal 3, @agent.metric_ids[NewRelic::MetricSpec.new("/A/b/d") ], @agent.metric_ids.inspect
+      assert_equal(3, @agent.metric_ids[NewRelic::MetricSpec.new('/A/b/d')],
+                   @agent.metric_ids.inspect)
     end
     should "set_record_sql" do
       @agent.set_record_sql(false)
@@ -106,34 +112,6 @@ class NewRelic::Agent::RpmAgentTest < Test::Unit::TestCase # ActiveSupport::Test
       assert_match /\d\.\d+\.\d+/, NewRelic::VERSION::STRING
     end
 
-    should "invoke_remote__ignore_non_200_results" do
-      NewRelic::Agent::Agent.class_eval do
-        public :invoke_remote
-      end
-      response_mock = mock()
-      Net::HTTP.any_instance.stubs(:request).returns(response_mock)
-      response_mock.stubs(:message).returns("bogus error")
-
-      for code in %w[500 504 400 302 503] do
-        assert_raise NewRelic::Agent::ServerConnectionException, "Ignore #{code}" do
-          response_mock.stubs(:code).returns(code)
-          NewRelic::Agent.agent.invoke_remote  :get_data_report_period, 0
-        end
-      end
-    end
-    should "invoke_remote__throw_other_errors" do
-      NewRelic::Agent::Agent.class_eval do
-        public :invoke_remote
-      end
-      response_mock = Net::HTTPSuccess.new  nil, nil, nil
-      response_mock.stubs(:body).returns("")
-      Marshal.stubs(:load).raises(RuntimeError, "marshal issue")
-      Net::HTTP.any_instance.stubs(:request).returns(response_mock)
-      assert_raise RuntimeError do
-        NewRelic::Agent.agent.invoke_remote  :get_data_report_period, 0xFEFE
-      end
-    end
-
     context "with transaction api" do
       should "reject empty arguments" do
         assert_raises RuntimeError do
@@ -143,7 +121,6 @@ class NewRelic::Agent::RpmAgentTest < Test::Unit::TestCase # ActiveSupport::Test
       should "record a transaction" do
         NewRelic::Agent.record_transaction 0.5, 'uri' => "/users/create?foo=bar"
       end
-
     end
   end
 end

data/test/new_relic/agent/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,74 @@ 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)
+    end
+  end
 
-    assert_equal('select * from test where foo = ?', sql_traces[0].sql)
-    assert_equal('select * from test where foo in (?,?,?,?,?)', sql_traces[1].sql)        
+  def test_to_collector_array
+    with_config(:'transaction_tracer.explain_enabled' => false) 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",
+                                                         "Database/test/select",
+                                                         {}, 1.5)])
+      @sampler.harvest_slow_sql(data)
+      sql_traces = @sampler.harvest
+
+      params = RUBY_VERSION >= '1.9.2' ? "eJyrrgUAAXUA+Q==\n" : {}
+      expected = [ 'WebTransaction/Controller/c/a', '/c/a', 526336943,
+                   'select * from test', 'Database/test/select',
+                   1, 1500, 1500, 1500, params ]
+
+      if NewRelic::Agent::NewRelicService::JsonMarshaller.is_supported?
+        marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
+      else
+        marshaller = NewRelic::Agent::NewRelicService::PrubyMarshaller.new
+      end
+
+      assert_equal expected, sql_traces[0].to_collector_array(marshaller.default_encoder)
+    end
   end
 end