newrelic_rpm 3.5.2.17 → 3.5.3.24

data/test/multiverse/test/suite_examples/two/a/fail_test.rb

@@ -0,0 +1,6 @@
+require 'test/unit'
+class ATest < Test::Unit::TestCase
+  def test_failure
+    fail "This test is failing!!!"
+  end
+end

data/test/new_relic/agent/agent_test.rb

@@ -1,4 +1,6 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+require 'new_relic/agent/thread_profiler'
+
 module NewRelic
   module Agent
     class AgentTest < Test::Unit::TestCase
@@ -53,6 +55,47 @@ module NewRelic
         end
       end
 
+      def test_graceful_shutdown_ends_thread_profiling
+        @agent.thread_profiler.expects(:stop).once
+        @agent.instance_variable_set(:@connected, true)
+
+        @agent.send(:graceful_disconnect)
+      end
+
+      def test_harvest_and_send_thread_profile
+        profile = with_profile(:finished => true)
+        @agent.send(:harvest_and_send_thread_profile, false)
+
+        assert_equal([profile],
+                    @agent.service.agent_data \
+                      .find{|data| data.action == :profile_data}.params)
+      end
+
+      def test_harvest_and_send_thread_profile_when_not_finished
+        with_profile(:finished => false)
+        @agent.send(:harvest_and_send_thread_profile, false)
+
+        assert_nil @agent.service.agent_data.find{|data| data.action == :profile_data}
+      end
+
+      def test_harvest_and_send_thread_profile_when_not_finished_but_disconnecting
+        profile = with_profile(:finished => false)
+        @agent.send(:harvest_and_send_thread_profile, true)
+
+        assert_equal([profile],
+                     @agent.service.agent_data \
+                       .find{|data| data.action == :profile_data}.params)
+      end
+
+      def with_profile(opts)
+        profile = NewRelic::Agent::ThreadProfile.new(-1, 0, 0, true)
+        profile.aggregate(["chunky.rb:42:in `bacon'"], profile.traces[:other])
+        profile.instance_variable_set(:@finished, opts[:finished])
+
+        @agent.thread_profiler.instance_variable_set(:@profile, profile)
+        profile
+      end
+
       def test_harvest_timeslice_data
         assert_equal({}, @agent.send(:harvest_timeslice_data),
                      'should return timeslice data')
@@ -63,11 +106,11 @@ module NewRelic
           @agent.stats_engine.stats_hash[i.to_s] = NewRelic::StatsBase.new
         end
 
-        harvest = Thread.new do
+        harvest = Thread.new("Harvesting Test run timeslices") do
           @agent.send(:harvest_timeslice_data)
         end
 
-        app = Thread.new do
+        app = Thread.new("Harvesting Test Modify stats_hash") do
           200.times do |i|
             @agent.stats_engine.stats_hash["a#{i}"] = NewRelic::StatsBase.new
           end
@@ -82,6 +125,15 @@ module NewRelic
         assert_equal([], @agent.send(:harvest_errors), 'should return errors')
       end
 
+      def test_check_for_agent_commands
+        @agent.send :check_for_agent_commands
+
+        expected = RUBY_VERSION >= "1.9.2" ? 1 : 0
+        assert_equal(expected,
+                     @agent.service.agent_data \
+                       .select {|data| data.action == :get_agent_commands }.size)
+      end
+
       def test_merge_data_from_empty
         unsent_timeslice_data = mock('unsent timeslice data')
         unsent_errors = mock('unsent errors')

data/test/new_relic/agent/agent_test_controller.rb

@@ -12,7 +12,7 @@ class NewRelic::Agent::AgentTestController < NewRelic::Agent::SuperclassControll
   @@headers_to_add = nil
 
   def index
-    sleep params['wait'].to_i if params['wait']
+    sleep params['wait'].to_f if params['wait']
     render :text => params.inspect
   end
   def _filter_parameters(params)

data/test/new_relic/agent/agent_test_controller_test.rb

@@ -289,19 +289,49 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
   end
 
 
