newrelic_rpm 3.4.1 → 3.4.2.beta1

data/test/new_relic/control/frameworks/rails_test.rb

@@ -0,0 +1,26 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'/../../../test_helper'))
+
+class NewRelic::Control::Frameworks::RailsTest < Test::Unit::TestCase
+  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.instance_eval { @browser_monitoring_installed = false }
+    with_config(:'browser_monitoring.auto_instrument' => true) do
+      NewRelic::Control.instance.install_browser_monitoring(config)
+    end
+  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.instance_eval { @browser_monitoring_installed = false }
+
+    with_config(:'browser_monitoring.auto_instrument' => false) do
+      NewRelic::Control.instance.install_browser_monitoring(config)
+    end
+  end
+end

data/test/new_relic/control/logging_methods_test.rb

@@ -5,15 +5,15 @@ 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'
+    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
     super
   end
 
@@ -60,30 +60,34 @@ class NewRelic::Control::LoggingMethodsTest < Test::Unit::TestCase
 
   def test_should_log_agent_disabled
     @base.instance_eval { @settings = true }
-    @base.expects(:agent_enabled?).returns(false)
-    assert !@base.should_log?
+    with_config(:agent_enabled => false) do
+      assert !@base.should_log?
+    end
   end
 
   def test_should_log_agent_enabled
     @base.instance_eval { @settings = true }
-    @base.expects(:agent_enabled?).returns(true)
-    assert @base.should_log?
+    with_config(:agent_enabled => true) do
+      assert @base.should_log?
+    end
   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)
+    with_config(:log_level => 'whee') do
+      fake_logger.expects(:level=).with(Logger::INFO)
+      assert_equal fake_logger, @base.set_log_level!(fake_logger)
+    end
   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)
+      with_config(:log_level => level) do
+        fake_logger.expects(:level=).with(Logger.const_get(level.upcase))
+        assert_equal fake_logger, @base.set_log_level!(fake_logger)
+      end
     end
   end
 
@@ -96,14 +100,14 @@ class NewRelic::Control::LoggingMethodsTest < Test::Unit::TestCase
 
   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')
+    Logger.expects(:new).returns(fake_logger)
     @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 }
+    with_config(:log_file_path => 'logpath', :log_file_name => 'logfilename') do
+      assert_equal fake_logger, @base.setup_log
+      assert_equal fake_logger, @base.instance_eval { @log }
+      assert_match(/logpath\/logfilename$/, @base.instance_eval { @log_file })
+    end
   end
 
   def test_to_stdout
@@ -117,69 +121,90 @@ class NewRelic::Control::LoggingMethodsTest < Test::Unit::TestCase
   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
+    with_config(:log_file_path => 'log') do
+      assert File.directory?('log')
+      assert_equal File.expand_path('log'), @base.log_path
+    end
   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)
+    with_config(:log_file_path => 'tmp/log_path_test') do
+      assert !File.directory?(path) || FileUtils.rmdir(path)
+      @base.expects(:log!).never
+      assert_equal path, @base.log_path
+      assert File.directory?(path)
+    end
   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
+    with_config(:log_file_path => 'tmp/log_path_test') do
+      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)
+      # once for the relative directory, once for the directory relative to Rails.root
+      Dir.expects(:mkdir).with(path).raises('cannot make directory bro!').twice
+      assert_nil @base.log_path
+      assert !File.directory?(path)
+      assert_equal STDOUT, @base.log.instance_eval { @logdev }.dev
+    end
   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    
+    with_config(:log_file_path => 'STDOUT') do
+      @base.setup_log
+      assert_equal STDOUT, @base.log.instance_eval { @logdev }.dev
+    end
   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')
+    with_config(:log_file_path => 'STDOUT') do
+      STDOUT.expects(:write).with(regexp_matches(/\*\* \[NewRelic\].*whee/))
+      @base.setup_log
+      @base.log.info('whee')
+    end
   end
 
   def test_set_stdout_destination_from_NEW_RELIC_LOG_env_var
-    @base.stubs(:fetch).returns('whatever')
     ENV['NEW_RELIC_LOG'] = 'stdout'
+    reset_environment_config
     Dir.expects(:mkdir).never
     @base.setup_log
     assert_equal STDOUT, @base.log.instance_eval { @logdev }.dev
     ENV['NEW_RELIC_LOG'] = nil
+    reset_environment_config
   end
 
   def test_set_file_destination_from_NEW_RELIC_LOG_env_var
-    @base.stubs(:fetch).returns('whatever')
     ENV['NEW_RELIC_LOG'] = 'log/file.log'
+    reset_environment_config
     @base.setup_log
     assert_equal 'log', File.basename(@base.log_path)
