wd_newrelic_rpm 3.3.4.1 → 3.5.5

data/test/new_relic/control/configuration_test.rb

@@ -1,84 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__),'/../../test_helper'))
-
-class NewRelic::Control::ConfigurationTest < Test::Unit::TestCase
-  require 'new_relic/control/configuration'
-  include NewRelic::Control::Configuration
-  
-  def setup
-    # The log stuff is memoized so let's clear it each time.
-    NewRelic::Control.instance.instance_variable_set '@log_path', nil
-    NewRelic::Control.instance.instance_variable_set '@log_file', nil
-    @root = ::Rails::VERSION::MAJOR == 3 ? Rails.root : RAILS_ROOT
-  end
-  
-  def teardown
-    NewRelic::Control.instance.settings.delete('log_file_path')
-  end
-  
-  def test_license_key_defaults_to_env_variable
-    ENV['NEWRELIC_LICENSE_KEY'] = nil
-    self.expects(:fetch).with('license_key', nil)
-    license_key
-
-    ENV['NEWRELIC_LICENSE_KEY'] = "a string"
-    self.expects(:fetch).with('license_key', 'a string')
-    license_key
-  end
-  
-  def test_log_path_uses_default_if_not_set
-    NewRelic::Control.instance.setup_log
-    assert_equal(File.expand_path("log/newrelic_agent.log"),
-                 NewRelic::Control.instance.log_file)
-  end
-
-  def test_log_file_path_uses_given_value
-    Dir.stubs(:mkdir).returns(true)
-    NewRelic::Control.instance['log_file_path'] = 'lerg'
-    NewRelic::Control.instance.setup_log
-    assert_match(/\/lerg\/newrelic_agent.log/,
-                 NewRelic::Control.instance.log_file)
-    NewRelic::Control.instance.settings.delete('log_file_path') # = nil    
-  end
-
-  def test_server_side_config_ignores_yaml
-    settings.merge! 'ssl' => false, 'transaction_tracer' => {'enabled' => true, 'stack_trace_threshold' => 1.0}, 'error_collector' => {'enabled' => true, 'ignore_errors' => 'ActiveRecord::RecordNotFound'}, 'capture_params' => false
-    merge_server_side_config 'transaction_tracer.enabled' => false, 'error_collector.enabled' => false
-    assert_equal({'ssl' => false, 'transaction_tracer' => {'enabled' => false}, 'error_collector' => {'enabled' => false}}, settings)
-  end
-
-  def test_install_browser_monitoring
-    require(File.expand_path(File.join(File.dirname(__FILE__),
-                         '/../../../lib/new_relic/rack/browser_monitoring')))
-    middleware = stub('middleware config')
-    config = stub('rails config', :middleware => middleware)
-    middleware.expects(:use).with(NewRelic::Rack::BrowserMonitoring)
-    NewRelic::Control.instance['browser_monitoring'] = { 'auto_instrument' => true }
-    NewRelic::Control.instance.instance_eval { @browser_monitoring_installed = false }
-
-    NewRelic::Control.instance.install_browser_monitoring(config)
-  end
-
-  def test_install_browser_monitoring_should_not_install_when_not_configured
-    middleware = stub('middleware config')
-    config = stub('rails config', :middleware => middleware)
-    middleware.expects(:use).never
-    NewRelic::Control.instance['browser_monitoring'] = { 'auto_instrument' => false }
-    NewRelic::Control.instance.instance_eval { @browser_monitoring_installed = false }
-    
-    NewRelic::Control.instance.install_browser_monitoring(config)
-
-    NewRelic::Control.instance['browser_monitoring'] = { 'auto_instrument' => true }
-  end
-
-  def test_data_serialization_default_off
-    DependencyDetection.send(:class_variable_set, '@@items', [])
-    assert NewRelic::Control.instance.disable_serialization?
-  end
-
-  def test_data_serialization_default_on_when_using_resque
-    DependencyDetection.defer { @name = :resque }
-    DependencyDetection.dependency_by_name(:resque).executed!
-    assert !NewRelic::Control.instance.disable_serialization?
-    DependencyDetection.send(:class_variable_set, '@@items', [])
-  end
-end

data/test/new_relic/control/logging_methods_test.rb

