newrelic_rpm 3.7.0.174.beta → 3.7.0.177

data/test/multiverse/suites/rails/ignore_test.rb

@@ -31,7 +31,7 @@ class IgnoredActionsTest < ActionDispatch::IntegrationTest
 
   def after_setup
     # Make sure we've got a blank slate for doing easier metric comparisons
-    NewRelic::Agent.instance.reset_stats
+    NewRelic::Agent.instance.drop_buffered_data
   end
 
   def test_metric__ignore

data/test/multiverse/suites/rails/request_statistics_test.rb

@@ -97,9 +97,7 @@ class RequestStatsTest < ActionController::TestCase
 
       # fail once
       $collector.stub('analytic_event_data', {}, 503)
-      assert_raises(NewRelic::Agent::ServerConnectionException) do
-        NewRelic::Agent.agent.send(:harvest_and_send_analytic_event_data)
-      end
+      NewRelic::Agent.agent.send(:harvest_and_send_analytic_event_data)
 
       # recover
       $collector.stub('analytic_event_data', {'return_value'=>nil}, 200)

data/test/multiverse/suites/sequel/sequel_instrumentation_test.rb

@@ -200,8 +200,9 @@ class NewRelic::Agent::Instrumentation::SequelInstrumentationTest < MiniTest::Un
   end
 
   def test_slow_queries_get_an_explain_plan
-    with_config( :'transaction_tracer.explain_threshold' => 0.0 ) do
-      segment = last_segment_for(:record_sql => :raw) do
+    with_config( :'transaction_tracer.explain_threshold' => -0.01,
+                 :'transaction_tracer.record_sql' => 'raw' ) do
+      segment = last_segment_for do
         Post[11]
       end
       assert_match %r{select \* from `posts` where `id` = 11}i, segment.params[:sql]
@@ -210,7 +211,11 @@ class NewRelic::Agent::Instrumentation::SequelInstrumentationTest < MiniTest::Un
   end
 
   def test_queries_can_get_explain_plan_with_obfuscated_sql
-    with_config( :'transaction_tracer.explain_threshold' => 0.0 ) do
+    config = {
+      :'transaction_tracer.explain_threshold' => -0.01,
+      :'transaction_tracer.record_sql' => 'obfuscated'
+    }
+    with_config(config) do
       segment = last_segment_for(:record_sql => :obfuscated) do
         Post[11]
       end
@@ -262,10 +267,8 @@ class NewRelic::Agent::Instrumentation::SequelInstrumentationTest < MiniTest::Un
         yield
       end
 
-      sample = transaction_samples.first.prepare_to_send!(
-        :explain_sql=>options[:explain_sql] || -0.01,    # Force to take explain, even if duration's reported as 0.0
-        :record_sql=>options[:record_sql])
-      segment = last_segment( sample )
+      sample = transaction_samples.first.prepare_to_send!
+      last_segment( sample )
   end
 
   def last_segment(txn_sample)

data/test/multiverse/suites/sinatra/ignoring_test.rb

@@ -155,7 +155,7 @@ class SinatraIgnoreItAllTest < SinatraTestCase
 
   def test_ignores_everything
     # Avoid Supportability metrics from startup of agent for this check
-    NewRelic::Agent.instance.reset_stats
+    NewRelic::Agent.drop_buffered_data
 
     get_and_assert_ok '/'
     assert_metrics_recorded_exclusive([])

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

@@ -38,7 +38,7 @@ class NewRelic::Agent::Agent::StartWorkerThreadTest < Test::Unit::TestCase
     # hooray for methods with no branches
     error = mock(:message => 'a message')
 
-    self.expects(:reset_stats)
+    self.expects(:drop_buffered_data)
     self.expects(:sleep).with(30)
     @connected = true
 

data/test/new_relic/agent/agent_logger_test.rb

@@ -25,24 +25,21 @@ class AgentLoggerTest < Test::Unit::TestCase
   LEVELS = [:fatal, :error, :warn, :info, :debug]
 
   def setup