-    assert_equal 'file.log', @base.log_file_name
-    ENV['NEW_RELIC_LOG'] = nil    
+    assert_equal 'file.log', NewRelic::Agent.config['log_file_name']
+    ENV['NEW_RELIC_LOG'] = nil
+    reset_environment_config
+  end
+
+  def test_log_path_uses_default_if_not_set
+    NewRelic::Control.instance.setup_log
+    assert_match(/log\/newrelic_agent.log$/,
+                 NewRelic::Control.instance.log_file)
+  end
+
+  def test_log_file_path_uses_given_value
+    Dir.stubs(:mkdir).returns(true)
+    with_config(:log_file_path => 'lerg') do
+      NewRelic::Control.instance.setup_log
+      assert_match(/\/lerg\/newrelic_agent.log$/,
+                   NewRelic::Control.instance.log_file)
+    end
+  end
+
+  def reset_environment_config
+    NewRelic::Agent::Configuration.manager.config_stack[0] =
+      NewRelic::Agent::Configuration::EnvironmentSource.new
   end
 end

data/test/new_relic/control_test.rb

@@ -4,7 +4,6 @@ class NewRelic::ControlTest < Test::Unit::TestCase
   attr_reader :control
 
   def setup
-    NewRelic::Agent.manual_start(:dispatcher_instance_id => 'test')
     @control =  NewRelic::Control.instance
     raise 'oh geez, wrong class' unless NewRelic::Control.instance.is_a?(::NewRelic::Control::Frameworks::Test)
   end
@@ -17,12 +16,11 @@ class NewRelic::ControlTest < Test::Unit::TestCase
     assert @control.cert_file_path
     assert_equal File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'cert', 'cacert.pem')), @control.cert_file_path
   end
-  
+
   # This test does not actually use the ruby agent in any way - it's
   # testing that the CA file we ship actually validates our server's
   # certificate. It's used for customers who enable verify_certificate
   def test_cert_file
-    return if ::RUBY_VERSION == '1.9.3'
     require 'socket'
     require 'openssl'
 
@@ -34,12 +32,11 @@ class NewRelic::ControlTest < Test::Unit::TestCase
     s.connect
     # should not raise an error
   end
-  
+
   # see above, but for staging, as well. This allows us to test new
   # certificates in a non-customer-facing place before setting them
   # live.
   def test_staging_cert_file
-    return if ::RUBY_VERSION == '1.9.3'
     require 'socket'
     require 'openssl'
 
@@ -52,26 +49,6 @@ class NewRelic::ControlTest < Test::Unit::TestCase
     # should not raise an error
   end
 
-  def test_monitor_mode
-    assert ! @control.monitor_mode?
-    @control.settings.delete 'enabled'
-    @control.settings.delete 'monitor_mode'
-    assert !@control.monitor_mode?
-    @control['enabled'] = false
-    assert ! @control.monitor_mode?
-    @control['enabled'] = true
-    assert @control.monitor_mode?
-    @control['monitor_mode'] = nil
-    assert !@control.monitor_mode?
-    @control['monitor_mode'] = false
-    assert !@control.monitor_mode?
-    @control['monitor_mode'] = true
-    assert @control.monitor_mode?
-  ensure
-    @control['enabled'] = false
-    @control['monitor_mode'] = false
-  end
-
   def test_test_config
     if defined?(Rails) && Rails::VERSION::MAJOR.to_i == 3
       assert_equal :rails3, control.app
@@ -81,10 +58,10 @@ class NewRelic::ControlTest < Test::Unit::TestCase
       assert_equal :test, control.app
     end
     assert_equal :test, control.framework
-    assert_match /test/i, control.dispatcher_instance_id
-    assert("" == control.dispatcher.to_s, "Expected dispatcher to be empty, but was #{control.dispatcher.to_s}")
-    assert !control['enabled']
-    assert_equal false, control['monitor_mode']
+    assert_match /test/i, control.local_env.dispatcher_instance_id
+    assert("" == NewRelic::Agent.config[:dispatcher].to_s,
+           "Expected dispatcher to be empty, but was #{NewRelic::Agent.config[:dispatcher].to_s}")
+    assert_equal false, NewRelic::Agent.config[:monitor_mode]
     control.local_env
   end
 
@@ -96,6 +73,7 @@ class NewRelic::ControlTest < Test::Unit::TestCase
   end
 
   def test_info
+    NewRelic::Agent.manual_start(:dispatcher_instance_id => 'test')
     props = NewRelic::Control.instance.local_env.snapshot
     if defined?(Rails)
       assert_match /jdbc|postgres|mysql|sqlite/, props.assoc('Database adapter').last, props.inspect
