newrelic_rpm 2.13.4 → 2.13.5.beta1

data/test/new_relic/agent/agent_controller_test.rb

@@ -1,5 +1,5 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
-
+require 'action_controller/test_case'
 class AgentControllerTest < ActionController::TestCase
   require 'action_controller/base'
   require 'new_relic/agent/agent_test_controller'
@@ -22,8 +22,12 @@ class AgentControllerTest < ActionController::TestCase
     ActionController::Routing::Routes.draw do | map |
       map.connect '/:controller/:action.:format'
       map.connect '/:controller/:action'
-    end
+      end
   end
+
+    if defined?(Rails) && Rails.respond_to?(:application) && Rails.application.respond_to?(:routes)
+      @routes = Rails.application.routes
+    end
   
     Thread.current[:newrelic_ignore_controller] = nil
     NewRelic::Agent.manual_start
@@ -57,7 +61,6 @@ class AgentControllerTest < ActionController::TestCase
   
   def test_heroku_queue
     engine.clear_stats
-    NewRelic::Control.instance.local_env.stubs(:mongrel).returns( stub('mongrel', :workers => stub('workers', :list => stub('list', :length => '10'))))
     NewRelic::Agent::AgentTestController.set_some_headers 'HTTP_X_HEROKU_QUEUE_DEPTH'=>'15'
     get :index
     assert_equal 1, stats('HttpDispatcher').call_count
@@ -65,6 +68,48 @@ class AgentControllerTest < ActionController::TestCase
     assert_equal 15, engine.get_stats_no_scope('Mongrel/Queue Length').total_call_time
     assert_equal 0, engine.get_stats_no_scope('WebFrontend/Mongrel/Average Queue Time').call_count
   end
+
+  def test_new_queue_integration
+    engine.clear_stats
+    start = ((Time.now - 1).to_f * 1_000_000).to_i
+    NewRelic::Agent::AgentTestController.set_some_headers 'HTTP_X_QUEUE_START'=> "t=#{start}"
+    get :index
+
+    check_metric_time('WebFrontend/QueueTime', 1, 0.1)
+  end
+  
+
+  def test_new_middleware_integration
+    engine.clear_stats
+    start = ((Time.now - 1).to_f * 1_000_000).to_i
+    NewRelic::Agent::AgentTestController.set_some_headers 'HTTP_X_MIDDLEWARE_START'=> "t=#{start}"
+    get :index
+
+    check_metric_time('Middleware/all', 1, 0.1)
+  end
+
+  def test_new_server_time_integration
+    engine.clear_stats
+    start = ((Time.now - 1).to_f * 1_000_000).to_i
+    NewRelic::Agent::AgentTestController.set_some_headers 'HTTP_X_REQUEST_START'=> "t=#{start}"
+    get :index
+
+    check_metric_time('WebFrontend/WebServer/all', 1, 0.1)
+  end
+
+  def test_new_frontend_work_integration
+    engine.clear_stats
+    times = [Time.now - 3, Time.now - 2, Time.now - 1]
+    times.map! {|t| (t.to_f * 1_000_000).to_i }
+    NewRelic::Agent::AgentTestController.set_some_headers({
+                                                            'HTTP_X_REQUEST_START'=> "t=#{times[0]}", 'HTTP_X_QUEUE_START' => "t=#{times[1]}", 'HTTP_X_MIDDLEWARE_START' => "t=#{times[2]}"})
+    get :index
+    
+    
+    check_metric_time('WebFrontend/WebServer/all', 1, 0.1)
+    check_metric_time('Middleware/all', 1, 0.1)
+    check_metric_time('WebFrontend/QueueTime', 1, 0.1)    
+  end
   
   def test_render_inline
     engine.clear_stats
@@ -88,7 +133,10 @@ class AgentControllerTest < ActionController::TestCase
                 'Apdex/new_relic/agent/agent_test/action_with_error',
                 'HttpDispatcher',
                 'Controller/new_relic/agent/agent_test/action_with_error',
-                'Errors/all']
+                'Errors/all',
+                'Middleware/all',
+                'WebFrontend/WebServer/all',
+                'WebFrontend/QueueTime']
 
     compare_metrics metrics, engine.metrics.reject{|m| m.index('Response')==0 || m.index('CPU')==0}
     assert_equal 1, engine.get_stats_no_scope("Controller/new_relic/agent/agent_test/action_with_error").call_count
