ghazel-newrelic_rpm 3.4.0.2 → 3.5.4

data/test/new_relic/agent/worker_loop_test.rb

@@ -19,6 +19,23 @@ class NewRelic::Agent::WorkerLoopTest < Test::Unit::TestCase
     assert @x
   end
 
+  def test_with_duration
+    worker_loop = NewRelic::Agent::WorkerLoop.new(:duration => 0.1)
+    count = 0
+    worker_loop.run(0.04) do
+      count += 1
+    end
+
+    assert_equal 2, count
+  end
+
+  def test_loop_limit
+    worker_loop = NewRelic::Agent::WorkerLoop.new(:limit => 2)
+    iterations = 0
+    worker_loop.run(0) { iterations += 1 }
+    assert_equal 2, iterations
+  end
+
   def test_density
     # This shows how the tasks stay aligned with the period and don't drift.
     count = 0
@@ -33,6 +50,7 @@ class NewRelic::Agent::WorkerLoopTest < Test::Unit::TestCase
     elapsed = Time.now - start
     assert_in_delta 0.09, elapsed, 0.03
   end
+
   def test_task_error__standard
     @logger.expects(:debug)
     @logger.expects(:error)
@@ -45,6 +63,7 @@ class NewRelic::Agent::WorkerLoopTest < Test::Unit::TestCase
     end
     assert done
   end
+
   class BadBoy < StandardError; end
 
   def test_task_error__exception
@@ -55,6 +74,7 @@ class NewRelic::Agent::WorkerLoopTest < Test::Unit::TestCase
       raise BadBoy, "oops"
     end
   end
+
   def test_task_error__server
     @logger.expects(:error).never
     @logger.expects(:debug).once

data/test/new_relic/agent_test.rb

@@ -3,7 +3,7 @@ require 'ostruct'
 
 module NewRelic
   class MainAgentTest < Test::Unit::TestCase
-    
+
     # mostly this module just passes through to the active agent
     # through the agent method or the control instance through
     # NewRelic::Control.instance . But it's nice to make sure.
@@ -12,13 +12,42 @@ module NewRelic
       super
       Thread.current[:newrelic_untraced] = nil
     end
-    
+
     def test_shutdown
       mock_agent = mocked_agent
       mock_agent.expects(:shutdown).with({})
       NewRelic::Agent.shutdown
     end
 
+    def test_shutdown_removes_manual_startup_config
+      NewRelic::Agent.manual_start(:some_absurd_setting => true)
+      assert NewRelic::Agent.config[:some_absurd_setting]
+      NewRelic::Agent.shutdown
+      assert !NewRelic::Agent.config[:some_absurd_setting]
+    end
+
+    def test_shutdown_removes_server_config
+      NewRelic::Agent.manual_start
+      NewRelic::Agent.instance.finish_setup('agent_config' =>
+                                            { :some_absurd_setting => true })
+      assert NewRelic::Agent.config[:some_absurd_setting]
+      NewRelic::Agent.shutdown
+      assert !NewRelic::Agent.config[:some_absurd_setting]
+    end
+
+    def test_finish_setup_applied_server_side_config
+      with_config({ :'transction_tracer.enabled' => true,
+                    'error_collector.enabled' => true,
+                    :log_level => 'info' }, 2) do
+        NewRelic::Agent.instance.finish_setup('log_level' => 'debug',
+         'agent_config' => { 'transaction_tracer.enabled' => false },
+                                         'collect_errors' => false)
+        assert !NewRelic::Agent.config[:'transaction_tracer.enabled']
+        assert !NewRelic::Agent.config[:'error_collector.enabled']
+        assert_equal 'debug', NewRelic::Agent.config[:log_level]
+      end
+    end
+
     def test_after_fork
       mock_agent = mocked_agent
       mock_agent.expects(:after_fork).with({})
@@ -32,43 +61,42 @@ module NewRelic
 
       assert agent.forked?
     end
-    
 
     if NewRelic::LanguageSupport.can_fork? &&
         !NewRelic::LanguageSupport.using_version?('1.9.1')
       def test_timeslice_harvest_with_after_fork_report_to_channel