-    @config = {
-      :log_file_path => "log/",
-      :log_file_name => "testlog.log",
-      :log_level => :info,
-    }
+    NewRelic::Agent.config.apply_config(:log_file_path => "log/",
+                                        :log_file_name => "testlog.log",
+                                        :log_level => :info)
   end
 
-
   #
   # Tests
   #
 
   def test_initalizes_from_config
-    logger = NewRelic::Agent::AgentLogger.new(@config)
+    logger = NewRelic::Agent::AgentLogger.new
 
     wrapped_logger = logger.instance_variable_get( :@log )
     logdev = wrapped_logger.instance_variable_get( :@logdev )
-    expected_logpath = File.expand_path( @config[:log_file_path] + @config[:log_file_name] )
+    expected_logpath = File.expand_path( NewRelic::Agent.config[:log_file_path] + NewRelic::Agent.config[:log_file_name] )
 
     assert_kind_of( Logger, wrapped_logger )
     assert_kind_of( File, logdev.dev )
@@ -51,64 +48,62 @@ class AgentLoggerTest < Test::Unit::TestCase
 
   def test_initalizes_from_override
     override_logger = Logger.new( '/dev/null' )
-    logger = NewRelic::Agent::AgentLogger.new(@config, "", override_logger)
+    logger = NewRelic::Agent::AgentLogger.new("", override_logger)
     assert_equal override_logger, logger.instance_variable_get(:@log)
   end
 
-
   def test_forwards_calls_to_logger
-    logdev = ArrayLogDevice.new
-    override_logger = Logger.new( logdev )
-    logger = NewRelic::Agent::AgentLogger.new(@config, "", override_logger)
+    logger = create_basic_logger
 
     LEVELS.each do |level|
       logger.send(level, "Boo!")
     end
 
-    assert_equal 4, logdev.array.length # No DEBUG
-
-    assert_match( /FATAL/, logdev.array[0] )
-    assert_match( /ERROR/, logdev.array[1] )
-    assert_match( /WARN/,  logdev.array[2] )
-    assert_match( /INFO/,  logdev.array[3] )
+    assert_logged(/FATAL/,
+                  /ERROR/,
+                  /WARN/,
+                  /INFO/) # No DEBUG
   end
 
-
   def test_forwards_calls_to_logger_with_multiple_arguments
-    logdev = ArrayLogDevice.new
-    override_logger = Logger.new( logdev )
-    logger = NewRelic::Agent::AgentLogger.new(@config, "", override_logger)
+    logger = create_basic_logger
 
     LEVELS.each do |level|
       logger.send(level, "What", "up?")
     end
 
-    assert_equal 8, logdev.array.length # No DEBUG, two per level
+    assert_logged(/FATAL/, /FATAL/,
+                  /ERROR/, /ERROR/,
+                  /WARN/,  /WARN/,
+                  /INFO/,  /INFO/) # No DEBUG
+  end
+
+  def test_forwards_calls_to_logger_once
+    logger = create_basic_logger
 
-    assert_match( /FATAL/, logdev.array[0] )
-    assert_match( /FATAL/, logdev.array[1] )
-    assert_match( /ERROR/, logdev.array[2] )
-    assert_match( /ERROR/, logdev.array[3] )
-    assert_match( /WARN/,  logdev.array[4] )
-    assert_match( /WARN/,  logdev.array[5] )
-    assert_match( /INFO/,  logdev.array[6] )
-    assert_match( /INFO/,  logdev.array[7] )
+    LEVELS.each do |level|
+      logger.send(:log_once, level, :special_key, "Special!")
+    end
+
+    assert_logged(/Special/)
   end
 
   def test_wont_log_if_agent_not_enabled
