ghazel-newrelic_rpm 3.4.0.2 → 3.5.4

data/test/new_relic/agent/method_tracer/class_methods/add_method_tracer_test.rb

@@ -35,7 +35,7 @@ module NewRelic
             end
 
             def test_default_metric_name_code
-              assert_equal "Custom/#{name}/test_method", default_metric_name_code('test_method')
+              assert_equal "Custom/#{self.class.name}/test_method", self.class.default_metric_name_code('test_method')
             end
 
             def test_newrelic_method_exists_positive
@@ -44,13 +44,13 @@ module NewRelic
             end
 
             def test_newrelic_method_exists_negative
-              self.expects(:method_defined?).returns(false)
-              self.expects(:private_method_defined?).returns(false)
+              self.class.expects(:method_defined?).returns(false)
+              self.class.expects(:private_method_defined?).returns(false)
 
               fake_log = mock('log')
               NewRelic::Control.instance.expects(:log).returns(fake_log)
-              fake_log.expects(:warn).with("Did not trace #{name}#test_method because that method does not exist")
-              assert !newrelic_method_exists?('test_method')
+              fake_log.expects(:warn).with("Did not trace #{self.class.name}#test_method because that method does not exist")
+              assert !self.class.newrelic_method_exists?('test_method')
             end
 
             def test_set_deduct_call_time_based_on_metric_positive

data/test/new_relic/agent/method_tracer_test.rb

@@ -324,14 +324,14 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
   end
 
   def test_add_multiple_tracers
-    self.class.add_method_tracer :method_to_be_traced, 'X', :push_scope => false
+    self.class.add_method_tracer :method_to_be_traced, 'XX', :push_scope => false
     method_to_be_traced 1,2,3,true,nil
-    self.class.add_method_tracer :method_to_be_traced, 'Y'
-    method_to_be_traced 1,2,3,true,'Y'
-    self.class.remove_method_tracer :method_to_be_traced, 'Y'
+    self.class.add_method_tracer :method_to_be_traced, 'YY'
+    method_to_be_traced 1,2,3,true,'YY'
+    self.class.remove_method_tracer :method_to_be_traced, 'YY'
     method_to_be_traced 1,2,3,true,nil
-    self.class.remove_method_tracer :method_to_be_traced, 'X'
-    method_to_be_traced 1,2,3,false,'X'
+    self.class.remove_method_tracer :method_to_be_traced, 'XX'
+    method_to_be_traced 1,2,3,false,'XX'
   end
 
   def trace_no_push_scope

data/test/new_relic/agent/mock_scope_listener.rb

@@ -18,6 +18,9 @@ class NewRelic::Agent::MockScopeListener
   end
 
   def notice_scope_empty(time)
+  end
 
+  def enabled?
+    true
   end
 end

data/test/new_relic/agent/new_relic_service_test.rb

@@ -1,11 +1,34 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
+require 'new_relic/agent/thread_profiler'
 
 class NewRelicServiceTest < Test::Unit::TestCase
+  def initialize(*_)
+    [ :HTTPSuccess,
+      :HTTPUnauthorized,
+      :HTTPNotFound,
+      :HTTPRequestEntityTooLarge,
+      :HTTPUnsupportedMediaType ].each do |class_name|
+      extend_with_mock(class_name)
+    end
+    super
+  end
+
+  def extend_with_mock(class_name)
+    if !self.class.const_defined?(class_name)
+      klass = self.class.const_set(class_name,
+                Class.new(Object.const_get(:Net).const_get(class_name)))
+      klass.class_eval { include HTTPResponseMock }
+    end
+  end
+  protected :extend_with_mock
+
   def setup
-    @server = NewRelic::Control::Server.new('127.0.0.1', 30303)    
+    @server = NewRelic::Control::Server.new('somewhere.example.com',
+                                            30303, '10.10.10.10')
     @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',
@@ -14,6 +37,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']
@@ -21,32 +51,37 @@ class NewRelicServiceTest < Test::Unit::TestCase
   end
 
   def test_connect_sets_redirect_host
-    assert_equal '127.0.0.1', @service.collector.name
-    @service.connect    
+    assert_equal 'somewhere.example.com', @service.collector.name
+    @service.connect
     assert_equal 'localhost', @service.collector.name
   end
 