-  def test_busycalculation
+  def test_busy_calculation_correctly_calculates_based_acccumlator
+
+    # woah it's 1970
+    now = Time.at 0
+
+    # We'll record two seconds of transactions
+    later = Time.at(now + 2)
+    NewRelic::Agent::BusyCalculator.stubs(:time_now).
+      returns(now).then.returns(later)
+
+    # reset harvest time to epoch (based on stub)
+    NewRelic::Agent::BusyCalculator.reset
+
+    # We record 1 second of busy time in our two seconds of wall clock
+    NewRelic::Agent::BusyCalculator.instance_variable_set(:@accumulator, 1.0)
+
+
+    NewRelic::Agent::BusyCalculator.harvest_busy
+
+    # smooth out floating point math
+    stat_int = (stats('Instance/Busy').total_call_time * 10).to_i
+
+    # Despite your expectations, #total_call_time is a percentage here.
+    assert_equal(stat_int, 5,
+                 "#{stats('Instance/Busy').total_call_time} != 0.5")
+  end
+
+  def test_busy_calculation_generates_a_positive_value
     engine.clear_stats
-    assert_equal 0, NewRelic::Agent::BusyCalculator.busy_count
     get :index, 'social_security_number' => "001-555-1212", 'wait' => '0.05'
     NewRelic::Agent::BusyCalculator.harvest_busy
 
     assert_equal 1, stats('Instance/Busy').call_count
     assert_equal 1, stats('HttpDispatcher').call_count
-    # We are probably busy about 99% of the time, but lets make sure it's at least 50
-    assert stats('Instance/Busy').total_call_time > (0.5 * 0.05), stats('Instance/Busy').inspect
+
+    # Timing is too non-deterministic, so we just assert a positive, non-zero
+    # value here.  See
+    # #test_busy_calculation_correctly_calculates_based_acccumlator for
+    # assertions that the formula is correct.
+    assert(stats('Instance/Busy').total_call_time > 0,
+           "#{stats('Instance/Busy').total_call_time} !> 0")
     assert_equal 0, stats('WebFrontend/Mongrel/Average Queue Time').call_count
   end
-
   def test_queue_headers_no_header
     engine.clear_stats
     queue_length_stat = stats('Mongrel/Queue Length')

data/test/new_relic/agent/browser_monitoring_test.rb

@@ -60,7 +60,7 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
   end
 
   def test_browser_timing_header_with_no_beacon_configuration
-    NewRelic::Agent.instance.expects(:beacon_configuration).returns( nil)
+    NewRelic::Agent.instance.stubs(:beacon_configuration).returns( nil)
     header = browser_timing_header
     assert_equal "", header
   end
@@ -71,14 +71,14 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
   end
 
   def test_browser_timing_header_with_rum_enabled_not_specified
-    NewRelic::Agent.instance.expects(:beacon_configuration).at_least_once.returns( NewRelic::Agent::BeaconConfiguration.new)
+    NewRelic::Agent.instance.stubs(:beacon_configuration).returns( NewRelic::Agent::BeaconConfiguration.new)
     header = browser_timing_header
     assert_equal "<script type=\"text/javascript\">var NREUMQ=NREUMQ||[];NREUMQ.push([\"mark\",\"firstbyte\",new Date().getTime()]);</script>", header
   end
 
   def test_browser_timing_header_with_rum_enabled_false
     with_config(:'rum.enabled' => false) do
-      NewRelic::Agent.instance.expects(:beacon_configuration).twice.returns( NewRelic::Agent::BeaconConfiguration.new)
+      NewRelic::Agent.instance.stubs(:beacon_configuration).returns( NewRelic::Agent::BeaconConfiguration.new)
       header = browser_timing_header
       assert_equal "", header
     end
@@ -115,7 +115,7 @@ var e=document.createElement("script");'
   def test_browser_timing_footer_with_no_browser_key_rum_enabled
     with_config(:browser_key => '') do
       browser_timing_header
-      NewRelic::Agent.instance.expects(:beacon_configuration).returns(NewRelic::Agent::BeaconConfiguration.new)
+      NewRelic::Agent.instance.stubs(:beacon_configuration).returns(NewRelic::Agent::BeaconConfiguration.new)
       footer = browser_timing_footer
       assert_equal "", footer
     end
@@ -124,7 +124,7 @@ var e=document.createElement("script");'
   def test_browser_timing_footer_with_no_browser_key_rum_disabled
     with_config(:'rum.enabled' => false) do
       browser_timing_header
-      NewRelic::Agent.instance.expects(:beacon_configuration) \
+      NewRelic::Agent.instance.stubs(:beacon_configuration) \
         .returns(NewRelic::Agent::BeaconConfiguration.new)
       footer = browser_timing_footer
       assert_equal "", footer
@@ -138,7 +138,7 @@ var e=document.createElement("script");'
     ("a" * 13).each_byte {|byte| license_bytes << byte}
     config =  NewRelic::Agent::BeaconConfiguration.new
     config.expects(:license_bytes).returns(license_bytes).at_least_once