-    @config[:agent_enabled] = false
-    logger = NewRelic::Agent::AgentLogger.new(@config)
-    assert_nothing_raised do
-      logger.warn('hi there')
-    end
+    with_config(:agent_enabled => false) do
+      logger = NewRelic::Agent::AgentLogger.new
+      assert_nothing_raised do
+        logger.warn('hi there')
+      end
 
-    assert_kind_of NewRelic::Agent::NullLogger, logger.instance_variable_get( :@log )
+      assert_kind_of NewRelic::Agent::NullLogger, logger.instance_variable_get( :@log )
+    end
   end
 
   def test_does_not_touch_dev_null
     Logger.expects(:new).with('/dev/null').never
-    @config[:agent_enabled] = false
-    logger = NewRelic::Agent::AgentLogger.new(@config)
+    with_config(:agent_enabled => false) do
+      logger = NewRelic::Agent::AgentLogger.new
+    end
   end
 
   def test_maps_log_levels
@@ -123,38 +118,39 @@ class AgentLoggerTest < Test::Unit::TestCase
   end
 
   def test_sets_log_level
-    @config[:log_level] = :debug
-
-    override_logger = Logger.new( $stderr )
-    override_logger.level = Logger::FATAL
+    with_config(:log_level => :debug) do
+      override_logger = Logger.new( $stderr )
+      override_logger.level = Logger::FATAL
 
-    logger = NewRelic::Agent::AgentLogger.new(@config, "", override_logger)
+      logger = NewRelic::Agent::AgentLogger.new("", override_logger)
 
-    assert_equal Logger::DEBUG, override_logger.level
+      assert_equal Logger::DEBUG, override_logger.level
+    end
   end
 
   def test_log_to_stdout_and_warns_if_failed_on_create
-      Dir.stubs(:mkdir).returns(nil)
-      config = @config.merge( :log_file_path => '/someplace/non/existant' )
+    Dir.stubs(:mkdir).returns(nil)
 
-    logger = with_squelched_stdout do
-      NewRelic::Agent::AgentLogger.new(config)
-    end
+    with_config(:log_file_path => '/someplace/nonexistent') do
+      logger = with_squelched_stdout do
+        NewRelic::Agent::AgentLogger.new
+      end
 
-    wrapped_logger = logger.instance_variable_get(:@log)
-    logdev = wrapped_logger.instance_variable_get(:@logdev)
+      wrapped_logger = logger.instance_variable_get(:@log)
+      logdev = wrapped_logger.instance_variable_get(:@logdev)
 
-    assert_equal $stdout, logdev.dev
+      assert_equal $stdout, logdev.dev
+    end
   end
 
   def test_log_to_stdout_based_on_config
-    @config[:log_file_path] = "STDOUT"
+    with_config(:log_file_path => 'STDOUT') do
+      logger = NewRelic::Agent::AgentLogger.new
+      wrapped_logger = logger.instance_variable_get(:@log)
+      logdev = wrapped_logger.instance_variable_get(:@logdev)
 
-    logger = NewRelic::Agent::AgentLogger.new(@config)
-    wrapped_logger = logger.instance_variable_get(:@log)
-    logdev = wrapped_logger.instance_variable_get(:@logdev)
-
-    assert_equal $stdout, logdev.dev
+      assert_equal $stdout, logdev.dev
+    end
   end
 
   def test_startup_purges_memory_logger
@@ -162,22 +158,16 @@ class AgentLoggerTest < Test::Unit::TestCase
       ::NewRelic::Agent::StartupLogger.instance.send(level, "boo!")
     end
 
-    logdev = ArrayLogDevice.new
-    override_logger = Logger.new( logdev )
-    logger = NewRelic::Agent::AgentLogger.new(@config, "", override_logger)
+    logger = create_basic_logger
 
-    assert_equal 4, logdev.array.length # No DEBUG
-
-    assert_match( /FATAL/, logdev.array[0] )
-    assert_match( /ERROR/, logdev.array[1] )
-    assert_match( /WARN/,  logdev.array[2] )
-    assert_match( /INFO/,  logdev.array[3] )
+    assert_logged(/FATAL/,
+                  /ERROR/,
+                  /WARN/,
+                  /INFO/) # No DEBUG
   end
 
   def test_passing_exceptions_only_logs_the_message_at_levels_higher_than_debug