@@ -109,7 +157,10 @@ class AgentControllerTest < ActionController::TestCase
                 'Apdex/new_relic/agent/agent_test/action_with_error',
                 'HttpDispatcher',
                 'Controller/new_relic/agent/agent_test/action_with_error',
-                'Errors/all']
+                'Errors/all',
+                'WebFrontend/QueueTime',
+                'Middleware/all',
+                'WebFrontend/WebServer/all']
 
     compare_metrics metrics, engine.metrics.reject{|m| m.index('Response')==0 || m.index('CPU')==0}
     assert_equal 1, engine.get_stats_no_scope("Controller/new_relic/agent/agent_test/action_with_error").call_count
@@ -130,7 +181,10 @@ class AgentControllerTest < ActionController::TestCase
                 'Apdex/new_relic/agent/agent_test/action_with_before_filter_error',
                 'HttpDispatcher',
                 'Controller/new_relic/agent/agent_test/action_with_before_filter_error',
-                'Errors/all']
+                'Errors/all',
+                'WebFrontend/QueueTime',
+                'Middleware/all',
+                'WebFrontend/WebServer/all']
 
     compare_metrics metrics, engine.metrics.reject{|m| m.index('Response')==0 || m.index('CPU')==0}
     assert_equal 1, engine.get_stats_no_scope("Controller/new_relic/agent/agent_test/action_with_before_filter_error").call_count
@@ -220,7 +274,7 @@ class AgentControllerTest < ActionController::TestCase
     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, stats('Instance/Busy')
+    assert stats('Instance/Busy').total_call_time > 0.5, stats('Instance/Busy').inspect
     assert_equal 0, stats('WebFrontend/Mongrel/Average Queue Time').call_count
   end
   
@@ -233,47 +287,61 @@ class AgentControllerTest < ActionController::TestCase
     assert_equal 1, bucket_stats.call_count
   end
 
-  def test_queue_headers
+  def test_queue_headers_no_header
     engine.clear_stats
     queue_length_stat = stats('Mongrel/Queue Length')
-    queue_time_stat = stats('WebFrontend/Mongrel/Average Queue Time')
+    queue_time_stat = stats('WebFrontend/QueueTime')
     
     # no request start header
     get 'index'
     assert_equal 0, queue_length_stat.call_count
+  end
+
+  def test_queue_headers_apache
 
+    engine.clear_stats
+    queue_length_stat = stats('Mongrel/Queue Length')
+    queue_time_stat = stats('WebFrontend/QueueTime')
+    
     # apache version of header
-    request_start = ((Time.now.to_f - 0.2) * 1e6).to_i.to_s
-    NewRelic::Agent::AgentTestController.set_some_headers({'HTTP_X_REQUEST_START' => "t=#{request_start}"})
+    request_start = ((Time.now.to_f - 0.5) * 1e6).to_i.to_s
+    NewRelic::Agent::AgentTestController.set_some_headers({'HTTP_X_QUEUE_START' => "t=#{request_start}"})
     get :index
     assert_equal(0, queue_length_stat.call_count, 'We should not be seeing a queue length yet')
     assert_equal(1, queue_time_stat.call_count, 'We should have seen the queue header once')
     assert(queue_time_stat.total_call_time > 0.1, "Queue time should be longer than 100ms")
-    assert(queue_time_stat.total_call_time < 10, "Queue time should be under 10 seconds (sanity check)")    
+    assert(queue_time_stat.total_call_time < 10, "Queue time should be under 10 seconds (sanity check)")
+
+  end
+  def test_queue_headers_heroku
     
     engine.clear_stats
     NewRelic::Agent::AgentTestController.clear_headers    
 
     queue_length_stat = stats('Mongrel/Queue Length')
-    queue_time_stat = stats('WebFrontend/Mongrel/Average Queue Time')
+    queue_time_stat = stats('WebFrontend/QueueTime')
     
     # heroku version
