newrelic_rpm 3.3.5 → 3.4.0.beta1

data/test/new_relic/agent/database_test.rb

@@ -146,4 +146,16 @@ class NewRelic::Agent::DatabaseTest < Test::Unit::TestCase
 
     NewRelic::Agent::Database::Obfuscator.instance.reset
   end
+
+  def test_close_connections_closes_all_held_db_connections
+    foo_connection = mock('foo connection')
+    bar_connection = mock('bar connection')
+    NewRelic::Agent::Database::ConnectionManager.instance.instance_eval do
+      @connections = { :foo => foo_connection, :bar => bar_connection }      
+    end
+    foo_connection.expects(:disconnect!)
+    bar_connection.expects(:disconnect!)
+    
+    NewRelic::Agent::Database.close_connections
+  end
 end

data/test/new_relic/agent/new_relic_service_test.rb

@@ -0,0 +1,151 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
+
+class NewRelicServiceTest < Test::Unit::TestCase
+  def setup
+    @server = NewRelic::Control::Server.new('127.0.0.1', 30303)    
+    @service = NewRelic::Agent::NewRelicService.new('license-key', @server)
+    @http_handle = HTTPHandle.new
+    NewRelic::Control.instance.stubs(:http_connection).returns(@http_handle)
+    @http_handle.respond_to(:get_redirect_host, 'localhost')
+    connect_response = {
+      'config' => 'some config directives',
+      'agent_run_id' => 1
+    }
+    @http_handle.respond_to(:connect, connect_response)
+  end
+
+  def test_connect_sets_agent_id_and_config_data
+    response = @service.connect
+    assert_equal 1, response['agent_run_id']
+    assert_equal 'some config directives', response['config']
+  end
+
+  def test_connect_sets_redirect_host
+    assert_equal '127.0.0.1', @service.collector.name
+    @service.connect    
+    assert_equal 'localhost', @service.collector.name
+  end
+
+  def test_connect_uses_proxy_collector_if_no_redirect_host
+    @http_handle.reset
+    @http_handle.respond_to(:get_redirect_host, nil)
+    @http_handle.respond_to(:connect, {'agent_run_id' => 1})
+
+    @service.connect
+    assert_equal '127.0.0.1', @service.collector.name
+  end
+
+  def test_connect_sets_agent_id
+    @http_handle.reset
+    @http_handle.respond_to(:get_redirect_host, 'localhost')
+    @http_handle.respond_to(:connect, {'agent_run_id' => 666})
+
+    @service.connect
+    assert_equal 666, @service.agent_id
+  end
+
+  def test_get_redirect_host
+    host = @service.get_redirect_host
+    assert_equal 'localhost', host
+  end
+
+  def test_shutdown
+    @service.agent_id = 666
+    @http_handle.respond_to(:shutdown, 'shut this bird down')
+    response = @service.shutdown(Time.now)
+    assert_equal 'shut this bird down', response
+  end
+
+  def test_should_not_shutdown_if_never_connected
+    @http_handle.respond_to(:shutdown, 'shut this bird down')
+    response = @service.shutdown(Time.now)
+    assert_nil response
+  end
+
+  def test_metric_data
+    @http_handle.respond_to(:metric_data, 'met rick date uhhh')
+    response = @service.metric_data(Time.now - 60, Time.now, {})
+    assert_equal 'met rick date uhhh', response
+  end
+
+  def test_error_data
+    @http_handle.respond_to(:error_data, 'too human')
+    response = @service.error_data([])
+    assert_equal 'too human', response    
+  end
+
+  def test_transaction_sample_data
+    @http_handle.respond_to(:transaction_sample_data, 'MPC1000')
+    response = @service.transaction_sample_data([])
+    assert_equal 'MPC1000', response        
+  end
+
+  def test_sql_trace_data
+    @http_handle.respond_to(:sql_trace_data, 'explain this')
+    response = @service.sql_trace_data([])
+    assert_equal 'explain this', response
+  end
+
+  def test_request_timeout
+    NewRelic::Control.instance['timeout'] = 600
+    service = NewRelic::Agent::NewRelicService.new('abcdef', @server)
+    assert_equal 600, service.request_timeout
+  end
+
+  def test_should_throw_received_errors
+    assert_raise NewRelic::Agent::ServerConnectionException do
+      @service.send(:invoke_remote, :bogus_method)
+    end
+  end
+
+  class HTTPHandle
+    attr_accessor :read_timeout, :route_table
+
+    def initialize
+      reset
+    end
+
+    def respond_to(method, payload)
+      register(HTTPResponse.new(Marshal.dump(payload))) do |request|
+        request.path.include?(method.to_s)
+      end
+    end
+
+    def register(response, &block)
+      @route_table[block] = response
+    end
+
+    def request(*args)
+      @route_table.each_pair do |condition, response|
+        if condition.call(args[0])
+          return response
+        end
+      end
+      HTTPFailure.new('not found', 404)
+    end
+
+    def reset
+      @route_table = {}
+    end
+  end
+
+  module HTTPResponseMock
+    attr_accessor :code, :body, :message, :headers
+
+    def initialize(body, code=200, message='OK')
+      @code = code
+      @body = body
+      @message = message
+      @headers = {}
+    end
+
+    def [](key)
+      @headers[key]
+    end
+  end
+
+  HTTPResponse = Class.new(Net::HTTPOK)
+  HTTPResponse.class_eval { include HTTPResponseMock }
+  HTTPFailure = Class.new(Net::HTTPError)
+  HTTPFailure.class_eval { include HTTPResponseMock }
+end

data/test/new_relic/agent/pipe_channel_manager_test.rb

@@ -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

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