wd_newrelic_rpm 3.3.4.1 → 3.5.5

data/test/new_relic/agent/agent/start_test.rb

@@ -3,9 +3,18 @@ class NewRelic::Agent::Agent::StartTest < Test::Unit::TestCase
   require 'new_relic/agent/agent'
   include NewRelic::Agent::Agent::Start
 
+  def setup
+    ENV['NEW_RELIC_APP_NAME'] = 'start_test'
+    NewRelic::Agent.reset_config
+  end
+
+  def teardown
+    ENV['NEW_RELIC_APP_NAME'] = nil
+    NewRelic::Agent.reset_config
+  end
+
   def test_already_started_positive
-    control = mocked_control
-    control.expects(:log!).with("Agent Started Already!", :error)
+    ::Logger.any_instance.expects(:error).with("Agent Started Already!")
     self.expects(:started?).returns(true)
     assert already_started?, "should have already started"
   end
@@ -16,39 +25,15 @@ class NewRelic::Agent::Agent::StartTest < Test::Unit::TestCase
   end
 
   def test_disabled_positive
-    control = mocked_control
-    control.expects(:agent_enabled?).returns(false)
-    assert disabled?
+    with_config(:agent_enabled => false) do
+      assert disabled?
+    end
   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
+    with_config(:agent_enabled => true) do
+      assert !disabled?
+    end
   end
 
   def test_check_config_and_start_agent_disabled
@@ -70,26 +55,20 @@ class NewRelic::Agent::Agent::StartTest < Test::Unit::TestCase
   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
+    with_config(:sync_startup => false, :monitor_mode => true, :license_key => 'a' * 40) do
+      check_config_and_start_agent
+    end
   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
+    with_config(:sync_startup => true, :monitor_mode => true, :license_key => 'a' * 40) do
+      check_config_and_start_agent
+    end
   end
 
   def test_connect_in_foreground
@@ -103,8 +82,6 @@ class NewRelic::Agent::Agent::StartTest < Test::Unit::TestCase
   private :at_exit
 
   def test_install_exit_handler_positive
-    control = mocked_control
-    control.expects(:send_data_on_exit).returns(true)
     NewRelic::LanguageSupport.expects(:using_engine?).with('rbx').returns(false)
     NewRelic::LanguageSupport.expects(:using_engine?).with('jruby').returns(false)
     self.expects(:using_sinatra?).returns(false)
@@ -112,69 +89,54 @@ class NewRelic::Agent::Agent::StartTest < Test::Unit::TestCase
     # test the shutdown logic. It's somewhat unfortunate, but we can't
     # kill the interpreter during a test.
     self.expects(:shutdown)
-    install_exit_handler
+    with_config(:send_data_on_exit => true) do
+      install_exit_handler
+    end
   end
 
   def test_install_exit_handler_negative
-    control = mocked_control
-    control.expects(:send_data_on_exit).returns(false)
-    install_exit_handler
+    with_config(:send_data_on_exit => false) do
+      install_exit_handler
+    end
+    # should not raise excpetion
   end
 
   def test_install_exit_handler_weird_ruby
-    control = mocked_control
-    control.expects(:send_data_on_exit).times(3).returns(true)
-    NewRelic::LanguageSupport.expects(:using_engine?).with('rbx').returns(false)
-    NewRelic::LanguageSupport.expects(:using_engine?).with('jruby').returns(false)
-    self.expects(:using_sinatra?).returns(true)
-    install_exit_handler
-    NewRelic::LanguageSupport.expects(:using_engine?).with('rbx').returns(false)
-    NewRelic::LanguageSupport.expects(:using_engine?).with('jruby').returns(true)
-    install_exit_handler
-    NewRelic::LanguageSupport.expects(:using_engine?).with('rbx').returns(true)
-    install_exit_handler
-  end
-
-  def test_notify_log_file_location_positive
-    log = mocked_log
-    NewRelic::Control.instance.expects(:log_file).returns('./')
-    log.expects(:send).with(:info, "Agent Log at ./")
-    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
+    with_config(:send_data_one_exit => true) do
+      NewRelic::LanguageSupport.expects(:using_engine?).with('rbx').returns(false)
+      NewRelic::LanguageSupport.expects(:using_engine?).with('jruby').returns(false)
+      self.expects(:using_sinatra?).returns(true)
+      install_exit_handler
+      NewRelic::LanguageSupport.expects(:using_engine?).with('rbx').returns(false)
+      NewRelic::LanguageSupport.expects(:using_engine?).with('jruby').returns(true)
+      install_exit_handler
+      NewRelic::LanguageSupport.expects(:using_engine?).with('rbx').returns(true)
+      install_exit_handler
+    end
   end
 
   def test_monitoring_positive