-    logdev = ArrayLogDevice.new
-    override_logger = Logger.new( logdev )
-    logger = NewRelic::Agent::AgentLogger.new(@config, "", override_logger)
+    logger = create_basic_logger
 
     begin
       raise "Something bad happened"
@@ -185,80 +175,66 @@ class AgentLoggerTest < Test::Unit::TestCase
       logger.error( err )
     end
 
-    assert_equal 1, logdev.array.length
-    assert_match( /ERROR : RuntimeError: Something bad happened/i, logdev.array[0] )
+    assert_logged(/ERROR : RuntimeError: Something bad happened/i)
   end
 
   def test_passing_exceptions_logs_the_backtrace_at_debug_level
-    config = @config.merge(:log_level => :debug)
+    with_config(:log_level => :debug) do
+      logger = create_basic_logger
 
-    logdev = ArrayLogDevice.new
-    override_logger = Logger.new( logdev )
-    logger = NewRelic::Agent::AgentLogger.new(config, "", override_logger)
+      begin
+        raise "Something bad happened"
+      rescue => err
+        logger.error( err )
+      end
 
-    begin
-      raise "Something bad happened"
-    rescue => err
-      logger.error( err )
+      assert_logged(/ERROR : RuntimeError: Something bad happened/i,
+                    /DEBUG : Debugging backtrace:\n.*test_passing_exceptions/i)
     end
-
-    assert_equal 2, logdev.array.length
-    assert_match( /ERROR : RuntimeError: Something bad happened/i, logdev.array[0] )
-    assert_match( /DEBUG : Debugging backtrace:\n.*test_passing_exceptions/i,
-                  logdev.array[1] )
   end
 
   def test_format_message_allows_nil_backtrace
-    config = @config.merge(:log_level => :debug)
-
-    logdev = ArrayLogDevice.new
-    override_logger = Logger.new( logdev )
-    logger = NewRelic::Agent::AgentLogger.new(config, "", override_logger)
+    with_config(:log_level => :debug) do
+      logger = create_basic_logger
 
-    e = Exception.new("Look Ma, no backtrace!")
-    assert_nil(e.backtrace)
-    logger.error(e)
+      e = Exception.new("Look Ma, no backtrace!")
+      assert_nil(e.backtrace)
+      logger.error(e)
 
-    assert_equal 2, logdev.array.length
-    assert_match( /ERROR : Exception: Look Ma, no backtrace!/i, logdev.array[0] )
-    assert_match( /DEBUG : No backtrace available./, logdev.array[1])
+      assert_logged(/ERROR : Exception: Look Ma, no backtrace!/i,
+                    /DEBUG : No backtrace available./)
+    end
   end
 
   def test_log_exception_logs_backtrace_at_same_level_as_message_by_default
-    logdev = ArrayLogDevice.new
-    override_logger = Logger.new(logdev)
-    logger = NewRelic::Agent::AgentLogger.new(@config, "", override_logger)
+    logger = create_basic_logger
 
     e = Exception.new("howdy")
     e.set_backtrace(["wiggle", "wobble", "topple"])
 
     logger.log_exception(:info, e)
 
-    assert_match(/INFO : Exception: howdy/i, logdev.array[0])
-    assert_match(/INFO : Debugging backtrace:\n.*wiggle\s+wobble\s+topple/,
-                  logdev.array[1])
+    assert_logged(/INFO : Exception: howdy/i,
+                  /INFO : Debugging backtrace:\n.*wiggle\s+wobble\s+topple/)
   end
 
   def test_log_exception_logs_backtrace_at_explicitly_specified_level