-        NewRelic::Control.instance.stubs(:agent_enabled?).returns(true)
-        NewRelic::Control.instance.stubs(:monitor_mode?).returns(true)
-        
-        NewRelic::Agent::Agent.instance.service = NewRelic::FakeService.new
-        NewRelic::Agent.shutdown # make sure the agent is not already started
-        NewRelic::Agent.manual_start(:license_key => ('1234567890' * 4),
-                                     :start_channel_listener => true)
-        
-        metric = 'Custom/test/method'
-        NewRelic::Agent.instance.stats_engine.get_stats_no_scope(metric) \
-          .record_data_point(1.0)
-        
-        # ensure that cached metric ids don't interfere with metric merging
-        NewRelic::Agent.agent.instance_variable_set(:@metric_ids,
-                                    {NewRelic::MetricSpec.new('Instance/Busy') => 1})
-        
-        NewRelic::Agent::PipeChannelManager.listener.close_all_pipes
-        NewRelic::Agent.register_report_channel(:agent_test) # before fork
-        pid = Process.fork do
-          NewRelic::Agent.after_fork(:report_to_channel => :agent_test)
-          NewRelic::Agent.agent.stats_engine.get_stats_no_scope(metric) \
-            .record_data_point(2.0)
+        with_config(:agent_enabled => true, :monitor_mode => true) do
+          NewRelic::Agent.shutdown # make sure the agent is not already started
+          NewRelic::Agent::Agent.instance.service = NewRelic::FakeService.new
+          NewRelic::Agent.manual_start(:license_key => ('1234567890' * 4),
+                                       :start_channel_listener => true)
+
+          metric = 'Custom/test/method'
+          NewRelic::Agent.instance.stats_engine.get_stats_no_scope(metric) \
+            .record_data_point(1.0)
+
+          # ensure that cached metric ids don't interfere with metric merging
+          NewRelic::Agent.agent.instance_variable_set(:@metric_ids,
+                            { NewRelic::MetricSpec.new('Instance/Busy') => 1 })
+
+          NewRelic::Agent::PipeChannelManager.listener.close_all_pipes
+          NewRelic::Agent.register_report_channel(:agent_test) # before fork
+          pid = Process.fork do
+            NewRelic::Agent.after_fork(:report_to_channel => :agent_test)
+            NewRelic::Agent.agent.stats_engine.get_stats_no_scope(metric) \
+              .record_data_point(2.0)
+          end
+          Process.wait(pid)
+          NewRelic::Agent::PipeChannelManager.listener.stop
+
+          engine = NewRelic::Agent.agent.stats_engine
+          assert_equal(3.0, engine.lookup_stats(metric).total_call_time)
+          assert_equal(2, engine.lookup_stats(metric).call_count)
+          engine.reset_stats
         end
-        Process.wait(pid)
-        NewRelic::Agent::PipeChannelManager.listener.stop
-        
-        engine = NewRelic::Agent.agent.stats_engine
-        assert_equal(3.0, engine.lookup_stats(metric).total_call_time)
-        assert_equal(2, engine.lookup_stats(metric).call_count)
       end
     end
-    
+
     def test_reset_stats
       mock_agent = mocked_agent
       mock_agent.expects(:reset_stats)
@@ -80,7 +108,7 @@ module NewRelic
       mock_control.expects(:init_plugin).with({:agent_enabled => true, :sync_startup => true})
       NewRelic::Agent.manual_start
     end
-    
+
     def test_manual_start_with_opts
       mock_control = mocked_control
       mock_control.expects(:init_plugin).with({:agent_enabled => true, :sync_startup => false})
@@ -121,7 +149,7 @@ module NewRelic
       mock_stats_engine.expects(:get_stats).with('Custom/test/metric', false)
       NewRelic::Agent.get_stats('Custom/test/metric')
     end
-    
+
     # note that this is the same as get_stats above, they're just aliases
     def test_get_stats_no_scope
       agent = mocked_agent
@@ -166,7 +194,7 @@ module NewRelic
       Thread.current[:record_tt] = false
       assert_equal(false, NewRelic::Agent.is_transaction_traced?, 'should be false since the thread local is false')
     end
-    
+
     def test_is_sql_recorded_true
       Thread.current[:record_sql] = true
       assert_equal(true, NewRelic::Agent.is_sql_recorded?, 'should be true since the thread local is set')
@@ -181,7 +209,7 @@ module NewRelic
       Thread.current[:record_sql] = false
       assert_equal(false, NewRelic::Agent.is_sql_recorded?, 'should be false since the thread local is false')
     end
-    
+
     def test_is_execution_traced_true
       Thread.current[:newrelic_untraced] = [true, true]
       assert_equal(true, NewRelic::Agent.is_execution_traced?, 'should be true since the thread local is set')
@@ -201,18 +229,18 @@ module NewRelic
       Thread.current[:newrelic_untraced] = [true, false]
       assert_equal(false, NewRelic::Agent.is_execution_traced?, 'should be false since the thread local stack has the last element false')
     end
-    
+
     def test_instance
       assert_equal(NewRelic::Agent.agent, NewRelic::Agent.instance, "should return the same agent for both identical methods")
     end
-    
+
     def test_register_report_channel
       NewRelic::Agent.register_report_channel(:channel_id)
       assert NewRelic::Agent::PipeChannelManager.channels[:channel_id] \
         .kind_of?(NewRelic::Agent::PipeChannelManager::Pipe)
       NewRelic::Agent::PipeChannelManager.listener.close_all_pipes
     end