@@ -1,185 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
-require 'new_relic/control/logging_methods'
-require 'fileutils'
-
-class BaseLoggingMethods
-  # stub class to enable testing of the module
-  include NewRelic::Control::LoggingMethods
-  include NewRelic::Control::Configuration
-  def root; "."; end
-end
-
-class NewRelic::Control::LoggingMethodsTest < Test::Unit::TestCase
-  def setup
-    @base = BaseLoggingMethods.new
-    @base.settings['log_file_path'] = 'log/'
-    @base.settings['log_file_name'] = 'newrelic_agent.log'
-    super
-  end
-
-  def test_log_basic
-    mock_logger = mock('logger')
-    @base.instance_eval { @log = mock_logger }
-    assert_equal mock_logger, @base.log
-  end
-
-  def test_log_no_log
-    log = @base.log
-    assert_equal Logger, log.class
-    assert_equal Logger::INFO, log.level
-    # have to root around in the logger for the logdev
-    assert_equal STDOUT, log.instance_eval { @logdev }.dev
-  end
-
-  def test_logbang_basic
-    @base.expects(:should_log?).returns(true)
-    @base.expects(:to_stdout).with('whee')
-    @base.instance_eval { @log = nil }
-    @base.log!('whee')
-  end
-
-  def test_logbang_should_not_log
-    @base.expects(:should_log?).returns(false)
-    @base.stubs(:to_stdout)
-    assert_equal nil, @base.log!('whee')
-  end
-
-  def test_logbang_with_log
-    @base.expects(:should_log?).returns(true)
-    @base.expects(:to_stdout).with('whee')
-    fake_logger = mock('log')
-    fake_logger.expects(:send).with(:info, 'whee')
-    @base.instance_eval { @log = fake_logger }
-    @base.log!('whee')
-  end
-
-  def test_should_log_no_settings
-    @base.instance_eval { @settings = nil }
-    assert !@base.should_log?
-  end
-
-  def test_should_log_agent_disabled
-    @base.instance_eval { @settings = true }
-    @base.expects(:agent_enabled?).returns(false)
-    assert !@base.should_log?
-  end
-
-  def test_should_log_agent_enabled
-    @base.instance_eval { @settings = true }
-    @base.expects(:agent_enabled?).returns(true)
-    assert @base.should_log?
-  end
-
-  def test_set_log_level_base
-    fake_logger = mock('logger')
-    # bad configuration
-    @base.expects(:fetch).with('log_level', 'info').returns('whee')
-    fake_logger.expects(:level=).with(Logger::INFO)
-    assert_equal fake_logger, @base.set_log_level!(fake_logger)
-  end
-
-  def test_set_log_level_with_each_level
-    fake_logger = mock('logger')
-    %w[debug info warn error fatal].each do |level|
-      @base.expects(:fetch).with('log_level', 'info').returns(level)
-      fake_logger.expects(:level=).with(Logger.const_get(level.upcase))
-      assert_equal fake_logger, @base.set_log_level!(fake_logger)
-    end
-  end
-
-  def test_set_log_format
-    fake_logger = Object.new
-    assert !fake_logger.respond_to?(:format_message)
-    assert_equal fake_logger, @base.set_log_format!(fake_logger)
-    assert fake_logger.respond_to?(:format_message)
-  end
-
-  def test_setup_log_existing_file
-    fake_logger = mock('logger')
-    Logger.expects(:new).with('logpath/logfilename').returns(fake_logger)
-    @base.expects(:log_path).returns('logpath').at_least_once
-    @base.expects(:log_file_name).returns('logfilename')
-    @base.expects(:set_log_format!).with(fake_logger)
-    @base.expects(:set_log_level!).with(fake_logger)
-    assert_equal fake_logger, @base.setup_log
-    assert_equal fake_logger, @base.instance_eval { @log }
-    assert_equal 'logpath/logfilename', @base.instance_eval { @log_file }
-  end
-
-  def test_to_stdout
-    STDOUT.expects(:puts).with('** [NewRelic] whee')
-    @base.to_stdout('whee')
-  end
-
-  def test_log_path_exists
-    @base.instance_eval { @log_path = 'logpath' }
-    assert_equal 'logpath', @base.log_path
-  end
-
-  def test_log_path_path_exists
-    @base.settings['log_file_path'] = 'log'
-    assert File.directory?('log')
-    assert_equal File.expand_path('log'), @base.log_path
-  end
-
-  def test_log_path_path_created
-    path = File.expand_path('tmp/log_path_test')
-    @base.instance_eval { @log_path = nil }
-    @base.settings['log_file_path'] = 'tmp/log_path_test'
-    assert !File.directory?(path) || FileUtils.rmdir(path)
-    @base.expects(:log!).never
-    assert_equal path, @base.log_path
-    assert File.directory?(path)
-  end
-
-  def test_log_path_path_unable_to_create
-    path = File.expand_path('tmp/log_path_test')
-    @base.instance_eval { @log_path = nil }
-    @base.settings['log_file_path'] = 'tmp/log_path_test'
-    assert !File.directory?(path) || FileUtils.rmdir(path)
-    @base.expects(:log!).with("Error creating log directory tmp/log_path_test, using standard out for logging.", :warn)
-    Dir.expects(:mkdir).with(path).raises('cannot make directory bro!').twice # once for the relative directory, once for the directory relative to Rails.root
-    assert_nil @base.log_path
-    assert !File.directory?(path)
-    assert_equal STDOUT, @base.log.instance_eval { @logdev }.dev    
-  end
-
-  def test_log_file_name
-    @base.expects(:fetch).with('log_file_name', 'newrelic_agent.log').returns('log_file_name')
-    assert_equal 'log_file_name', @base.log_file_name
-  end
-
-  def test_log_to_stdout_when_log_file_path_set_to_STDOUT
-    @base.stubs(:fetch).returns('whatever')
-    @base.expects(:fetch).with('log_file_path', 'log').returns('STDOUT')
-    Dir.expects(:mkdir).never
-    @base.setup_log
-    assert_equal STDOUT, @base.log.instance_eval { @logdev }.dev    
-  end
-
-  def test_logs_to_stdout_include_newrelic_prefix
-    @base.stubs(:fetch).returns('whatever')
-    @base.expects(:fetch).with('log_file_path', 'log').returns('STDOUT')
-    STDOUT.expects(:write).with(regexp_matches(/\*\* \[NewRelic\].*whee/))
-    @base.setup_log
-    @base.log.info('whee')
-  end
-
-  def test_set_stdout_destination_from_NEW_RELIC_LOG_env_var
-    @base.stubs(:fetch).returns('whatever')
-    ENV['NEW_RELIC_LOG'] = 'stdout'
-    Dir.expects(:mkdir).never
-    @base.setup_log
-    assert_equal STDOUT, @base.log.instance_eval { @logdev }.dev
-    ENV['NEW_RELIC_LOG'] = nil
-  end
-
-  def test_set_file_destination_from_NEW_RELIC_LOG_env_var
-    @base.stubs(:fetch).returns('whatever')
-    ENV['NEW_RELIC_LOG'] = 'log/file.log'
-    @base.setup_log
-    assert_equal 'log', File.basename(@base.log_path)
-    assert_equal 'file.log', @base.log_file_name
-    ENV['NEW_RELIC_LOG'] = nil    
-  end
-end