-    logdev = ArrayLogDevice.new
-    override_logger = Logger.new(logdev)
-    logger = NewRelic::Agent::AgentLogger.new(@config, "", override_logger)
+    logger = create_basic_logger
 
     e = Exception.new("howdy")
     e.set_backtrace(["wiggle", "wobble", "topple"])
 
     logger.log_exception(:warn, e, :info)
 
-    assert_match(/WARN : Exception: howdy/i, logdev.array[0])
-    assert_match(/INFO : Debugging backtrace:\n.*wiggle\s+wobble\s+topple/,
-                  logdev.array[1])
+    assert_logged(/WARN : Exception: howdy/i,
+                  /INFO : Debugging backtrace:\n.*wiggle\s+wobble\s+topple/)
   end
 
   def test_logs_to_stdout_if_fails_on_file
     Logger::LogDevice.any_instance.stubs(:open).raises(Errno::EACCES)
 
     logger = with_squelched_stdout do
-      NewRelic::Agent::AgentLogger.new(@config, "")
+      NewRelic::Agent::AgentLogger.new
     end
 
     wrapped_logger = logger.instance_variable_get(:@log)
@@ -272,9 +248,11 @@ class AgentLoggerTest < Test::Unit::TestCase
       def debug; end
     end
 
-    logger = NewRelic::Agent::AgentLogger.new(@config.merge(:agent_enabled => false))
-    assert_nothing_raised do
-      logger.debug('hi!')
+    logger = NewRelic::Agent::AgentLogger.new
+    with_config(:agent_enabled => false) do
+      assert_nothing_raised do
+        logger.debug('hi!')
+      end
     end
   ensure
     Kernel.module_eval do
@@ -288,6 +266,16 @@ class AgentLoggerTest < Test::Unit::TestCase
   # Helpers
   #
 
+  def logged_lines
+    @logdev.array
+  end
+
+  def create_basic_logger
+    @logdev = ArrayLogDevice.new
+    override_logger = Logger.new(@logdev)
+    NewRelic::Agent::AgentLogger.new("", override_logger)
+  end
+
   def with_squelched_stdout
     orig = $stdout.dup
     $stdout.reopen( '/dev/null' )
@@ -296,4 +284,10 @@ class AgentLoggerTest < Test::Unit::TestCase
     $stdout.reopen( orig )
   end
 
+  def assert_logged(*args)
+    assert_equal(args.length, logged_lines.length)
+    logged_lines.each_with_index do |line, index|
+      assert_match(args[index], line)
+    end
+  end
 end

data/test/new_relic/agent/agent_test.rb

@@ -78,6 +78,7 @@ module NewRelic
 
       def test_transmit_data_should_transmit
         @agent.service.expects(:metric_data).at_least_once
+        @agent.stats_engine.record_metrics(['foo'], 12)
         @agent.instance_eval { transmit_data }
       end
 
@@ -100,10 +101,8 @@ module NewRelic
                        :transaction_name => nil,
                        :force_persist => true,
                        :truncate => 4000)
-          trace.expects(:prepare_to_send!).with(:record_sql => :raw,
-                                               :explain_sql => 2)
 
-          @agent.transaction_sampler.stubs(:harvest).returns([trace])
+          @agent.transaction_sampler.stubs(:harvest!).returns([trace])
           @agent.send :harvest_and_send_transaction_traces
         end
       end
@@ -111,10 +110,7 @@ module NewRelic
       def test_harvest_and_send_transaction_traces_merges_back_on_failure
         traces = [mock('tt1'), mock('tt2')]
 
-        # make prepare_to_send just return self
-        traces.each { |tt| tt.expects(:prepare_to_send!).returns(tt) }
-
-        @agent.transaction_sampler.expects(:harvest).returns(traces)
+        @agent.transaction_sampler.expects(:harvest!).returns(traces)
         @agent.service.stubs(:transaction_sample_data).raises("wat")
         @agent.transaction_sampler.expects(:merge!).with(traces)
 