-    control = mocked_control
-    control.expects(:monitor_mode?).returns(true)
-    log = mocked_log
-    assert monitoring?
+    with_config(:monitor_mode => true) do
+      assert monitoring?
+    end
   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?
+    with_config(:monitor_mode => false) do
+      assert !monitoring?
+    end
   end
 
   def test_has_license_key_positive
-    control = mocked_control
-    control.expects(:license_key).returns("a" * 40)
-    assert has_license_key?
+    with_config(:license_key => 'a' * 40) do
+      assert has_license_key?
+    end
   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?
+    with_config(:license_key => false) do
+      assert !has_license_key?
+    end
   end
 
   def test_has_correct_license_key_positive
@@ -189,47 +151,42 @@ class NewRelic::Agent::Agent::StartTest < Test::Unit::TestCase
   end
 
   def test_correct_license_length_positive
-    control = mocked_control
-    control.expects(:license_key).returns("a" * 40)
-    assert correct_license_length
+    with_config(:license_key => 'a' * 40) do
+      assert correct_license_length
+    end
   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
+    with_config(:license_key => 'a' * 30) do
+      assert !correct_license_length
+    end
   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?
+    with_config(:dispatcher => :passenger) do
+      assert using_forking_dispatcher?
+    end
   end
 
   def test_using_forking_dispatcher_negative
-    control = mocked_control
-    control.expects(:dispatcher).returns(:frobnitz)
-    assert !using_forking_dispatcher?
+    with_config(:dispatcher => :frobnitz) do
+      assert !using_forking_dispatcher?
+    end
   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")
+    expects_logging(:warn, "DURRR")
     assert !log_unless(false, :warn, "DURRR")
   end
 
   def test_log_if_positive
-    log = mocked_log
-    log.expects(:send).with(:warn, "WHEE")
+    expects_logging(:warn, "WHEE")
     assert log_if(true, :warn, "WHEE")
   end
 
@@ -239,13 +196,6 @@ class NewRelic::Agent::Agent::StartTest < Test::Unit::TestCase
 
   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)

data/test/new_relic/agent/agent/start_worker_thread_test.rb

@@ -7,8 +7,6 @@ class NewRelic::Agent::Agent::StartWorkerThreadTest < Test::Unit::TestCase
     self.expects(:catch_errors).yields
     self.expects(:connect).with('connection_options')
     @connected = true
-    self.expects(:check_transaction_sampler_status)
-    self.expects(:check_sql_sampler_status)    
     self.expects(:log_worker_loop_start)
     self.expects(:create_and_run_worker_loop)
     deferred_work!('connection_options')
@@ -18,62 +16,24 @@ class NewRelic::Agent::Agent::StartWorkerThreadTest < Test::Unit::TestCase
     self.expects(:catch_errors).yields
     self.expects(:connect).with('connection_options')
     @connected = false
-    fake_log = mocked_log
-    fake_log.expects(:debug).with("No connection.  Worker thread ending.")
     deferred_work!('connection_options')
   end
 
-  def test_check_transaction_sampler_status_enabled
-    control = mocked_control
-    control.expects(:developer_mode?).returns(false)
-    @should_send_samples = true
-    @transaction_sampler = mock('transaction_sampler')
-    @transaction_sampler.expects(:enable)
-    check_transaction_sampler_status
-  end
-
-  def test_check_transaction_sampler_status_devmode
-    control = mocked_control
-    control.expects(:developer_mode?).returns(true)
-    @should_send_samples = false
-    @transaction_sampler = mock('transaction_sampler')
-    @transaction_sampler.expects(:enable)
-    check_transaction_sampler_status
-  end
-
-  def test_check_transaction_sampler_status_disabled
-    control = mocked_control
-    control.expects(:developer_mode?).returns(false)
-    @should_send_samples = false
-    @transaction_sampler = mock('transaction_sampler')
-    @transaction_sampler.expects(:disable)
-    check_transaction_sampler_status
-  end
-
-  def test_log_worker_loop_start
-    @report_period = 30
-    log = mocked_log
-    log.expects(:info).with("Reporting performance data every 30 seconds.")
-    log.expects(:debug).with("Running worker loop")
-    log_worker_loop_start
-  end
-
   def test_create_and_run_worker_loop