+  def test_connect_resets_cached_ip_address
+    assert_equal '10.10.10.10', @service.collector.ip
+    @service.connect
+    assert_nil @service.collector.ip # 'localhost' resolves to nil
+  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})
+    @http_handle.respond_to(:connect, 'agent_run_id' => 1)
 
     @service.connect
-    assert_equal '127.0.0.1', @service.collector.name
+    assert_equal 'somewhere.example.com', @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})
+    @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
+    assert_equal 'localhost', @service.get_redirect_host
   end
 
   def test_shutdown
@@ -64,20 +99,20 @@ class NewRelicServiceTest < Test::Unit::TestCase
 
   def test_metric_data
     @http_handle.respond_to(:metric_data, 'met rick date uhhh')
-    response = @service.metric_data(Time.now - 60, Time.now, {})
+    response = @service.metric_data((Time.now - 60).to_f, Time.now.to_f, {})
     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    
+    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        
+    assert_equal 'MPC1000', response
   end
 
   def test_sql_trace_data
@@ -86,10 +121,49 @@ class NewRelicServiceTest < Test::Unit::TestCase
     assert_equal 'explain this', response
   end
 
+
+# Thread profiling only available in 1.9.2 and above
+if RUBY_VERSION >= '1.9.2'
+  def test_profile_data
+    @http_handle.respond_to(:profile_data, 'profile' => 123)
+    response = @service.profile_data(NewRelic::Agent::ThreadProfile.new(0, 0, 0, true))
+    assert_equal({ "profile" => 123 }, response)
+  end
+
+  def test_get_agent_commands
+    @service.agent_id = 666
+    @http_handle.respond_to(:get_agent_commands, [1,2,3])
+
+    response = @service.get_agent_commands
+    assert_equal [1,2,3], response
+  end
+
+  def test_get_agent_commands_with_no_response
+    @service.agent_id = 666
+    @http_handle.respond_to(:get_agent_commands, nil)
+
+    response = @service.get_agent_commands
+    assert_equal nil, response
+  end
+
+  def test_agent_command_results
+    @http_handle.respond_to(:agent_command_results, {})
+    response = @service.agent_command_results(4200)
+    assert_equal({}, response)
+  end
+
+  def test_agent_command_results_with_errors
+    @http_handle.respond_to(:agent_command_results, [123])
+    response = @service.agent_command_results(4200, 'Boo!')
+    assert_equal [123], response
+  end
+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
@@ -98,6 +172,93 @@ class NewRelicServiceTest < Test::Unit::TestCase
     end
   end
 