@@ -126,7 +122,7 @@ module NewRelic
       def test_harvest_and_send_errors_merges_back_on_failure
         errors = [mock('e0'), mock('e1')]
 
-        @agent.error_collector.expects(:harvest_errors).returns(errors)
+        @agent.error_collector.expects(:harvest!).returns(errors)
         @agent.service.stubs(:error_data).raises('wat')
         @agent.error_collector.expects(:merge!).with(errors)
 
@@ -135,11 +131,6 @@ module NewRelic
         end
       end
 
-      def test_harvest_timeslice_data
-        assert_equal({}, @agent.send(:harvest_timeslice_data),
-                     'should return timeslice data')
-      end
-
       # This test asserts nothing about correctness of logging data from multiple
       # threads, since the get_stats + record_data_point combo is not designed
       # to be thread-safe, but it does ensure that writes to the stats hash
@@ -161,7 +152,7 @@ module NewRelic
             threads << t
           end
 
-          100.times { @agent.send(:harvest_timeslice_data) }
+          100.times { @agent.send(:harvest_and_send_timeslice_data) }
           threads.each { |t| t.join }
         end
       end
@@ -171,9 +162,16 @@ module NewRelic
         @agent.send :check_for_and_handle_agent_commands
       end
 
+      def test_check_for_and_handle_agent_commands_with_error
+        @agent.service.expects(:get_agent_commands).raises('bad news')
+        assert_nothing_raised do
+          @agent.send :check_for_and_handle_agent_commands
+        end
+      end
+
       def test_harvest_and_send_for_agent_commands
         @agent.service.expects(:profile_data).with(any_parameters)
-        @agent.agent_command_router.stubs(:harvest_data_to_send).returns({:profile_data => Object.new})
+        @agent.agent_command_router.stubs(:harvest!).returns({:profile_data => [Object.new]})
         @agent.send :harvest_and_send_for_agent_commands
       end
 
@@ -211,21 +209,19 @@ module NewRelic
         request_sampler = @agent.instance_variable_get(:@request_sampler)
         samples = [mock('some analytics event')]
 
-        request_sampler.expects(:harvest).returns(samples)
+        request_sampler.expects(:harvest!).returns(samples)
         request_sampler.expects(:merge!).with(samples)
 
         # simulate a failure in transmitting analytics events
         service.stubs(:analytic_event_data).raises(StandardError.new)
 
-        assert_raises(StandardError) do
-          @agent.send(:harvest_and_send_analytic_event_data)
-        end
+        @agent.send(:harvest_and_send_analytic_event_data)
       end
 
       def test_harvest_and_send_timeslice_data_merges_back_on_failure
-        timeslices = mock('timeslices')
+        timeslices = [1,2,3]
 
-        @agent.stats_engine.expects(:harvest).returns(timeslices)
+        @agent.stats_engine.expects(:harvest!).returns(timeslices)
         @agent.service.stubs(:metric_data).raises('wat')
         @agent.stats_engine.expects(:merge!).with(timeslices)
 
@@ -353,6 +349,128 @@ module NewRelic
         assert done
       end
 
