newrelic_rpm 4.1.0.333 → 4.2.0.334

data/test/new_relic/agent/audit_logger_test.rb

@@ -1,208 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
-require 'new_relic/agent/audit_logger'
-require 'new_relic/agent/null_logger'
-
-class AuditLoggerTest < Minitest::Test
-  def setup
-    NewRelic::Agent.config.add_config_for_testing(:'audit_log.enabled' => true)
-
-    @uri = "http://really.notreal"
-    @marshaller = NewRelic::Agent::NewRelicService::Marshaller.new
-    @dummy_data = {
-      'foo' => [1, 2, 3],
-      'bar' => {
-        'baz' => 'qux',
-        'jingle' => 'bells'
-      }
-    }
-  end
-
-  def teardown
-    NewRelic::Agent.config.reset_to_defaults
-    NewRelic::Agent::Hostname.instance_variable_set(:@hostname, nil)
-  end
-
-  def setup_fake_logger
-    @fakelog = StringIO.new
-    @logger = NewRelic::Agent::AuditLogger.new
-    @logger.stubs(:ensure_log_path).returns(@fakelog)
-  end
-
-  def setup_fake_logger_with_failure(error)
-    setup_fake_logger
-    @logger.stubs(:enabled?).raises(error)
-  end
-
-  def assert_log_contains_string(str)
-    log_body = read_log_body
-    assert(log_body.include?(str), "Expected log to contain string '#{str}'\nLog body was: #{log_body}")
-  end
-
-  def read_log_body
-    @fakelog.rewind
-    @fakelog.read
-  end
-
-  def test_never_setup_if_disabled
-    with_config(:'audit_log.enabled' => false) do
-      logger = NewRelic::Agent::AuditLogger.new
-      logger.log_request(@uri, "hi there", @marshaller)
-      assert(!logger.setup?, "Expected logger to not have been setup")
-    end
-  end
-
-  def test_never_prepare_if_disabled
-    with_config(:'audit_log.enabled' => false) do
-      logger = NewRelic::Agent::AuditLogger.new
-      marshaller = NewRelic::Agent::NewRelicService::Marshaller.new
-      marshaller.expects(:prepare).never
-      logger.log_request(@uri, "hi there", @marshaller)
-    end
-  end
-
-  def test_log_formatter
-    NewRelic::Agent::Hostname.instance_variable_set(:@hostname, nil)
-    Socket.stubs(:gethostname).returns('dummyhost')
-    formatter = NewRelic::Agent::AuditLogger.new.create_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 dummyhost (#{$$})] : hello\n"
-    assert_equal(expected, result)
-  end
-
-  def test_log_formatter_to_stdout
-    with_config(:'audit_log.path' => "STDOUT") do
-      NewRelic::Agent::Hostname.instance_variable_set(:@hostname, nil)
-      Socket.stubs(:gethostname).returns('dummyhost')
-      formatter = NewRelic::Agent::AuditLogger.new.create_log_formatter
-      time = '2012-01-01 00:00:00'
-      msg = 'hello'
-      result = formatter.call(Logger::INFO, time, 'bleh', msg)
-      expected = "** [NewRelic][2012-01-01 00:00:00 dummyhost (#{$$})] : hello\n"
-      assert_equal(expected, result)
-    end
-  end
-
-  def test_ensure_path_returns_nil_with_bogus_path
-    with_config(:'audit_log.path' => '/really/really/not/a/path') do
-      FileUtils.stubs(:mkdir_p).raises(SystemCallError, "i'd rather not")
-      logger = NewRelic::Agent::AuditLogger.new
-      assert_nil(logger.ensure_log_path)
-    end
-  end
-
-  def test_setup_logger_creates_null_logger_when_ensure_path_fails
-    null_logger = NewRelic::Agent::NullLogger.new
-    NewRelic::Agent::NullLogger.expects(:new).returns(null_logger)
-    logger = NewRelic::Agent::AuditLogger.new
-    logger.stubs(:ensure_log_path).returns(nil)
-
-    logger.setup_logger
-    logger.log_request(@uri, 'whatever', @marshaller)
-  end
-
-  def test_log_request_captures_system_call_errors
-    logger = NewRelic::Agent::AuditLogger.new
-    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)
-
-    logger.log_request(@uri, 'whatever', @marshaller)
-  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_json_with_json_marshaller
-    marshaller_cls = NewRelic::Agent::NewRelicService::JsonMarshaller
-    setup_fake_logger
-    json_marshaller = marshaller_cls.new
-    @logger.log_request(@uri, @dummy_data, json_marshaller)
-    assert_audit_log_contains_object(read_log_body, @dummy_data, :json)
-  end
-
-  def test_allows_through_endpoints
-    fake_metrics = { 'metric' => 'yup' }
-    with_config(:'audit_log.endpoints' => ['metric_data']) do
-      setup_fake_logger
-      @logger.log_request('host/metric_data', fake_metrics, @marshaller)
-      assert_log_contains_string(fake_metrics.inspect)
-    end
-  end
-
-  def test_filters_endpoints
-    fake_txn = { 'txn' => 'nope' }
-    with_config(:'audit_log.endpoints' => ['metric_data']) do
-      setup_fake_logger
-      @logger.log_request('host/transaction_sample_data', fake_txn, @marshaller)
-      assert_empty read_log_body
-    end
-  end
-
-  def test_should_cache_hostname
-    NewRelic::Agent::Hostname.instance_variable_set(:@hostname, nil)
-    Socket.expects(:gethostname).once.returns('cachey-mccaherson')
-    setup_fake_logger
-    3.times do
-      @logger.log_request(@uri, @dummy_data, @marshaller)
-    end
-    assert_log_contains_string('cachey-mccaherson')
-  end
-
-  TRAPPABLE_ERRORS = [
-    StandardError.new,
-    SystemStackError.new,
-    SystemCallError.new("Syscalls FTW")
-  ]
-
-  TRAPPABLE_ERRORS.each do |error|
-    define_method("test_traps_#{error.class}") do
-      setup_fake_logger_with_failure(error)
-      @logger.log_request(@uri, @dummy_data, @marshaller)
-      assert_empty read_log_body
-    end
-  end
-
-  def test_allows_other_exceptions_through
-    setup_fake_logger_with_failure(Exception.new)
-    assert_raises(Exception) do
-      @logger.log_request(@uri, @dummy_data, @marshaller)
-    end
-  end
-
-  def test_writes_to_stdout
-    with_config(:'audit_log.path' => "STDOUT") do
-      output = capturing_stdout do
-        @logger = NewRelic::Agent::AuditLogger.new
-        @logger.log_request(@uri, @dummy_data, @marshaller)
-      end
-
-      assert_includes output, @dummy_data.inspect
-    end
-  end
-
-  def capturing_stdout
-    orig = $stdout.dup
-    output = ""
-    $stdout = StringIO.new(output)
-    yield
-    output
-  ensure
-    $stdout = orig
-  end
-end