-    
+
     private
 
     def mocked_agent
@@ -220,7 +248,7 @@ module NewRelic
       NewRelic::Agent.stubs(:agent).returns(agent)
       agent
     end
-    
+
     def mocked_control
       server = NewRelic::Control::Server.new('localhost', 3000)
       control = OpenStruct.new(:license_key => 'abcdef',
@@ -229,7 +257,7 @@ module NewRelic
         def [](key)
           nil
         end
-        
+
         def fetch(k,d)
           nil
         end

data/test/new_relic/collection_helper_test.rb

@@ -24,7 +24,7 @@ class NewRelic::CollectionHelperTest < Test::Unit::TestCase
     assert_equal '1000', new_array[0]
   end
   def test_boolean
-    np = normalize_params(NewRelic::Control.instance.settings)
+    np = normalize_params('monitor_mode' => false)
     assert_equal false, np['monitor_mode']
   end
   def test_string__singleton
@@ -118,14 +118,13 @@ class NewRelic::CollectionHelperTest < Test::Unit::TestCase
   end
 
   def test_disabled_strip_backtrace
-    NewRelic::Control.instance['disable_backtrace_cleanup'] = true
-    clean_trace = strip_nr_from_backtrace(mock_backtrace)
-    assert_equal(1, clean_trace.grep(/new_relic/).size,
-            "should not remove instances of new relic from backtrace but got: #{clean_trace.join("\n")}")
-    assert_equal(1, clean_trace.grep(/_trace/).size, 
+    with_config(:disable_backtrace_cleanup => true) do
+      clean_trace = strip_nr_from_backtrace(mock_backtrace)
+      assert_equal(1, clean_trace.grep(/new_relic/).size,
+                   "should not remove instances of new relic from backtrace but got: #{clean_trace.join("\n")}")
+      assert_equal(1, clean_trace.grep(/_trace/).size,
                    "should not remove trace method tags from method names but got: #{clean_trace.join("\n")}")
-    #       assert (clean_trace.grep(/find/).size >= 3), "should see at least three frames with 'find' in them (#{e}): \n#{clean_trace.join("\n")}"
-    NewRelic::Control.instance['disable_backtrace_cleanup'] = false
+    end
   end
   
   private 

data/test/new_relic/command/deployments_test.rb

@@ -10,6 +10,8 @@ class NewRelic::Command::DeploymentsTest < Test::Unit::TestCase
       def info(message); @messages = @messages ? @messages + message : message; end
       def just_exit(status=0); @exit_status ||= status; end
     end
+    @config = { :license_key => 'a' * 40 }
+    NewRelic::Agent.config.apply_config(@config)
   end
   def teardown
     super
@@ -17,6 +19,7 @@ class NewRelic::Command::DeploymentsTest < Test::Unit::TestCase
     puts @deployment.errors
     puts @deployment.messages
     puts @deployment.exit_status
+    NewRelic::Agent.config.remove_config(@config)
   end
   def test_help
     begin
@@ -33,7 +36,10 @@ class NewRelic::Command::DeploymentsTest < Test::Unit::TestCase
   end
   def test_interactive
     mock_the_connection
-    @deployment = NewRelic::Command::Deployments.new :appname => 'APP', :revision => 3838, :user => 'Bill', :description => "Some lengthy description"
+    @deployment = NewRelic::Command::Deployments.new(:appname => 'APP',
+                                  :revision => 3838,
+                                  :user => 'Bill',
+                                  :description => "Some lengthy description")
     assert_nil @deployment.exit_status
     assert_nil @deployment.errors
     assert_equal '3838', @deployment.revision
@@ -56,7 +62,18 @@ class NewRelic::Command::DeploymentsTest < Test::Unit::TestCase
 
     @deployment = nil
   end
+
+  def test_error_if_no_license_key
+    with_config(:license_key => '') do
+      assert_raise NewRelic::Command::CommandFailure do
+      deployment = NewRelic::Command::Deployments.new(%w[-a APP -r 3838 --user=Bill] << "Some lengthy description")
+        deployment.run
+      end
+    end
+  end
+
   private
+
   def mock_the_connection
     mock_connection = mock()
     @mock_response = mock()
@@ -64,5 +81,4 @@ class NewRelic::Command::DeploymentsTest < Test::Unit::TestCase
     mock_connection.expects(:request).returns(@mock_response)
     NewRelic::Control.instance.stubs(:http_connection).returns(mock_connection)
   end
-
 end

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,91 @@ 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')
+    FileUtils.mkdir_p(File.dirname(path))
     @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.config.config_stack[0] =
+      NewRelic::Agent::Configuration::EnvironmentSource.new
   end
 end