data/test/new_relic/data_serialization_test.rb

@@ -1,208 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__),'..', 'test_helper'))
-require 'new_relic/data_serialization'
-class NewRelic::DataSerializationTest < Test::Unit::TestCase
-
-  attr_reader :file, :path
-  
-  def setup
-    NewRelic::Control.instance['log_file_path'] = './log'
-    @path = NewRelic::Control.instance.log_path
-    @file = "#{path}/newrelic_agent_store.db"
-    Dir.mkdir(path) if !File.directory?(path)
-    FileUtils.rm_rf(@file)
-    FileUtils.rm_rf("#{@path}/newrelic_agent_store.pid")
-  end
-  
-  def teardown
-    # this gets set to true in some tests
-    NewRelic::Control.instance['disable_serialization'] = false
-    mocha_teardown
-  end
-  
-  def test_read_and_write_from_file_read_only
-    File.open(file, 'w') do |f|
-      f.write(Marshal.dump('a happy string'))
-    end
-    NewRelic::DataSerialization.read_and_write_to_file do |data|
-      assert_equal('a happy string', data, "should pull the dumped item from the file")
-      nil # must explicitly return nil or the return value will be dumped
-    end
-    assert_equal(0, File.size(file), "Should not leave any data in the file")
-  end
-  
-  def test_read_and_write_to_file_dumping_contents
-    expected_contents = Marshal.dump('a happy string')
-    NewRelic::DataSerialization.read_and_write_to_file do
-      'a happy string'
-    end
-    assert_equal(expected_contents, File.read(file), "should have dumped the contents")
-  end
-
-  def test_read_and_write_to_file_yields_old_data
-    expected_contents = 'a happy string'
-    File.open(file, 'w') do |f|
-      f.write(Marshal.dump(expected_contents))
-    end
-    contents = nil
-    NewRelic::DataSerialization.read_and_write_to_file do |old_data|
-      contents = old_data
-      'a happy string'
-    end
-    assert_equal(contents, expected_contents, "should have dumped the contents")
-  end
-
-  def test_read_and_write_to_file_round_trip
-    old_data = nil
-    NewRelic::DataSerialization.read_and_write_to_file do |data|
-      old_data = data
-      'a' * 30
-    end
-    NewRelic::DataSerialization.read_and_write_to_file do |data|
-      assert_equal('a'*30, data, "should be the same after serialization")
-    end
-  end
-
-  def test_should_send_data_when_over_limit
-    NewRelic::DataSerialization.stubs(:max_size).returns(20)
-    NewRelic::DataSerialization.read_and_write_to_file do
-      "a" * 30
-    end
-    assert(NewRelic::DataSerialization.should_send_data?, 'Should be over limit')
-  end
-
-  def test_read_until_eoferror
-    File.open(file, 'w') do |f|
-      f.write("a" * 10_001)
-    end
-    value = ""
-    File.open(file,'r') do |f|
-      value << NewRelic::DataSerialization.instance_eval { read_until_eof_error(f) }
-    end
-    assert_equal('a' * 10_001, value, "should retrieve all the contents from the string and not raise EOFerrors")
-  end
-  
-  def test_write_contents_nonblockingly
-    File.open(file, 'w') do |f|
-      f.write("") # write nothing! NOTHING
-    end
-
-    File.open(file, 'w') do |f|
-      NewRelic::DataSerialization.instance_eval { write_contents_nonblockingly(f, 'a' * 10_001) }
-    end
-    value = File.read(file)
-    assert_equal('a' * 10_001, value, "should write a couple thousand 'a's to a file without exploding")
-  end
-
-  def test_should_send_data_disabled
-    NewRelic::Control.instance.disable_serialization = true
-    assert(NewRelic::DataSerialization.should_send_data?,
-           'should send data when disabled')
-  end
-
-  def test_should_send_data_under_limit
-    NewRelic::DataSerialization.expects(:max_size).returns(2000)
-    NewRelic::DataSerialization.read_and_write_to_file do |old_data|
-      "a" * 5
-    end
-    
-    assert(!NewRelic::DataSerialization.store_too_large?,
-           'Should be under the limit')
-  end
-
-  def test_should_handle_empty_spool_file
-    NewRelic::Control.instance.log.expects(:error).never
-    assert_nil NewRelic::DataSerialization.instance_eval { load('') }
-  end
-
-  def test_spool_file_location_respects_log_file_path_setting
-    NewRelic::Control.instance.expects(:log_path).returns('./tmp')
-    Dir.mkdir('./tmp') if !File.directory?('./tmp')
-    NewRelic::DataSerialization.read_and_write_to_file do |_|
-      'a' * 30
-    end
-    assert(File.exists?('./tmp/newrelic_agent_store.db'),
-           "Spool file not created at user specified location")
-  end
-
-  def test_age_file_location_respects_log_file_path_setting
-    NewRelic::Control.instance.expects(:log_path).returns('./tmp')
-    Dir.mkdir('./tmp') if !File.directory?('./tmp')
-    NewRelic::DataSerialization.update_last_sent!
-    assert(File.exists?('./tmp/newrelic_agent_store.pid'),
-           "Age file not created at user specified location")
-  end
-  
-  def test_pid_age_creates_pid_file_if_none_exists
-    assert(!File.exists?("#{@path}/newrelic_agent_store.pid"),
-           'pid file found, should not be there')
-    NewRelic::DataSerialization.update_last_sent!
-    assert(File.exists?("#{@path}/newrelic_agent_store.pid"),
-           'pid file not found, should be there')
-  end
-  
-  def test_should_not_create_files_if_serialization_disabled
-    NewRelic::Control.instance['disable_serialization'] = true
-    NewRelic::DataSerialization.should_send_data?
-    assert(!File.exists?("#{@path}/newrelic_agent_store.db"),
-           'db file created when serialization disabled')
-    assert(!File.exists?("#{@path}/newrelic_agent_store.pid"),
-           'pid file created when serialization disabled')
-  end
-  
-  def test_loading_does_not_seg_fault_if_gc_triggers
-    return if NewRelic::LanguageSupport.using_version?('1.8.6')
-    require 'timeout'
-    
-    Thread.abort_on_exception = true
-    rcv,snd = IO.pipe
-    
-    write = Thread.new do
-      obj = ('a'..'z').inject({}){|h,s|h[s.intern]=s*1024;h}
-      data = Marshal.dump(obj)
-      snd.write(data[0,data.size/2])
-      sleep(0.1)
-      snd.write(data[(data.size/2)..-1])
-      snd.close
-    end
-    
-    read = Thread.new do
-      lock = Mutex.new
-      lock.synchronize do
-        NewRelic::DataSerialization.class_eval { load(rcv) }
-      end
-    end
-
-    gc = Thread.new do
-      10.times do
-        GC.start
-      end
-    end
-
-    Timeout::timeout(5) do
-      write.join
-      read.join
-      gc.join
-    end
-    # should not seg fault
-  end
-
-  def test_dump_should_be_thread_safe
-    stats_hash = {}
-
-    2000.times do |i|
-      stats_hash[i.to_s] = NewRelic::StatsBase.new
-    end
-        
-    harvest = Thread.new do
-      NewRelic::DataSerialization.class_eval { dump(stats_hash) }
-    end
-    
-    app = Thread.new do
-      stats_hash["a"] = NewRelic::StatsBase.new
-    end
-    
-    assert_nothing_raised do
-      [app, harvest].each{|t| t.join}
-    end    
-  end
-end