+      def test_harvest_from_container
+        container = mock
+        harvested_items = ['foo', 'bar', 'baz']
+        container.expects(:harvest!).returns(harvested_items)
+        items = @agent.send(:harvest_from_container, container, 'digglewumpus')
+        assert_equal(harvested_items, items)
+      end
+
+      def test_harvest_from_container_with_error
+        container = mock
+        container.stubs(:harvest!).raises('an error')
+        container.expects(:reset!)
+        @agent.send(:harvest_from_container, container, 'digglewumpus')
+      end
+
+      def send_data_from_container
+        service = @agent.service
+        items = [1, 2, 3]
+        service.expects(:dummy_endpoint).with(items)
+        @agent.send(:send_data_from_container, stub, 'dummy_endpoint', items)
+      end
+
+      def send_data_from_container_with_unrecoverable_server_error
+        service = @agent.service
+        container = mock('data container')
+        container.expects(:merge!).never
+        items = [1, 2, 3]
+        service.expects(:dummy_endpoint).raises(UnrecoverableServerException)
+        @agent.send(:send_data_from_container, container, 'dummy_endpoint', items)
+      end
+
+      def send_data_from_container_with_other_error
+        service = @agent.service
+        items = [1, 2, 3]
+        container = mock('data container')
+        container.expects(:merge!).with(items)
+        service.expects(:dummy_endpoint).raises('other errors')
+        @agent.send(:send_data_from_container, container, 'dummy_endpoint', items)
+      end
+
+      def harvest_and_send_from_container
+        container = mock('data container')
+        items = [1, 2, 3]
+        container.expects(:harvest!).returns(items)
+        service = @agent.service
+        service.expects(:dummy_endpoint).with(items)
+        @agent.send(:harvest_and_send_from_container, container, 'dummy_endpoint')
+      end
+
+      def harvest_and_send_from_container_does_not_harvest_if_nothing_to_send
+        container = mock('data container')
+        items = []
+        container.expects(:harvest!).returns(items)
+        service = @agent.service
+        service.expects(:dummy_endpoint).never
+        @agent.send(:harvest_and_send_from_container, container, 'dummy_endpoint')
+      end
+
+      def harvest_and_send_from_container_resets_on_harvest_failure
+        container = mock('data container')
+        container.stubs(:harvest!).raises('an error')
+        container.expects(:reset!)
+        @agent.service.expects(:dummy_endpoint).never
+        @agent.send(:harvest_and_send_from_container, container, 'dummy_endpoint')
+      end
+
+      def harvest_and_send_from_container_does_not_merge_on_unrecoverable_failure
+        container = mock('data container')
+        container.stubs(:harvest!).returns([1,2,3])
+        @agent.service.expects(:dummy_endpoint).with([1,2,3]).raises(UnrecoverableServerException)
+        container.expects(:merge!).never
+        @agent.send(:harvest_and_send_from_container, container, 'dummy_endpoint')
+      end
+
+      def harvest_and_send_from_container_merges_on_other_failure
+        container = mock('data container')
+        container.stubs(:harvest!).returns([1,2,3])
+        @agent.service.expects(:dummy_endpoint).with([1,2,3]).raises('other error')
+        container.expects(:merge!).with([1,2,3])
+        @agent.send(:harvest_and_send_from_container, container, 'dummy_endpoint')
+      end
+
+      def test_harvest_and_send_from_container_does_not_swallow_forced_errors
+        container = mock('data container')
+        container.stubs(:harvest!).returns([1])
+
+        error_classes = [
+          NewRelic::Agent::ForceRestartException,
+          NewRelic::Agent::ForceDisconnectException
+        ]
+
+        error_classes.each do |cls|
+          @agent.service.expects(:dummy_endpoint).with([1]).raises(cls.new)
+          assert_raise(cls) do
+            @agent.send(:harvest_and_send_from_container, container, 'dummy_endpoint')
+          end
+        end
+      end
+
+      def test_check_for_and_handle_agent_commands_does_not_swallow_forced_errors
+        error_classes = [
+          NewRelic::Agent::ForceRestartException,
+          NewRelic::Agent::ForceDisconnectException
+        ]
+
+        error_classes.each do |cls|
+          @agent.service.expects(:get_agent_commands).raises(cls.new)
+          assert_raise(cls) do
+            @agent.send(:check_for_and_handle_agent_commands)
+          end
+        end
+      end
+
+      def test_graceful_disconnect_should_emit_before_disconnect_event
+        before_shutdown_call_count = 0
+        @agent.events.subscribe(:before_shutdown) do
+          before_shutdown_call_count += 1
+        end
+        @agent.stubs(:connected?).returns(true)
+        @agent.send(:graceful_disconnect)
+        assert_equal(1, before_shutdown_call_count)
+      end
     end