@@ -109,6 +87,36 @@ class NewRelic::ControlTest < Test::Unit::TestCase
     assert_equal '204.93.223.153', control.send(:convert_to_ip_address, 'collector.newrelic.com')
   end
 
+  def test_do_not_resolve_if_we_need_to_verify_a_cert
+    assert_equal nil, control.send(:convert_to_ip_address, 'localhost')
+    with_config(:ssl => true, :verify_certificate => true) do
+      assert_equal 'localhost', control.send(:convert_to_ip_address, 'localhost')
+    end
+  end
+
+  def test_api_server_uses_configured_values
+    control.instance_variable_set(:@api_server, nil)
+    with_config(:api_host => 'somewhere', :api_port => 8080) do
+      assert_equal 'somewhere', control.api_server.name
+      assert_equal 8080, control.api_server.port
+    end
+  end
+
+  def test_proxy_server_uses_configured_values
+    control.instance_variable_set(:@proxy_server, nil)
+    with_config(:proxy_host => 'proxytown', :proxy_port => 81) do
+      assert_equal 'proxytown', control.proxy_server.name
+      assert_equal 81, control.proxy_server.port
+    end
+  end
+
+  def test_server_from_host_uses_configured_values
+    with_config(:host => 'donkeytown', :port => 8080) do
+      assert_equal 'donkeytown', control.server_from_host.name
+      assert_equal 8080, control.server_from_host.port
+    end
+  end
+
   class FakeResolv
     def self.getaddress(host)
       raise 'deliberately broken'
@@ -131,126 +139,95 @@ class NewRelic::ControlTest < Test::Unit::TestCase
     assert_equal old_ipsocket, IPSocket
   end
 
-  def test_config_yaml_erb
-    assert_equal 'heyheyhey', control['erb_value']
-    assert_equal '', control['message']
-    assert_equal '', control['license_key']
-  end
-
-  def test_appnames
-    assert_equal %w[a b c], NewRelic::Control.instance.app_names
-  end
-
-  def test_config_booleans
-    assert_equal control['tval'], true
-    assert_equal control['fval'], false
-    assert_nil control['not_in_yaml_val']
-    assert_equal control['yval'], true
-    assert_equal control['sval'], 'sure'
-  end
-
-  def test_config_apdex
-    assert_equal 1.1, control.apdex_t
-  end
-
-#  def test_transaction_threshold
-#    assert_equal 'Apdex_f', c['transaction_tracer']['transaction_threshold']
-#    assert_equal 4.4, NewRelic::Agent::Agent.instance.instance_variable_get('@slowest_transaction_threshold')
-#  end
-
   def test_log_file_name
     NewRelic::Control.instance.setup_log
     assert_match /newrelic_agent.log$/, control.instance_variable_get('@log_file')
   end
 
-#  def test_transaction_threshold__apdex
-#    forced_start
-#    assert_equal 'Apdex_f', c['transaction_tracer']['transaction_threshold']
-#    assert_equal 4.4, NewRelic::Agent::Agent.instance.instance_variable_get('@slowest_transaction_threshold')
-#  end
-
-  def test_transaction_threshold__default
-    forced_start :transaction_tracer => { :transaction_threshold => nil}
-    assert_nil control['transaction_tracer']['transaction_threshold']
-    assert_equal 2.0, NewRelic::Agent::Agent.instance.instance_variable_get('@slowest_transaction_threshold')
-  end
-
   def test_transaction_threshold__override
-    forced_start :transaction_tracer => { :transaction_threshold => 1}
-    assert_equal 1, control['transaction_tracer']['transaction_threshold']
-    assert_equal 1, NewRelic::Agent::Agent.instance.instance_variable_get('@slowest_transaction_threshold')
+    with_config(:transaction_tracer => { :transaction_threshold => 1}) do
+      NewRelic::Agent.instance.config_transaction_tracer
+      assert_equal 1, NewRelic::Agent.config[:'transaction_tracer.transaction_threshold']
+      assert_equal 1, NewRelic::Agent.instance \
+        .instance_variable_get(:@slowest_transaction_threshold)
+    end
   end
 
   def test_transaction_tracer_disabled
-    forced_start(:transaction_tracer => { :enabled => false },
-                 :developer_mode => false, :monitor_mode => true)
-    NewRelic::Agent::Agent.instance.check_transaction_sampler_status
-    
-    assert(!NewRelic::Agent::Agent.instance.transaction_sampler.enabled?,
-           'transaction tracer enabled when config calls for disabled')
-    
-    @control['developer_mode'] = true
-    @control['monitor_mode'] = false
+    with_config(:'transaction_tracer.enabled' => false,
+                :developer_mode => false, :monitor_mode => true) do
+      NewRelic::Agent::Agent.instance.config_transaction_tracer
+      NewRelic::Agent::Agent.instance.check_transaction_sampler_status
+
+      assert(!NewRelic::Agent::Agent.instance.transaction_sampler.enabled?,
+             'transaction tracer enabled when config calls for disabled')
+    end
   end
