wd_newrelic_rpm 3.3.4.1

data/test/new_relic/agent/agent/connect_test.rb

@@ -0,0 +1,403 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..', '..', '..','test_helper'))
+class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
+  require 'new_relic/agent/agent'
+  
+  # I don't like this, we should be testing a third party, not ourselves -Jon
+  include NewRelic::Agent::Agent::Connect
+
+  def setup
+    @connected = nil
+    @keep_retrying = nil
+    @connect_attempts = 1
+    @connect_retry_period = 0
+    @transaction_sampler = NewRelic::Agent::TransactionSampler.new
+    @sql_sampler = NewRelic::Agent::SqlSampler.new    
+  end
+
+  def test_tried_to_connect?
+    # base case, should default to false
+    assert !tried_to_connect?({})
+  end
+
+  def test_tried_to_connect_connected
+    # is true if connected is true.
+    @connected = true
+    assert tried_to_connect?({})
+  end
+
+  def test_tried_to_connect_forced
+    # is false if force_reconnect is true
+    assert !tried_to_connect?({:force_reconnect => true})
+  end
+
+  def test_should_keep_retrying_base
+    # default to true
+    should_keep_retrying?({})
+    assert @keep_retrying, "should keep retrying by default"
+  end
+
+  def test_should_keep_retrying_option_true
+    # should be true if keep_retrying is true
+    should_keep_retrying?({:keep_retrying => true})
+  end
+
+  def test_get_retry_period
+    (1..6).each do |x|
+      @connect_attempts = x
+      assert_equal get_retry_period, x * 60, "should be #{x} minutes"
+    end
+    @connect_attempts = 100
+    assert_equal get_retry_period, 600, "should max out at 10 minutes after 6 tries"
+  end
+
+  def test_increment_retry_period
+    @connect_retry_period = 0
+    @connect_attempts = 1
+    assert_equal 0, connect_retry_period
+    increment_retry_period!
+    assert_equal 60, connect_retry_period
+  end
+
+  def test_should_retry_true
+    @keep_retrying = true
+    @connect_attempts = 1
+    log.expects(:info).once
+    self.expects(:increment_retry_period!).once
+    assert should_retry?, "should retry in this circumstance"
+    assert_equal 2, @connect_attempts, "should be on the second attempt"
+  end
+
+  def test_should_retry_false
+    @keep_retrying = false
+    self.expects(:disconnect).once
+    assert !should_retry?
+  end
+
+  def test_disconnect
+    assert disconnect
+  end
+
+  def test_attr_accessor_connect_retry_period
+    assert_accessor(:connect_retry_period)
+  end
+
+  def test_attr_accessor_connect_attempts
+    assert_accessor(:connect_attempts)
+  end
+
+  def test_log_error
+    error = mock('error')
+    error.expects(:backtrace).once.returns(["line", "secondline"])
+    error.expects(:message).once.returns("message")
+    fake_control = mock()
+    fake_control.expects(:server).returns("server")
+    self.expects(:control).once.returns(fake_control)
+    log.expects(:error).with("Error establishing connection with New Relic Service at server: message")
+    log.expects(:debug).with("line\nsecondline")
+    log_error(error)
+  end
+
+  def test_handle_license_error
+    error = mock('error')
+    self.expects(:disconnect).once
+    log.expects(:error).once.with("error message")
+    log.expects(:info).once.with("Visit NewRelic.com to obtain a valid license key, or to upgrade your account.")
+    error.expects(:message).returns("error message")
+    handle_license_error(error)
+  end
+
+  def test_log_seed_token
+    fake_control = mocked_control
+    fake_control.expects(:validate_seed).times(2).returns("many seeds")
+    fake_control.expects(:validate_token).once.returns("a token, man")
+    log.expects(:debug).with("Connecting with validation seed/token: many seeds/a token, man").once
+    log_seed_token
+  end
+
+  def test_no_seed_token
+    fake_control = mocked_control
+    fake_control.expects(:validate_seed).once.returns(nil)
+    log.expects(:debug).never
+    log_seed_token
+  end
+
+  def mocks_for_positive_environment_for_connect(value_for_control)
+    control = mocked_control
+    control.expects(:'[]').with('send_environment_info').once.returns(value_for_control)
+    fake_env = mock('local_env')
+    fake_env.expects(:snapshot).once.returns("snapshot")
+    control.expects(:local_env).once.returns(fake_env)
+  end
+
+  def test_environment_for_connect_nil
+    mocks_for_positive_environment_for_connect(nil)
+    assert_equal 'snapshot', environment_for_connect
+  end
+
+  def test_environment_for_connect_positive
+    mocks_for_positive_environment_for_connect(true)
+    assert_equal 'snapshot', environment_for_connect
+  end
+
+  def test_environment_for_connect_negative
+    control = mocked_control
+    control.expects(:'[]').with('send_environment_info').once.returns(false)
+    assert_equal [], environment_for_connect
+  end
+
+  def test_validate_settings
+    control = mocked_control
+    control.expects(:validate_seed).once
+    control.expects(:validate_token).once
+    assert_equal({:seed => nil, :token => nil}, validate_settings)
+  end
+
+  def test_connect_settings
+    control = mocked_control
+    control.expects(:app_names)
+    control.expects(:settings)
+    self.expects(:validate_settings)
+    self.expects(:environment_for_connect)
+    keys = %w(pid host app_name language agent_version environment settings validate)
+    value = connect_settings
+    keys.each do |k|
+      assert(value.has_key?(k.to_sym), "should include the key #{k}")
+    end
+  end
+
+  def test_configure_error_collector_base
+    fake_collector = mocked_error_collector
+    fake_collector.expects(:config_enabled).returns(false)
+    fake_collector.expects(:enabled=).with(false)
+    log.expects(:debug).with("Errors will not be sent to the New Relic service.")
+    configure_error_collector!(false)
+  end
+
+  def test_configure_error_collector_enabled
+    fake_collector = mocked_error_collector
+    fake_collector.expects(:config_enabled).returns(true)
+    fake_collector.expects(:enabled=).with(true)
+    log.expects(:debug).with("Errors will be sent to the New Relic service.")
+    configure_error_collector!(true)
+  end
+
+  def test_configure_error_collector_server_disabled
+    fake_collector = mocked_error_collector
+    fake_collector.expects(:config_enabled).returns(true)
+    fake_collector.expects(:enabled=).with(false)
+    log.expects(:debug).with("Errors will not be sent to the New Relic service.")
+    configure_error_collector!(false)
+  end
+
+  def test_enable_random_samples
+    sampling_rate = 10
+    ts = @transaction_sampler = mock('ts')
+    ts.expects(:random_sampling=).with(true)
+    ts.expects(:sampling_rate=).with(sampling_rate)
+    ts.expects(:sampling_rate).returns(sampling_rate)
+    log.expects(:info).with("Transaction sampling enabled, rate = 10")
+    enable_random_samples!(sampling_rate)
+  end
+
+  def test_enable_random_samples_with_no_sampling_rate
+    # testing that we set a sane default for sampling rate
+    sampling_rate = 0
+    ts = @transaction_sampler = mock('ts')
+    ts.expects(:random_sampling=).with(true)
+    ts.expects(:sampling_rate=).with(10)
+    ts.expects(:sampling_rate).returns(10)
+    log.expects(:info).with("Transaction sampling enabled, rate = 10")
+    enable_random_samples!(sampling_rate)
+  end
+
+  def test_config_transaction_tracer
+    NewRelic::Control.instance.settings['transaction_tracer'] = {
+      'enabled' => true,
+      'random_sample' => false,
+      'explain_threshold' => 0.75,
+      'explain_enabled' => true
+    }
+
+    config_transaction_tracer
+
+    assert @transaction_sampler.enabled?
+    assert_equal 0.75, @transaction_sampler.explain_threshold
+    assert @transaction_sampler.explain_enabled
+#     assert_equal 1.5, @transaction_sampler.transaction_threshold
+  end
+
+  def test_configure_transaction_tracer_with_random_sampling
+    @config_should_send_samples = true
+    @should_send_random_samples = true
+    @slowest_transaction_threshold = 5
+    log.stubs(:debug)
+    self.expects(:enable_random_samples!).with(10)
+    configure_transaction_tracer!(true, 10)
+    assert @should_send_samples
+    assert_equal 5, @transaction_sampler.slow_capture_threshold
+  end
+
+  def test_configure_transaction_tracer_positive
+    @config_should_send_samples = true
+    @slowest_transaction_threshold = 5
+    log.stubs(:debug)
+    configure_transaction_tracer!(true, 10)
+    assert @should_send_samples
+    assert_equal 5, @transaction_sampler.slow_capture_threshold
+  end
+
+  def test_configure_transaction_tracer_negative
+    @config_should_send_samples = false
+    log.expects(:debug).with('Transaction traces will not be sent to the New Relic service.')
+    configure_transaction_tracer!(true, 10)
+    assert !@should_send_samples
+  end
+
+  def test_configure_transaction_tracer_server_disabled
+    @config_should_send_samples = true
+    log.expects(:debug).with('Transaction traces will not be sent to the New Relic service.')
+    configure_transaction_tracer!(false, 10)
+    assert !@should_send_samples
+  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
+    NewRelic::Control.instance.settings['transaction_tracer'] = { 'transaction_threshold' => 'apdex_f' }
+    assert apdex_f_threshold?
+  end
+
+  def test_apdex_f_threshold_negative
+    NewRelic::Control.instance.settings['transaction_tracer'] = { 'transaction_threshold' => 'WHEE' }
+    assert !apdex_f_threshold?
+  end
+
+  def test_set_sql_recording_default
+    NewRelic::Control.instance.settings['transaction_tracer'] = { }
+    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_off
+    NewRelic::Control.instance.settings['transaction_tracer'] = {'record_sql' => 'off'}
+    self.expects(:log_sql_transmission_warning?)
+    set_sql_recording!
+    assert_equal :off, @record_sql, "should be set to :off, was #{@record_sql}"
+  end
+
+  def test_set_sql_recording_none
+    NewRelic::Control.instance.settings['transaction_tracer'] = {'record_sql' => 'none'}    
+    self.expects(:log_sql_transmission_warning?)
+    set_sql_recording!
+    assert_equal :off, @record_sql, "should be set to :off, was #{@record_sql}"
+  end
+
+  def test_set_sql_recording_raw
+    NewRelic::Control.instance.settings['transaction_tracer'] = {'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_set_sql_recording_falsy
+    NewRelic::Control.instance.settings['transaction_tracer'] = {'record_sql' => false}            
+    self.expects(:log_sql_transmission_warning?)
+    set_sql_recording!
+    assert_equal :off, @record_sql, "should be set to :off, 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(:warn).with('Agent is configured to send raw SQL to the service')
+    log_sql_transmission_warning?
+  end
+
+  def test_set_collector_host_positive
+    control = mocked_control
+    self.expects(:invoke_remote).with(:get_redirect_host).returns('collector-deux.newrelic.com')
+    control.expects(:server_from_host).with('collector-deux.newrelic.com').returns('correct')
+    set_collector_host!
+    assert_equal 'correct', @collector
+  end
+
+  def test_set_collector_host_negative
+    @collector = 'initial value'
+    control = mocked_control
+    self.expects(:invoke_remote).with(:get_redirect_host).returns(nil)
+    set_collector_host!
+    assert_equal 'initial value', @collector, "should not modify collector value"
+  end
+
+  def test_query_server_for_configuration
+    self.expects(:set_collector_host!)
+    self.expects(:connect_to_server).returns("so happy")
+    self.expects(:finish_setup).with("so happy")
+    query_server_for_configuration
+  end
+
+  def test_finish_setup
+    config = {
+      'agent_run_id' => 'fishsticks',
+      'data_report_period' => 'pasta sauce',
+      'url_rules' => 'tamales',
+      'collect_traces' => true,
+      'collect_errors' => true,
+      'sample_rate' => 10
+    }
+    NewRelic::Control.instance.settings['transaction_tracer'] = {'enabled' => true}
+    self.expects(:log_connection!).with(config)
+    self.expects(:configure_transaction_tracer!).with(true, 10)
+    self.expects(:configure_error_collector!).with(true)
+    @transaction_sampler = stub('transaction sampler', :configure! => true,
+                                :config => {})
+    @sql_sampler = stub('sql sampler', :configure! => true)    
+    finish_setup(config)
+    assert_equal 'fishsticks', @agent_id
+    assert_equal 'pasta sauce', @report_period
+    assert_equal 'tamales', @url_rules
+  end
+
+  private
+
+  def mocked_control
+    fake_control = mock('control')
+    self.stubs(:control).returns(fake_control)
+    fake_control
+  end
+
+  def mocked_log
+    fake_log = mock('log')
+    self.stubs(:log).returns(fake_log)
+    fake_log
+  end
+
+  def mocked_error_collector
+    fake_collector = mock('error collector')
+    self.stubs(:error_collector).returns(fake_collector)
+    fake_collector
+  end
+
+  def log
+    @logger ||= Object.new
+  end
+
+  def assert_accessor(sym)
+    var_name = "@#{sym}"
+    instance_variable_set(var_name, 1)
+    assert (self.send(sym) == 1)
+    self.send(sym.to_s + '=', 10)
+    assert (instance_variable_get(var_name) == 10)
+  end
+end

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

@@ -0,0 +1,255 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+class NewRelic::Agent::Agent::StartTest < 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_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)
+    NewRelic::LanguageSupport.expects(:using_engine?).with('rbx').returns(false)
+    NewRelic::LanguageSupport.expects(:using_engine?).with('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)
+    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
+  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
+