+  def test_should_connect_to_proxy_only_once_per_run
+    @service.expects(:get_redirect_host).once
+
+    @service.connect
+    @http_handle.respond_to(:metric_data, 0)
+    @service.metric_data((Time.now - 60).to_f, Time.now.to_f, {})
+
+    @http_handle.respond_to(:transaction_sample_data, 1)
+    @service.transaction_sample_data([])
+
+    @http_handle.respond_to(:sql_trace_data, 2)
+    @service.sql_trace_data([])
+  end
+
+  # for PRUBY proxy compatibility
+  def test_should_raise_exception_on_401
+    @http_handle.reset
+    @http_handle.respond_to(:get_redirect_host, 'bad license', :code => 401)
+    assert_raise NewRelic::Agent::LicenseException do
+      @service.get_redirect_host
+    end
+  end
+
+  # protocol 9
+  def test_should_raise_exception_on_413
+    @http_handle.respond_to(:metric_data, 'too big', :code => 413)
+    assert_raise NewRelic::Agent::UnrecoverableServerException do
+      @service.metric_data((Time.now - 60).to_f, Time.now.to_f, {})
+    end
+  end
+
+  # protocol 9
+  def test_should_raise_exception_on_415
+    @http_handle.respond_to(:metric_data, 'too big', :code => 415)
+    assert_raise NewRelic::Agent::UnrecoverableServerException do
+      @service.metric_data((Time.now - 60).to_f, Time.now.to_f, {})
+    end
+  end
+
+  if NewRelic::LanguageSupport.using_version?('1.9')
+    def test_json_marshaller_handles_responses_from_collector
+      marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
+      assert_equal ['beep', 'boop'], marshaller.load('{"return_value": ["beep","boop"]}')
+    end
+
+    def test_json_marshaller_handles_errors_from_collector
+      marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
+      assert_raise(NewRelic::Agent::NewRelicService::CollectorError,
+                   'JavaCrash: error message') do
+        marshaller.load('{"exception": {"message": "error message", "error_type": "JavaCrash"}}')
+      end
+    end
+  end
+
+  def test_pruby_marshaller_handles_errors_from_collector
+    marshaller = NewRelic::Agent::NewRelicService::PrubyMarshaller.new
+    assert_raise(NewRelic::Agent::NewRelicService::CollectorError, 'error message') do
+      marshaller.load(Marshal.dump({"exception" => {"message" => "error message",
+                                       "error_type" => "JavaCrash"}}))
+    end
+  end
+
+  def test_pruby_marshaller_compresses_large_payloads
+    marshaller = NewRelic::Agent::NewRelicService::PrubyMarshaller.new
+    large_payload = 'a' * 64 * 1024
+    result = marshaller.dump(large_payload)
+    assert_equal 'deflate', marshaller.encoding
+    assert_equal large_payload, Marshal.load(Zlib::Inflate.inflate(result))
+  end
+
+  def test_marshaller_handles_known_errors
+    error_data = {
+      'error_type' => 'NewRelic::Agent::ForceRestartException',
+      'message'    => 'test'
+    }
+    error = @service.marshaller.parsed_error(error_data)
+    assert_equal NewRelic::Agent::ForceRestartException, error.class
+    assert_equal 'test', error.message
+  end
+
+  def test_marshaller_handles_unknown_errors
+    error = @service.marshaller.parsed_error('error_type' => 'OogBooga',
+                                             'message' => 'test')
+    assert_equal NewRelic::Agent::NewRelicService::CollectorError, error.class
+    assert_equal 'OogBooga: test', error.message
+  end
+
   class HTTPHandle
     attr_accessor :read_timeout, :route_table
 
@@ -105,9 +266,38 @@ class NewRelicServiceTest < Test::Unit::TestCase
       reset
     end
 
-    def respond_to(method, payload)
-      register(HTTPResponse.new(Marshal.dump(payload))) do |request|
-        request.path.include?(method.to_s)
+    def respond_to(method, payload, opts={})
+      if NewRelic::Agent::NewRelicService::JsonMarshaller.is_supported?
+        format = :json
+      else
+        format = :pruby
+      end
+
+      opts = {
+        :code => 200,
+        :format => format
+      }.merge(opts)
+
+      if opts[:code] == 401
+        klass = HTTPUnauthorized
+      elsif opts[:code] == 413
+        klass = HTTPRequestEntityTooLarge
+      elsif opts[:code] == 415
+        klass = HTTPUnsupportedMediaType
+      elsif opts[:code] >= 400
+        klass = HTTPServerError
+      else
+        klass = HTTPSuccess
+      end
+
+      if opts[:format] == :json
+        register(klass.new(JSON.dump('return_value' => payload), opts[:code])) do |request|
+          request.path.include?(method.to_s)
+        end
+      else
+        register(klass.new(Marshal.dump('return_value' => payload), opts[:code])) do |request|
+          request.path.include?(method.to_s)
+        end
       end
     end
 
@@ -121,7 +311,7 @@ class NewRelicServiceTest < Test::Unit::TestCase
           return response
         end
       end
-      HTTPFailure.new('not found', 404)
+      HTTPNotFound.new('not found', 404)
     end
 
     def reset
@@ -143,9 +333,4 @@ class NewRelicServiceTest < Test::Unit::TestCase
       @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

@@ -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,32 +43,35 @@ 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)
+      engine.reset_stats
     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
         sample = TransactionSampleTestHelper.run_sample_trace_on(new_sampler)
         new_sampler.store_force_persist(sample)
-        listener.pipes[667].write(:transaction_traces => new_sampler.harvest([], 0))
+        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/',
@@ -74,9 +80,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
@@ -103,8 +109,19 @@ class NewRelic::Agent::PipeChannelManagerTest < Test::Unit::TestCase
       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