-  
+
   def test_sql_tracer_disabled
-    forced_start(:slow_sql => { :enabled => false }, :monitor_mode => true)
-    NewRelic::Agent::Agent.instance.check_sql_sampler_status
-    
-    assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
-           'sql tracer enabled when config calls for disabled')
-    
-    @control['monitor_mode'] = false
+    with_config(:'slow_sql.enabled' => false, :monitor_mode => true) do
+      NewRelic::Agent.instance.sql_sampler.configure!
+      NewRelic::Agent::Agent.instance.check_sql_sampler_status
+
+      assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
+             'sql tracer enabled when config calls for disabled')
+    end
   end
-  
+
   def test_sql_tracer_disabled_with_record_sql_false
-    forced_start(:slow_sql => { :enabled => true, :record_sql => 'off' })
-    NewRelic::Agent::Agent.instance.check_sql_sampler_status
-    
-    assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
-           'sql tracer enabled when config calls for disabled')
+    with_config(:slow_sql => { :enabled => true, :record_sql => 'off' }) do
+      NewRelic::Agent::Agent.instance.check_sql_sampler_status
+
+      assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
+             'sql tracer enabled when config calls for disabled')
+    end
   end
 
   def test_sql_tracer_disabled_when_tt_disabled
-    forced_start(:transaction_tracer => { :enabled => false },
-                 :slow_sql => { :enabled => true },
-                 :developer_mode => false, :monitor_mode => true)
-    NewRelic::Agent::Agent.instance.check_sql_sampler_status
-    
-    assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
-           'sql enabled when transaction tracer disabled')
-    
-    @control['developer_mode'] = true
-    @control['monitor_mode'] = false    
+    with_config(:'transaction_tracer.enabled' => false,
+                :'slow_sql.enabled' => true,
+                :developer_mode => false, :monitor_mode => true) do
+      NewRelic::Agent::Agent.instance.check_sql_sampler_status
+
+      assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
+             'sql enabled when transaction tracer disabled')
+    end
   end
 
   def test_sql_tracer_disabled_when_tt_disabled_by_server
-    forced_start(:slow_sql => { :enabled => true },
-                 :transaction_tracer => { :enabled => true },
-                 :monitor_mode => true)
-    NewRelic::Agent::Agent.instance.check_sql_sampler_status
-    NewRelic::Agent::Agent.instance.finish_setup('collect_traces' => false)    
-    
-    assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
-           'sql enabled when tracing disabled by server')
-    
-    @control['monitor_mode'] = false        
+    with_config({:'slow_sql.enabled' => true,
+                  :'transaction_tracer.enabled' => true,
+                  :monitor_mode => true}, 2) do
+
+      NewRelic::Agent.instance.check_sql_sampler_status
+      NewRelic::Agent.instance.finish_setup('collect_traces' => false,
+                                            'listen_to_server_config' => true)
+
+      assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
+             'sql enabled when tracing disabled by server')
+    end
   end
 
-  def test_merging_options
-    NewRelic::Control.send :public, :merge_options
-    @control.merge_options :api_port => 66, :transaction_tracer => { :explain_threshold => 2.0 }
-    assert_equal 66, NewRelic::Control.instance['api_port']
-    assert_equal 2.0, NewRelic::Control.instance['transaction_tracer']['explain_threshold']
-    assert_equal 'raw', NewRelic::Control.instance['transaction_tracer']['record_sql']
+  def test_init_plugin_loads_samplers_enabled
+    NewRelic::Agent.shutdown
+    with_config(:disable_samplers => false, :agent_enabled => true) do
+      NewRelic::Control.instance.init_plugin
+      assert NewRelic::Agent.instance.stats_engine.send(:harvest_samplers).any?
+    end
+  end
+
+  def test_init_plugin_loads_samplers_disabled
+    NewRelic::Agent.shutdown
+    with_config(:disable_samplers => true, :agent_enabled => true) do
+      NewRelic::Control.instance.init_plugin
+      assert_equal [], NewRelic::Agent.instance.stats_engine.send(:harvest_samplers)
+    end
   end
-    
+
   private
 
-  def forced_start(overrides={})
-    NewRelic::Agent.manual_start overrides
-    # This is to force the agent to start again.
-    NewRelic::Agent.instance.stubs(:started?).returns(nil)
-    NewRelic::Agent.instance.start
+  def reset_environment_config
+    NewRelic::Agent::Configuration.manager.config_stack[0] =
+      NewRelic::Agent::Configuration::EnvironmentSource.new
   end
 end