data/test/new_relic/agent/autostart_test.rb

@@ -1,79 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
-require 'new_relic/agent/autostart'
-
-class AutostartTest < Minitest::Test
-
-  def test_typically_the_agent_should_autostart
-    assert ::NewRelic::Agent::Autostart.agent_should_start?
-  end
-
-  if defined?(::Rails)
-    def test_agent_wont_autostart_if_RAILS_CONSOLE_constant_is_defined
-      assert !defined?(::Rails::Console), "precondition: Rails::Console shouldn't be defined"
-      Rails.const_set(:Console, Class.new)
-      assert ! ::NewRelic::Agent::Autostart.agent_should_start?, "Agent shouldn't autostart in Rails Console session"
-    ensure
-      Rails.send(:remove_const, :Console)
-    end
-  else
-    puts "Skipping tests in #{__FILE__} because Rails is unavailable"
-  end
-
-  def test_agent_will_autostart_if_global_CONSOLE_constant_is_defined
-    Object.const_set(:Console, Class.new)
-    assert ::NewRelic::Agent::Autostart.agent_should_start?, "Agent shouldn't find ::Console"
-  ensure
-    Object.send(:remove_const, :Console)
-  end
-
-  def test_agent_wont_start_if_dollar_0_is_irb
-    @orig_dollar_0, $0 = $0, '/foo/bar/irb'
-    assert ! ::NewRelic::Agent::Autostart.agent_should_start?, "Agent shouldn't autostart when process is invoked by irb"
-  ensure
-    $0 = @orig_dollar_0
-  end
-
-  RAILS_DEFAULT_RAKE_TASKS = %w| about assets:clean assets:clobber
-  assets:environment assets:precompile db:create db:drop db:fixtures:load
-  db:migrate db:migrate:status db:rollback db:schema:cache:clear
-  db:schema:cache:dump db:schema:dump db:schema:load db:seed db:setup
-  db:structure:dump db:version doc:app log:clear middleware notes notes:custom
-  rails:template rails:update routes secret spec spec:features spec:requests
-  spec:controllers spec:helpers spec:models spec:views spec:routing
-  spec:rcov stats test test:all test:all:db test:recent test:single
-  test:uncommitted time:zones:all tmp:clear tmp:create |.each do |task|
-
-    define_method("test_agent_wont_autostart_if_top_level_rake_task_is_#{task}") do
-      Rake.stubs(:application => stub(:top_level_tasks => [task]))
-      assert ! ::NewRelic::Agent::Autostart.agent_should_start?, "Agent shouldn't start during #{task.inspect} rake task"
-    end
-  end
-
-
-  MyConst = true
-  def test_blacklisted_constants_can_be_configured
-    with_config('autostart.blacklisted_constants' => "IRB,::AutostartTest::MyConst") do
-      assert ! ::NewRelic::Agent::Autostart.agent_should_start?, "Agent shouldn't autostart when environment contains blacklisted constant"
-    end
-  end
-
-  def test_blacklisted_executable_can_be_configured
-    @orig_dollar_0, $0 = $0, '/foo/bar/baz'
-    with_config('autostart.blacklisted_executables' => 'boo,baz') do
-      assert ! ::NewRelic::Agent::Autostart.agent_should_start?, "Agent shouldn't autostart when process is invoked by blacklisted executable"
-    end
-  ensure
-    $0 = @orig_dollar_0
-  end
-
-  def test_blacklisted_rake_tasks_can_be_configured
-    with_config('autostart.blacklisted_rake_tasks' => 'foo,bar,baz:bang') do
-      Rake.stubs(:application => stub(:top_level_tasks => ['biz', 'baz:bang']))
-      assert ! ::NewRelic::Agent::Autostart.agent_should_start?, "Agent shouldn't during blacklisted rake task"
-    end
-  end
-end