-    request_start = ((Time.now.to_f - 0.2) * 1e3).to_i.to_s
-    NewRelic::Agent::AgentTestController.set_some_headers({'HTTP_X_REQUEST_START' => request_start, 'HTTP_X_HEROKU_QUEUE_DEPTH' => '0'})
+    request_start = ((Time.now.to_f - 0.5) * 1e6).to_i.to_s
+    NewRelic::Agent::AgentTestController.set_some_headers({'HTTP_X_QUEUE_START' => "t=#{request_start}", 'HTTP_X_HEROKU_QUEUE_DEPTH' => '0'})
     get :index
     assert_equal(0, queue_length_stat.total_call_time, 'queue should be empty')
     assert_equal(1, queue_time_stat.call_count, 'should have seen the queue header once')
     assert(queue_time_stat.total_call_time > 0.1, "Queue time should be longer than 100ms")
     assert(queue_time_stat.total_call_time < 10, "Queue time should be under 10 seconds (sanity check)")
+  end
+
+  def test_queue_headers_heroku_queue_length
+    
     engine.clear_stats
     NewRelic::Agent::AgentTestController.clear_headers
     
     queue_length_stat = stats('Mongrel/Queue Length')
-    queue_time_stat = stats('WebFrontend/Mongrel/Average Queue Time')    
+    queue_time_stat = stats('WebFrontend/QueueTime')    
 
     # heroku version with queue length > 0
-    request_start = ((Time.now.to_f - 0.2) * 1e3).to_i.to_s
-    NewRelic::Agent::AgentTestController.set_some_headers({'HTTP_X_REQUEST_START' => request_start, 'HTTP_X_HEROKU_QUEUE_DEPTH' => '3'})
+    request_start = ((Time.now.to_f - 0.5) * 1e6).to_i.to_s
+    NewRelic::Agent::AgentTestController.set_some_headers({'HTTP_X_QUEUE_START' => "t=#{request_start}", 'HTTP_X_HEROKU_QUEUE_DEPTH' => '3'})
     get :index
     
     assert_equal(1, queue_length_stat.call_count, 'queue should have been seen once')

data/test/new_relic/agent/agent_start_test.rb