-    @report_period = 30
     @should_send_samples = true
     wl = mock('worker loop')
     NewRelic::Agent::WorkerLoop.expects(:new).returns(wl)
     wl.expects(:run).with(30).yields
-    self.expects(:save_or_transmit_data)
-    create_and_run_worker_loop
+    self.expects(:transmit_data)
+    with_config(:data_report_period => 30) do
+      create_and_run_worker_loop
+    end
   end
 
   def test_handle_force_restart
     # hooray for methods with no branches
-    error = mock('exception')
-    log = mocked_log
-    error.expects(:message).returns('a message')
-    log.expects(:info).with('a message')
+    error = mock(:message => 'a message')
+
     self.expects(:reset_stats)
     self.expects(:sleep).with(30)
 
@@ -87,37 +47,22 @@ class NewRelic::Agent::Agent::StartWorkerThreadTest < Test::Unit::TestCase
   end
 
   def test_handle_force_disconnect
-    error = mock('exception')
-    error.expects(:message).returns('a message')
-    log = mocked_log
-    log.expects(:error).with("New Relic forced this agent to disconnect (a message)")
+    error = mock(:message => 'a message')
+
     self.expects(:disconnect)
     handle_force_disconnect(error)
   end
 
   def test_handle_server_connection_problem
-    error_class = mock('class of exception')
-    error = mock('exception')
-    log = mocked_log
-    log.expects(:error).with('Unable to establish connection with the server.  Run with log level set to debug for more information.')
-    error.expects(:class).returns(error_class)
-    error_class.expects(:name).returns('an error class')
-    error.expects(:message).returns('a message')
-    error.expects(:backtrace).returns(['first line', 'second line'])
-    log.expects(:debug).with("an error class: a message\nfirst line")
+    error = StandardError.new('a message')
+
     self.expects(:disconnect)
     handle_server_connection_problem(error)
   end
 
   def test_handle_other_error
-    error_class = mock('class of exception')
-    error = mock('exception')
-    log = mocked_log
-    error.expects(:class).returns(error_class)
-    error_class.expects(:name).returns('an error class')
-    error.expects(:message).returns('a message')
-    error.expects(:backtrace).returns(['first line', 'second line'])
-    log.expects(:error).with("Terminating worker loop: an error class: a message\n  first line\n  second line")
+    error = StandardError.new('a message')
+
     self.expects(:disconnect)
     handle_other_error(error)
   end
@@ -137,13 +82,6 @@ class NewRelic::Agent::Agent::StartWorkerThreadTest < Test::Unit::TestCase
 
   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)

data/test/new_relic/agent/agent_logger_test.rb

