newrelic_rpm 3.5.4.35.beta → 3.5.5.38

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

@@ -16,20 +16,9 @@ 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_log_worker_loop_start
-    log = mocked_log
-    log.expects(:info).with("Reporting performance data every 30 seconds.")
-    log.expects(:debug).with("Running worker loop")
-    with_config(:data_report_period => 30) do
-      log_worker_loop_start
-    end
-  end
-
   def test_create_and_run_worker_loop
     @should_send_samples = true
     wl = mock('worker loop')
@@ -43,10 +32,8 @@ class NewRelic::Agent::Agent::StartWorkerThreadTest < Test::Unit::TestCase
 
   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)
 
@@ -60,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
@@ -110,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

data/test/new_relic/agent/agent_test.rb

@@ -127,11 +127,7 @@ module NewRelic
 
       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)
+        assert_equal(1, @agent.service.calls_for(:get_agent_commands).size)
       end
 
       def test_merge_data_from_empty
@@ -204,10 +200,15 @@ module NewRelic
         @agent.merge_data_from([{}, [1,2,3], [4,5,6]])
       end
 
-      def test_should_not_log_log_file_location_if_no_log_file
-        NewRelic::Control.instance.stubs(:log_file).returns('/vasrkjn4b3b4')
-        @agent.expects(:log).never
-        @agent.notify_log_file_location
+      def test_fill_metric_id_cache_from_collect_response
+        response = [[{"scope"=>"Controller/blogs/index", "name"=>"Database/SQL/other"}, 1328],
+                    [{"scope"=>"", "name"=>"WebFrontend/QueueTime"}, 10],
+                    [{"scope"=>"", "name"=>"ActiveRecord/Blog/find"}, 1017]]
+
+        @agent.send(:fill_metric_id_cache, response)
+        assert_equal 1328, @agent.metric_ids[MetricSpec.new('Database/SQL/other', 'Controller/blogs/index')]
+        assert_equal 10,   @agent.metric_ids[MetricSpec.new('WebFrontend/QueueTime')]
+        assert_equal 1017, @agent.metric_ids[MetricSpec.new('ActiveRecord/Blog/find')]
       end
 
       def test_fill_metric_id_cache_from_collect_response

data/test/new_relic/agent/audit_logger_test.rb

@@ -0,0 +1,105 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+require 'new_relic/agent/audit_logger'
+
+class AuditLoggerTest < Test::Unit::TestCase
+  def setup
+    @config = {
+      :'audit_log.enabled' => true
+    }
+    @uri = "http://really.notreal"
+    @marshaller = NewRelic::Agent::NewRelicService::Marshaller.new
+    @hostname = 'dummyhost'
+    @dummy_data = {
+      'foo' => [1, 2, 3],
+      'bar' => {
+        'baz' => 'qux',
+        'jingle' => 'bells'
+      }
+    }
+    Socket.stubs(:gethostname).returns(@hostname)
+  end
+
+  def setup_fake_logger
+    @fakelog = StringIO.new
+    @logger = NewRelic::Agent::AuditLogger.new(@config)
+    @logger.stubs(:ensure_log_path).returns(@fakelog)
+  end
+
+  def assert_log_contains_string(str)
+    @fakelog.rewind
+    log_body = @fakelog.read
+    assert(log_body.include?(str), "Expected log to contain string '#{str}'")
+  end
+
+  def test_never_setup_if_disabled
+    config = { :'audit_log.enabled' => false }
+    logger = NewRelic::Agent::AuditLogger.new(config)
+    logger.log_request(@uri, "hi there", @marshaller)
+    assert(!logger.setup?, "Expected logger to not have been setup")
+  end
+
+  def test_never_prepare_if_disabled
+    config = { :'audit_log.enabled' => false }
+    logger = NewRelic::Agent::AuditLogger.new(config)
+    marshaller = NewRelic::Agent::NewRelicService::Marshaller.new
+    marshaller.expects(:prepare).never
+    logger.log_request(@uri, "hi there", @marshaller)
+  end
+
+  def test_log_formatter
+    formatter = NewRelic::Agent::AuditLogger.new(@config).log_formatter
+    time = '2012-01-01 00:00:00'
+    msg = 'hello'
+    result = formatter.call(Logger::INFO, time, 'bleh', msg)
+    expected = "[2012-01-01 00:00:00 #{@hostname} (#{$$})] : hello\n"
+    assert_equal(expected, result)
+  end
+
+  def test_ensure_path_returns_nil_with_bogus_path
+    opts = { :'audit_log.path' => '/really/really/not/a/path' }
+    FileUtils.stubs(:mkdir_p).raises(SystemCallError, "i'd rather not")
+    logger = NewRelic::Agent::AuditLogger.new(@config.merge(opts))
+    assert_nil(logger.ensure_log_path)
+  end
+
+  def test_log_request_captures_system_call_errors
+    logger = NewRelic::Agent::AuditLogger.new(@config)
+    dummy_sink = StringIO.new
+    dummy_sink.stubs(:write).raises(SystemCallError, "nope")
+    logger.stubs(:ensure_log_path).returns(dummy_sink)
+
+    # In 1.9.2 and later, Logger::LogDevice#write captures any errors during
+    # writing and spits them out with Kernel#warn.
+    # This just silences that output to keep the test output uncluttered.
+    Logger::LogDevice.any_instance.stubs(:warn)
+
+    assert_nothing_raised do
+      logger.log_request(@uri, 'whatever', @marshaller)
+    end
+  end
+
+  def test_prepares_data_with_identity_encoder
+    setup_fake_logger
+    data = { 'foo' => 'bar' }
+    identity_encoder = NewRelic::Agent::NewRelicService::Encoders::Identity
+    @marshaller.expects(:prepare).with(data, { :encoder => identity_encoder })
+    @logger.log_request(@uri, data, @marshaller)
+  end
+
+  def test_logs_inspect_with_pruby_marshaller
+    setup_fake_logger
+    pruby_marshaller = NewRelic::Agent::NewRelicService::PrubyMarshaller.new
+    @logger.log_request(@uri, @dummy_data, pruby_marshaller)
+    assert_log_contains_string(@dummy_data.inspect)
+  end
+
+  def test_logs_json_with_json_marshaller
+    marshaller_cls = NewRelic::Agent::NewRelicService::JsonMarshaller
+    if marshaller_cls.is_supported?
+      setup_fake_logger
+      json_marshaller = marshaller_cls.new
+      @logger.log_request(@uri, @dummy_data, json_marshaller)
+      assert_log_contains_string(JSON.dump(@dummy_data))
+    end
+  end
+end