@@ -0,0 +1,326 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+class NewRelic::Agent::AgentStartTest < Test::Unit::TestCase
+  require 'new_relic/agent/agent'
+  include NewRelic::Agent::Agent::Start
+
+  def test_already_started_positive
+    control = mocked_control
+    control.expects(:log!).with("Agent Started Already!", :error)
+    self.expects(:started?).returns(true)
+    assert already_started?, "should have already started"
+  end
+
+  def test_already_started_negative
+    self.expects(:started?).returns(false)
+    assert !already_started?
+  end
+  
+  def test_disabled_positive
+    control = mocked_control
+    control.expects(:agent_enabled?).returns(false)
+    assert disabled?
+  end
+
+  def test_disabled_negative
+    control = mocked_control
+    control.expects(:agent_enabled?).returns(true)
+    assert !disabled?
+  end
+
+  def test_log_dispatcher_positive
+    control = mocked_control
+    log = mocked_log
+    control.expects(:dispatcher).returns('Y U NO SERVE WEBPAGE')
+    log.expects(:info).with("Dispatcher: Y U NO SERVE WEBPAGE")
+    log_dispatcher
+  end
+
+  def test_log_dispatcher_negative
+    control = mocked_control
+    log = mocked_log
+    control.expects(:dispatcher).returns('')
+    log.expects(:info).with("No dispatcher detected.")
+    log_dispatcher
+  end
+
+  def test_log_app_names
+    control = mocked_control
+    log = mocked_log
+    control.expects(:app_names).returns(%w(zam zam zabam))
+    log.expects(:info).with("Application: zam, zam, zabam")
+    log_app_names
+  end
+
+  def test_apdex_f
+    NewRelic::Control.instance.expects(:apdex_t).returns(10)
+    assert_equal 40, apdex_f
+  end
+
+  def test_apdex_f_threshold_positive
+    self.expects(:sampler_config).returns({'transaction_threshold' => 'apdex_f'})
+    assert apdex_f_threshold?
+  end
+
+  def test_apdex_f_threshold_negative
+    self.expects(:sampler_config).returns({'transaction_threshold' => 'WHEE'})
+    assert !apdex_f_threshold?
+  end
+
+  def test_set_sql_recording_default
+    self.expects(:sampler_config).returns({})
+    self.expects(:log_sql_transmission_warning?)
+    set_sql_recording!
+    assert_equal :obfuscated, @record_sql, " should default to :obfuscated, was #{@record_sql}"
+  end
+
+  def test_set_sql_recording_none
+    self.expects(:sampler_config).returns({'record_sql' => 'none'})
+    self.expects(:log_sql_transmission_warning?)
+    set_sql_recording!
+    assert_equal :none, @record_sql, "should be set to :none, was #{@record_sql}"
+  end
+  
+  def test_set_sql_recording_raw
+    self.expects(:sampler_config).returns({'record_sql' => 'raw'})
+    self.expects(:log_sql_transmission_warning?)
+    set_sql_recording!
+    assert_equal :raw, @record_sql, "should be set to :raw, was #{@record_sql}"
+  end
+
+  def test_log_sql_transmission_warning_negative
+    log = mocked_log
+    @record_sql = :obfuscated
+    log.expects(:warn).never
+    log_sql_transmission_warning?
+  end
+
+  def test_log_sql_transmission_warning_positive
+    log = mocked_log
+    @record_sql = :raw
+    log.expects(:send).with(:warn, 'Agent is configured to send raw SQL to RPM service')
+    log_sql_transmission_warning?
+  end
+
+  def test_sampler_config
+    control = mocked_control
+    control.expects(:fetch).with('transaction_tracer', {})
+    sampler_config
+  end
+
+  def test_config_transaction_tracer
+    fake_sampler_config = mock('sampler config')
+    self.expects(:sampler_config).times(5).returns(fake_sampler_config)
+    fake_sampler_config.expects(:fetch).with('enabled', true)
+    fake_sampler_config.expects(:fetch).with('random_sample', false)
+    fake_sampler_config.expects(:fetch).with('explain_threshold', 0.5)
+    fake_sampler_config.expects(:fetch).with('explain_enabled', true)
+    self.expects(:set_sql_recording!)
+    
+    fake_sampler_config.expects(:fetch).with('transaction_threshold', 2.0)
+    self.expects(:apdex_f_threshold?).returns(true)
+    self.expects(:apdex_f)
+    config_transaction_tracer
+  end
+  
+  def test_check_config_and_start_agent_disabled
+    self.expects(:monitoring?).returns(false)
+    check_config_and_start_agent
+  end
+
+  def test_check_config_and_start_agent_incorrect_key
+    self.expects(:monitoring?).returns(true)
+    self.expects(:has_correct_license_key?).returns(false)
+    check_config_and_start_agent
+  end
+  
+  def test_check_config_and_start_agent_forking
+    self.expects(:monitoring?).returns(true)
+    self.expects(:has_correct_license_key?).returns(true)
+    self.expects(:using_forking_dispatcher?).returns(true)
+    check_config_and_start_agent
+  end
+
+  def test_check_config_and_start_agent_normal
+    self.expects(:monitoring?).returns(true)
+    self.expects(:has_correct_license_key?).returns(true)
+    self.expects(:using_forking_dispatcher?).returns(false)
+    control = mocked_control
+    control.expects(:sync_startup).returns(false)
+    self.expects(:start_worker_thread)
+    self.expects(:install_exit_handler)
+    check_config_and_start_agent
+  end
+  
+  def test_check_config_and_start_agent_sync
+    self.expects(:monitoring?).returns(true)
+    self.expects(:has_correct_license_key?).returns(true)
+    self.expects(:using_forking_dispatcher?).returns(false)
+    control = mocked_control
+    control.expects(:sync_startup).returns(true)
+    self.expects(:connect_in_foreground)
+    self.expects(:start_worker_thread)
+    self.expects(:install_exit_handler)
+    check_config_and_start_agent
+  end
+  
+  def test_connect_in_foreground
+    self.expects(:connect).with({:keep_retrying => false })
+    connect_in_foreground
+  end
+  
+  def at_exit
+    yield
+  end
+  private :at_exit
+  
+  def test_install_exit_handler_positive
+    control = mocked_control
+    control.expects(:send_data_on_exit).returns(true)
+    self.expects(:using_rubinius?).returns(false)
+    self.expects(:using_jruby?).returns(false)
+    self.expects(:using_sinatra?).returns(false)
+    # we are overriding at_exit above, to immediately return, so we can
+    # test the shutdown logic. It's somewhat unfortunate, but we can't
+    # kill the interpreter during a test.
+    self.expects(:shutdown)
+    install_exit_handler
+  end
+  
+  def test_install_exit_handler_negative
+    control = mocked_control
+    control.expects(:send_data_on_exit).returns(false)
+    install_exit_handler
+  end
+
+  def test_install_exit_handler_weird_ruby
+    control = mocked_control
+    control.expects(:send_data_on_exit).times(3).returns(true)
+    self.expects(:using_rubinius?).returns(false)
+    self.expects(:using_jruby?).returns(false)
+    self.expects(:using_sinatra?).returns(true)
+    install_exit_handler
+    self.expects(:using_rubinius?).returns(false)
+    self.expects(:using_jruby?).returns(true)
+    install_exit_handler
+    self.expects(:using_rubinius?).returns(true)
+    install_exit_handler
+  end
+
+  def test_notify_log_file_location_positive
+    log = mocked_log
+    NewRelic::Control.instance.expects(:log_file).returns('CHUD CHUD CHUD')
+    log.expects(:send).with(:info, "Agent Log found in CHUD CHUD CHUD")
+    notify_log_file_location
+  end
+
+  def test_notify_log_file_location_negative
+    log = mocked_log
+    NewRelic::Control.instance.expects(:log_file).returns(nil)
+    notify_log_file_location
+  end
+
+  def test_monitoring_positive
+    control = mocked_control
+    control.expects(:monitor_mode?).returns(true)
+    log = mocked_log
+    assert monitoring?
+  end
+
+  def test_monitoring_negative
+    control = mocked_control
+    log = mocked_log
+    control.expects(:monitor_mode?).returns(false)
+    log.expects(:send).with(:warn, "Agent configured not to send data in this environment - edit newrelic.yml to change this")
+    assert !monitoring?
+  end
+
+  def test_has_license_key_positive
+    control = mocked_control
+    control.expects(:license_key).returns("a" * 40)
+    assert has_license_key?
+  end
+
+  def test_has_license_key_negative
+    control = mocked_control
+    control.expects(:license_key).returns(nil)
+    log = mocked_log
+    log.expects(:send).with(:error, 'No license key found.  Please edit your newrelic.yml file and insert your license key.')
+    assert !has_license_key?
+  end
+
+  def test_has_correct_license_key_positive
+    self.expects(:has_license_key?).returns(true)
+    self.expects(:correct_license_length).returns(true)
+    assert has_correct_license_key?
+  end
+
+  def test_has_correct_license_key_negative
+    self.expects(:has_license_key?).returns(false)
+    assert !has_correct_license_key?
+  end
+
+  def test_correct_license_length_positive
+    control = mocked_control
+    control.expects(:license_key).returns("a" * 40)
+    assert correct_license_length
+  end
+
+  def test_correct_license_length_negative
+    control = mocked_control
+    log = mocked_log
+    control.expects(:license_key).returns("a"*30)
+    log.expects(:send).with(:error, "Invalid license key: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
+    assert !correct_license_length
+  end
+
+  def test_using_forking_dispatcher_positive
+    control = mocked_control
+    control.expects(:dispatcher).returns(:passenger)
+    log = mocked_log
+    log.expects(:send).with(:info, "Connecting workers after forking.")
+    assert using_forking_dispatcher?
+  end
+
+  def test_using_forking_dispatcher_negative
+    control = mocked_control
+    control.expects(:dispatcher).returns(:frobnitz)
+    assert !using_forking_dispatcher?
+  end
+
+  def test_log_unless_positive
+    # should not log
+    assert log_unless(true, :warn, "DURRR")
+  end
+  def test_log_unless_negative
+    # should log
+    log = mocked_log
+    log.expects(:send).with(:warn, "DURRR")
+    assert !log_unless(false, :warn, "DURRR")
+  end
+
+  def test_log_if_positive
+    log = mocked_log
+    log.expects(:send).with(:warn, "WHEE")
+    assert log_if(true, :warn, "WHEE")
+  end
+
+  def test_log_if_negative
+    assert !log_if(false, :warn, "WHEE")
+  end
+  
+  private
+
+  def mocked_log
+    fake_log = mock('log')
+    self.stubs(:log).returns(fake_log)
+    fake_log
+  end
+
+
+  def mocked_control
+    fake_control = mock('control')
+    self.stubs(:control).returns(fake_control)
+    fake_control
+  end
+end
+