data/test/new_relic/agent/aws_info_test.rb

@@ -1,76 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
-require 'new_relic/agent/aws_info'
-
-module NewRelic::Agent
-  class AWSInfoTest < Minitest::Test
-
-    def setup
-      NewRelic::Agent.drop_buffered_data
-    end
-
-    test_cases = load_cross_agent_test("aws")
-    test_cases.each do |test_case|
-      testname, uris, expected_vendors_hash, expected_metrics = test_case.values_at 'testname', 'uris', 'expected_vendors_hash', 'expected_metrics'
-
-      define_method("test_#{testname.gsub(/\W/, "_")}") do
-        stub_responses(uris)
-        assert_valid_vendors_hash(expected_vendors_hash)
-        assert_metrics_recorded(expected_metrics) if expected_metrics
-      end
-    end
-
-    def test_assert_logging_with_invalid_data
-      Net::HTTP.stubs(:get).returns("j" * 1000)
-
-      NewRelic::Agent.logger.stubs(:debug)
-      NewRelic::Agent.logger.expects(:debug).with(anything)
-
-      AWSInfo.new
-    end
-
-    def method_from_uri(uri)
-      uri.split("/").last.tr("-", "_")
-    end
-
-    def stub_responses(uris)
-      uris.each_pair do |uri, attrs|
-        if attrs['timeout']
-          Net::HTTP.stubs(:get).with(URI(uri)).raises(Timeout::Error)
-        else
-          Net::HTTP.stubs(:get).with(URI(uri)).returns(attrs['response'])
-        end
-      end
-    end
-
-    def assert_valid_vendors_hash(expected_vendors_hash)
-      aws_info = AWSInfo.new
-
-      if expected_vendors_hash.nil?
-        refute aws_info.loaded?
-      else
-        actual = stringify_keys_in_object(aws_info.to_collector_hash)
-        assert_equal expected_vendors_hash["aws"], actual
-      end
-    end
-
-    # recurses through hashes and arrays and stringifies keys
-    def stringify_keys_in_object(object)
-      case object
-      when Hash
-        object.inject({}) do |memo, (k, v)|
-          memo[k.to_s] = stringify_keys_in_object(v)
-          memo
-        end
-      when Array
-        object.map {|o| stringify_keys_in_object(o)}
-      else
-        object
-      end
-    end
-
-  end
-end

data/test/new_relic/agent/busy_calculator_test.rb