-    NewRelic::Agent.instance.expects(:beacon_configuration).returns(config).at_least_once
+    NewRelic::Agent.instance.stubs(:beacon_configuration).returns(config).at_least_once
     footer = browser_timing_footer
     beginning_snippet = '<script type="text/javascript">if (!NREUMQ.f) { NREUMQ.f=function() {
 NREUMQ.push(["load",new Date().getTime()]);
@@ -152,7 +152,7 @@ var e=document.createElement("script");'
 
   def test_browser_timing_footer_with_no_beacon_configuration
     browser_timing_header
-    NewRelic::Agent.instance.expects(:beacon_configuration).returns( nil)
+    NewRelic::Agent.instance.stubs(:beacon_configuration).returns( nil)
     footer = browser_timing_footer
     assert_equal "", footer
   end
@@ -178,7 +178,7 @@ var e=document.createElement("script");'
   def test_browser_timing_footer_browser_key_missing
     with_config(:browser_key => '') do
       fake_config = mock('beacon configuration')
-      NewRelic::Agent.instance.expects(:beacon_configuration).returns(fake_config)
+      NewRelic::Agent.instance.stubs(:beacon_configuration).returns(fake_config)
       fake_config.expects(:nil?).returns(false)
       fake_config.expects(:enabled?).returns(true)
       self.expects(:generate_footer_js).never

data/test/new_relic/agent/configuration/environment_source_test.rb

@@ -49,6 +49,22 @@ module NewRelic::Agent::Configuration
       assert_equal 'STDOUT', source[:log_file_path]
     end
 
+    def test_thread_profiler_is_supported
+      source = EnvironmentSource.new
+
+      assert_equal(
+        NewRelic::Agent::ThreadProfiler.is_supported?,
+        source[:'thread_profiler.is_supported'])
+    end
+
+    def test_thread_profiler_enabled_depending_on_support
+      source = EnvironmentSource.new
+
+      expected = false unless NewRelic::Agent::ThreadProfiler.is_supported?
+
+      assert_equal expected, source[:'thread_profiler.enabled']
+    end
+
     def assert_applied_string(env_var, config_var)
       ENV[env_var] = 'test value'
       assert_equal 'test value', EnvironmentSource.new[config_var.to_sym]

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/new_relic_service_test.rb

@@ -1,8 +1,10 @@
 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|
@@ -26,6 +28,7 @@ class NewRelicServiceTest < Test::Unit::TestCase
     @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',
@@ -62,7 +65,7 @@ class NewRelicServiceTest < Test::Unit::TestCase
   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 'somewhere.example.com', @service.collector.name
@@ -71,15 +74,14 @@ class NewRelicServiceTest < Test::Unit::TestCase
   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
@@ -97,7 +99,7 @@ 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
 
@@ -119,6 +121,44 @@ 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
     with_config(:timeout => 600) do
       service = NewRelic::Agent::NewRelicService.new('abcdef', @server)
@@ -136,32 +176,89 @@ class NewRelicServiceTest < Test::Unit::TestCase
     @service.expects(:get_redirect_host).once
 
     @service.connect
-    @http_handle.respond_to(:metric_data, '0')
-    @service.metric_data(Time.now - 60, Time.now, {})
+    @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')
+    @http_handle.respond_to(:transaction_sample_data, 1)
     @service.transaction_sample_data([])
 
-    @http_handle.respond_to(:sql_trace_data, '2')
+    @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', 413)
+    @http_handle.respond_to(:metric_data, 'too big', :code => 413)
     assert_raise NewRelic::Agent::UnrecoverableServerException do
-      @service.metric_data(Time.now - 60, Time.now, {})
+      @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', 415)
+    @http_handle.respond_to(:metric_data, 'too big', :code => 415)
     assert_raise NewRelic::Agent::UnrecoverableServerException do
-      @service.metric_data(Time.now - 60, Time.now, {})
+      @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
 
@@ -169,18 +266,38 @@ class NewRelicServiceTest < Test::Unit::TestCase
       reset
     end
 
-    def respond_to(method, payload, code=200)
-      klass = HTTPSuccess
-      if code == 413
+    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 code == 415
+      elsif opts[:code] == 415
         klass = HTTPUnsupportedMediaType
-      elsif code >= 400
+      elsif opts[:code] >= 400
         klass = HTTPServerError
+      else
+        klass = HTTPSuccess
       end
 
-      register(klass.new(Marshal.dump(payload), code)) do |request|
-        request.path.include?(method.to_s)
+      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