data/test/new_relic/agent/browser_monitoring_test.rb

@@ -17,7 +17,8 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
       :application_id         => '5, 6', # collector can return app multiple ids
       :'rum.enabled'          => true,
       :episodes_file          => 'this_is_my_file',
-      :'rum.jsonp'            => true
+      :'rum.jsonp'            => true,
+      :license_key            => 'a' * 40
     }
     NewRelic::Agent.config.apply_config(@config)
     @episodes_file = "this_is_my_file"

data/test/new_relic/agent/busy_calculator_test.rb

@@ -78,4 +78,11 @@ class NewRelic::Agent::BusyCalculatorTest < Test::Unit::TestCase
     NewRelic::Agent::BusyCalculator.harvest_busy
     assert_equal 3, @instance_busy.call_count
   end
+  def test_can_turn_off_recording
+    with_config(:report_instance_busy => false) do
+      assert_equal 0, @instance_busy.call_count, "Problem with test--instance busy not starting off at zero."
+      NewRelic::Agent::BusyCalculator.harvest_busy
+      assert_equal 0, @instance_busy.call_count
+    end
+  end
 end

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

@@ -3,16 +3,31 @@ require 'new_relic/agent/configuration/environment_source'
 
 module NewRelic::Agent::Configuration
   class EnvironmentSourceTest < Test::Unit::TestCase
+
+    def setup
+      @original_env = {}
+      @original_env.replace(ENV)
+    end
+
+    def teardown
+      ENV.replace(@original_env)
+    end
+
     def test_environment_strings_are_applied
       assert_applied_string 'NRCONFIG', 'config_path'
       assert_applied_string 'NEW_RELIC_LICENSE_KEY', 'license_key'
       assert_applied_string 'NEWRELIC_LICENSE_KEY', 'license_key'
       assert_applied_string 'NEW_RELIC_APP_NAME', 'app_name'
       assert_applied_string 'NEWRELIC_APP_NAME', 'app_name'
-      assert_applied_string 'NEW_RELIC_DISPATCHER', 'dispatcher'
-      assert_applied_string 'NEWRELIC_DISPATCHER', 'dispatcher'
-      assert_applied_string 'NEW_RELIC_FRAMEWORK', 'framework'
-      assert_applied_string 'NEWRELIC_FRAMEWORK', 'framework'
+      assert_applied_string 'NEW_RELIC_HOST', 'host'
+      assert_applied_string 'NEW_RELIC_PORT', 'port'
+    end
+
+    def test_environment_symbols_are_applied
+      assert_applied_symbol 'NEW_RELIC_DISPATCHER', 'dispatcher'
+      assert_applied_symbol 'NEWRELIC_DISPATCHER', 'dispatcher'
+      assert_applied_symbol 'NEW_RELIC_FRAMEWORK', 'framework'
+      assert_applied_symbol 'NEWRELIC_FRAMEWORK', 'framework'
     end
 
     def test_environment_booleans_truths_are_applied
@@ -49,26 +64,16 @@ 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]
       ENV.delete(env_var)
     end
+
+    def assert_applied_symbol(env_var, config_var)
+      ENV[env_var] = 'test value'
+      assert_equal :'test value', EnvironmentSource.new[config_var.to_sym]
+      ENV.delete(env_var)
+    end
   end
 end