@@ -1,104 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
-
-class NewRelic::Agent::BusyCalculatorTest < Minitest::Test
-  attr_reader :now
-
-  def setup
-    @now = Time.now.to_f
-    NewRelic::Agent::BusyCalculator.reset
-    NewRelic::Agent.agent.stats_engine.clear_stats
-  end
-
-  def test_normal
-    # start the timewindow 10 seconds ago
-    # start a request at 10 seconds, 5 seconds long
-    NewRelic::Agent::BusyCalculator.stubs(:harvest_start).returns(now - 10.0)
-    NewRelic::Agent::BusyCalculator.dispatcher_start(now - 10.0)
-    NewRelic::Agent::BusyCalculator.dispatcher_finish(now - 5.0)
-    assert_equal 5, NewRelic::Agent::BusyCalculator.accumulator
-    NewRelic::Agent::BusyCalculator.harvest_busy
-
-    assert_instance_busy_metric_recorded call_count: 1, total_call_time: 0.50
-  end
-
-  def test_split
-    # start the timewindow 10 seconds ago
-    # start a request at 5 seconds, don't finish
-    NewRelic::Agent::BusyCalculator.stubs(:harvest_start).returns(now - 10.0)
-    NewRelic::Agent::BusyCalculator.dispatcher_start(now - 5.0)
-    NewRelic::Agent::BusyCalculator.harvest_busy
-
-    assert_instance_busy_metric_recorded call_count: 1, total_call_time: 0.50
-  end
-
-  def test_reentrancy
-    # start the timewindow 10 seconds ago
-    # start a request at 5 seconds, don't finish, but make two more
-    # complete calls, which should be ignored.
-    NewRelic::Agent::BusyCalculator.stubs(:harvest_start).returns(now - 10.0)
-    NewRelic::Agent::BusyCalculator.dispatcher_start(now - 5.0)
-    NewRelic::Agent::BusyCalculator.dispatcher_start(now - 4.5)
-    NewRelic::Agent::BusyCalculator.dispatcher_start(now - 4.0)
-    NewRelic::Agent::BusyCalculator.dispatcher_finish(now - 3.5)
-    NewRelic::Agent::BusyCalculator.dispatcher_finish(now - 3.0)
-    NewRelic::Agent::BusyCalculator.dispatcher_start(now - 2.0)
-    NewRelic::Agent::BusyCalculator.dispatcher_finish(now - 1.0)
-    NewRelic::Agent::BusyCalculator.harvest_busy
-
-    assert_instance_busy_metric_recorded call_count: 1, total_call_time: 0.50
-  end
-
-  def test_concurrency
-    # start the timewindow 10 seconds ago
-    # start a request at 10 seconds, 5 seconds long
-    NewRelic::Agent::BusyCalculator.stubs(:harvest_start).returns(now - 10.0)
-    NewRelic::Agent::BusyCalculator.dispatcher_start(now - 8.0)
-    worker = Thread.new do
-      # Get busy for 6 - 3 seconds
-      NewRelic::Agent::BusyCalculator.dispatcher_start(now - 6.0)
-      NewRelic::Agent::BusyCalculator.dispatcher_start(now - 5.0)
-      NewRelic::Agent::BusyCalculator.dispatcher_finish(now - 4.0)
-      NewRelic::Agent::BusyCalculator.dispatcher_finish(now - 3.0)
-    end
-    # Get busy for 8 - 2 seconds
-    NewRelic::Agent::BusyCalculator.dispatcher_finish(now - 2.0)
-    worker.join
-
-    NewRelic::Agent::BusyCalculator.stubs(:time_now).returns(now - 1.0)
-    NewRelic::Agent::BusyCalculator.harvest_busy
-
-    assert_instance_busy_metric_recorded call_count: 1, total_call_time: 1.0
-  end
-
-  def test_dont_ignore_zero_counts
-    NewRelic::Agent::BusyCalculator.harvest_busy
-    NewRelic::Agent::BusyCalculator.harvest_busy
-    NewRelic::Agent::BusyCalculator.harvest_busy
-
-    assert_instance_busy_metric_recorded :call_count => 3
-  end
-
-  def test_can_turn_off_recording
-    with_config(:report_instance_busy => false) do
-      NewRelic::Agent::BusyCalculator.harvest_busy
-      assert_metrics_not_recorded 'Instance/Busy'
-    end
-  end
-
-  def test_finishing_without_starting_doesnt_raise
-    NewRelic::Agent::TransactionState.tl_clear_for_testing
-    NewRelic::Agent::BusyCalculator.dispatcher_finish
-  end
-
-  def assert_instance_busy_metric_recorded total_call_time: nil, call_count: 1
-    spec = NewRelic::MetricSpec.new("Instance/Busy")
-    stats = NewRelic::Agent.instance.stats_engine.to_h[spec]
-    refute_nil stats
-    assert_equal call_count, stats.call_count
-    assert_in_delta total_call_time, stats.total_call_time, 0.01 if total_call_time
-  end
-end