ghazel-newrelic_rpm 3.1.0.1 → 3.4.0.2

data/test/new_relic/agent/pipe_channel_manager_test.rb

@@ -0,0 +1,114 @@
+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
+    NewRelic::Agent::PipeChannelManager.listener.close_all_pipes
+    NewRelic::Agent.manual_start
+  end
+
+  def teardown
+    NewRelic::Agent::PipeChannelManager.listener.stop
+    NewRelic::Agent.shutdown
+  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)    
+    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)
+        listener.pipes[667].write(:transaction_traces => new_sampler.harvest([], 0))
+      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
+  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

@@ -82,8 +82,10 @@ class NewRelic::Agent::RpmAgentTest < Test::Unit::TestCase # ActiveSupport::Test
 
     should "send_timeslice_data" do
       # this test fails due to a rubinius bug
-      return if (RUBY_DESCRIPTION =~ /rubinius/i)
-      @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)
+      return if NewRelic::LanguageSupport.using_engine?('rbx')
+      @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)
       @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
@@ -106,34 +108,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 +117,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

@@ -0,0 +1,192 @@
+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
+    agent.stubs(:stats_engine).returns(stats_engine)
+    @sampler = NewRelic::Agent::SqlSampler.new
+    @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    
+    @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    
+    @sampler.notice_sql "select * from test", "Database/test/select", nil, 10
+  end
+
+  def test_notice_sql
+    @sampler.notice_first_scope_push nil
+    @sampler.notice_sql "select * from test", "Database/test/select", nil, 1.5
+    @sampler.notice_sql "select * from test2", "Database/test2/select", nil, 1.3
+    # this sql will not be captured
+    @sampler.notice_sql "select * from test", "Database/test/select", nil, 0
+    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 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", 
+            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), 
+                          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
+
+  def test_harvest_should_not_take_more_than_10
+    data = NewRelic::Agent::TransactionSqlData.new
+    data.set_transaction_info("WebTransaction/Controller/c/a", "/c/a", {}, 'guid')
+    15.times do |i|
+      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
+
+  def test_harvest_should_aggregate_similar_queries
+    data = NewRelic::Agent::TransactionSqlData.new
+    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 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
+
+  def test_harvest_should_collect_explain_plans
+    @connection.expects(:execute).with("EXPLAIN select * from test") \
+     .returns([{"header0" => 'foo0', "header1" => 'foo1', "header2" => 'foo2'}])
+    @connection.expects(:execute).with("EXPLAIN select * from test2") \
+     .returns([{"header0" => 'bar0', "header1" => 'bar1', "header2" => 'bar2'}])
+
+    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), 
+               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   
+    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)    
+    assert_equal(["bar0", "bar1", "bar2"],
+                 sql_traces[1].params[:explain_plan][1][0].sort)
+  end
+
+  def test_sql_trace_should_include_transaction_guid
+    txn_sampler = NewRelic::Agent::TransactionSampler.new
+    NewRelic::Agent.instance.stats_engine.transaction_sampler = txn_sampler
+    txn_sampler.start_builder(Time.now)
+    txn_sampler.notice_transaction('a path', 'a uri', {:some => :params})
+    @sampler.create_transaction_data
+    @sampler.notice_transaction('a path', 'a uri', {:some => :params})
+
+    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 }
+  end
+
+  def test_sql_id_fits_in_a_mysql_int_11
+    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
+
+    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