@@ -0,0 +1,153 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+require 'new_relic/agent/agent_logger'
+
+class AgentLoggerTest < Test::Unit::TestCase
+  def setup
+    @config = {
+      :log_file_path => "log/",
+      :log_file_name => "testlog.log",
+      :log_level => :info,
+    }
+  end
+
+  def test_initalizes_from_config
+    override_logger = stub(:level=)
+    ::Logger.stubs(:new).with(any_parameters).returns(override_logger)
+
+    logger = NewRelic::Agent::AgentLogger.new(@config)
+    assert_equal(override_logger, logger.instance_variable_get(:@log))
+  end
+
+  def test_initalizes_from_override
+    override_logger = stub(:level=)
+    logger = NewRelic::Agent::AgentLogger.new(@config, "", override_logger)
+    assert_equal override_logger, logger.instance_variable_get(:@log)
+  end
+
+  def test_forwards_calls_to_logger
+    [:fatal, :error, :warn, :info, :debug].each do |level|
+      override_logger = stub(:level=)
+      override_logger.expects(level).with(any_parameters)
+
+      logger = NewRelic::Agent::AgentLogger.new(@config, "", override_logger)
+
+      logger.send(level, "Boo!")
+    end
+  end
+
+
+  def test_forwards_calls_to_logger_with_multiple_arguments
+    [:fatal, :error, :warn, :info, :debug].each do |level|
+      override_logger = stub(:level=)
+      override_logger.expects(level).with("What\nup?")
+
+      logger = NewRelic::Agent::AgentLogger.new(@config, "", override_logger)
+
+      logger.send(level, "What", "up?")
+    end
+  end
+
+  def test_passing_exceptions_gets_pretty_formatting
+    caught = nil
+    begin
+      raise Exception.new("Boo!")
+    rescue Exception => e
+      caught = e
+    end
+
+    # Checking if it looks like message includes backtrace
+    override_logger = stub(:level=)
+    override_logger.expects(:debug).with {|msg| msg.include?("test_") }
+
+    NewRelic::Agent::AgentLogger.new(@config, "", override_logger).debug(e)
+  end
+
+  def test_wont_log_if_agent_not_enabled
+    ::Logger.stubs(:new).with("/dev/null").returns(stub(:level=)).at_least_once
+
+    @config[:agent_enabled] = false
+    logger = NewRelic::Agent::AgentLogger.new(@config)
+  end
+
+  def test_logs_to_nul_if_dev_null_not_there
+    File.stubs(:exists?).with("/dev/null").returns(false)
+    File.stubs(:exists?).with("NUL").returns(true)
+
+    ::Logger.stubs(:new).with("NUL").returns(stub(:level=)).once
+
+    @config[:agent_enabled] = false
+    logger = NewRelic::Agent::AgentLogger.new(@config)
+  end
+
+  def test_maps_log_levels
+    assert_equal Logger::FATAL, NewRelic::Agent::AgentLogger.log_level_for(:fatal)
+    assert_equal Logger::ERROR, NewRelic::Agent::AgentLogger.log_level_for(:error)
+    assert_equal Logger::WARN,  NewRelic::Agent::AgentLogger.log_level_for(:warn)
+    assert_equal Logger::INFO,  NewRelic::Agent::AgentLogger.log_level_for(:info)
+    assert_equal Logger::DEBUG, NewRelic::Agent::AgentLogger.log_level_for(:debug)
+
+    assert_equal Logger::INFO, NewRelic::Agent::AgentLogger.log_level_for("")
+    assert_equal Logger::INFO, NewRelic::Agent::AgentLogger.log_level_for(:unknown)
+  end
+
+  def test_sets_log_level
+    override_logger = mock()
+    override_logger.expects(:level=).with(Logger::DEBUG)
+    @config[:log_level] = :debug
+
+    logger = NewRelic::Agent::AgentLogger.new(@config, "", override_logger)
+  end
+
+  def test_log_to_stdout_and_warns_if_failed_on_create
+    NewRelic::Agent::AgentLogger.any_instance.stubs(:find_or_create_file_path).returns(nil)
+
+    stdout = stub(:level=)
+    stdout.expects(:warn)
+    ::Logger.stubs(:new).with(STDOUT).returns(stdout)
+
+    logger = NewRelic::Agent::AgentLogger.new(@config)
+    assert_equal stdout, logger.instance_variable_get(:@log)
+  end
+
+  def test_log_to_stdout_based_on_config
+    @config[:log_file_path] = "STDOUT"
+
+    stdout = stub(:level=)
+    stdout.expects(:warn).never
+    ::Logger.stubs(:new).with(STDOUT).returns(stdout)
+
+    logger = NewRelic::Agent::AgentLogger.new(@config)
+    assert_equal stdout, logger.instance_variable_get(:@log)
+  end
+
+  def test_startup_purges_memory_logger
+    [:fatal, :error, :warn, :info, :debug].each do |level|
+      ::NewRelic::Agent::StartupLogger.instance.send(level, "boo!")
+
+      override_logger = stub(:level=)
+      override_logger.expects(level).with("boo!")
+
+      NewRelic::Agent::AgentLogger.new(@config, "", override_logger)
+    end
+  end
+
+  def test_format_message_allows_nil_backtrace
+    override_logger = stub(:level=)
+    override_logger.expects(:debug)
+
+    logger = ::NewRelic::Agent::AgentLogger.new(@config, "", override_logger)
+
+    logger.debug(Exception.new("Look Ma, no backtrace!"))
+  end
+
+
+  def test_logs_to_stdout_if_fails_on_file
+    stdout = stub_everything()
+    ::Logger.stubs(:new).with(STDOUT).returns(stdout)
+    ::Logger.stubs(:new).with(instance_of(String)).raises(Errno::EACCES)
+
+    logger = NewRelic::Agent::AgentLogger.new(@config, "")
+
+    assert_equal stdout, logger.instance_variable_get(:@log)
+  end
+end