sundawg_newrelic_rpm 3.5.8.1

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

@@ -0,0 +1,88 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+class NewRelic::Agent::Agent::StartWorkerThreadTest < Test::Unit::TestCase
+  require 'new_relic/agent/agent'
+  include NewRelic::Agent::Agent::StartWorkerThread
+
+  def test_deferred_work_connects
+    self.expects(:catch_errors).yields
+    self.expects(:connect).with('connection_options')
+    self.stubs(:connected?).returns(true)
+    self.expects(:log_worker_loop_start)
+    self.expects(:create_and_run_worker_loop)
+    deferred_work!('connection_options')
+  end
+
+  def test_deferred_work_connect_failed
+    self.expects(:catch_errors).yields
+    self.expects(:connect).with('connection_options')
+    self.stubs(:connected?).returns(false)
+    deferred_work!('connection_options')
+  end
+
+  def test_create_and_run_worker_loop
+    @should_send_samples = true
+    wl = mock('worker loop')
+    NewRelic::Agent::WorkerLoop.expects(:new).returns(wl)
+    wl.expects(:run).with(30).yields
+    self.expects(:transmit_data)
+    with_config(:data_report_period => 30) do
+      create_and_run_worker_loop
+    end
+  end
+
+  def test_handle_force_restart
+    # hooray for methods with no branches
+    error = mock(:message => 'a message')
+
+    self.expects(:reset_stats)
+    self.expects(:sleep).with(30)
+    @connected = true
+
+    handle_force_restart(error)
+
+    assert_equal(:pending, @connect_state)
+  end
+
+  def test_handle_force_disconnect
+    error = mock(:message => 'a message')
+
+    self.expects(:disconnect)
+    handle_force_disconnect(error)
+  end
+
+  def test_handle_server_connection_problem
+    error = StandardError.new('a message')
+
+    self.expects(:disconnect)
+    handle_server_connection_problem(error)
+  end
+
+  def test_handle_other_error
+    error = StandardError.new('a message')
+
+    self.expects(:disconnect)
+    handle_other_error(error)
+  end
+
+  def test_catch_errors_force_restart
+    @runs = 0
+    error = NewRelic::Agent::ForceRestartException.new
+    # twice, because we expect it to retry the block
+    self.expects(:handle_force_restart).with(error).twice
+    catch_errors do
+      # needed to keep it from looping infinitely in the test
+      @runs += 1
+      raise error unless @runs > 2
+    end
+    assert_equal 3, @runs, 'should retry the block when it fails'
+  end
+
+  private
+
+  def mocked_control
+    fake_control = mock('control')
+    self.stubs(:control).returns(fake_control)
+    fake_control
+  end
+end
+

data/test/new_relic/agent/agent_logger_test.rb

@@ -0,0 +1,153 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+require 'new_relic/agent/agent_logger'
+
+class AgentLoggerTest < Test::Unit::TestCase
+  def setup
+    @config = {
+      :log_file_path => "log/",
+      :log_file_name => "testlog.log",
+      :log_level => :info,
+    }
+  end
+
+  def test_initalizes_from_config
+    override_logger = stub(:level=)
+    ::Logger.stubs(:new).with(any_parameters).returns(override_logger)
+
+    logger = NewRelic::Agent::AgentLogger.new(@config)
+    assert_equal(override_logger, logger.instance_variable_get(:@log))
+  end
+
+  def test_initalizes_from_override
+    override_logger = stub(:level=)
+    logger = NewRelic::Agent::AgentLogger.new(@config, "", override_logger)
+    assert_equal override_logger, logger.instance_variable_get(:@log)
+  end
+
+  def test_forwards_calls_to_logger
+    [:fatal, :error, :warn, :info, :debug].each do |level|
+      override_logger = stub(:level=)
+      override_logger.expects(level).with(any_parameters)
+
+      logger = NewRelic::Agent::AgentLogger.new(@config, "", override_logger)
+
+      logger.send(level, "Boo!")
+    end
+  end
+
+
+  def test_forwards_calls_to_logger_with_multiple_arguments
+    [:fatal, :error, :warn, :info, :debug].each do |level|
+      override_logger = stub(:level=)
+      override_logger.expects(level).with("What\nup?")
+
+      logger = NewRelic::Agent::AgentLogger.new(@config, "", override_logger)
+
+      logger.send(level, "What", "up?")
+    end
+  end
+
+  def test_passing_exceptions_gets_pretty_formatting
+    caught = nil
+    begin
+      raise Exception.new("Boo!")
+    rescue Exception => e
+      caught = e
+    end
+
+    # Checking if it looks like message includes backtrace
+    override_logger = stub(:level=)
+    override_logger.expects(:debug).with {|msg| msg.include?("test_") }
+
+    NewRelic::Agent::AgentLogger.new(@config, "", override_logger).debug(e)
+  end
+
+  def test_wont_log_if_agent_not_enabled
+    ::Logger.stubs(:new).with("/dev/null").returns(stub(:level=)).at_least_once
+
+    @config[:agent_enabled] = false
+    logger = NewRelic::Agent::AgentLogger.new(@config)
+  end
+
+  def test_logs_to_nul_if_dev_null_not_there
+    File.stubs(:exists?).with("/dev/null").returns(false)
+    File.stubs(:exists?).with("NUL").returns(true)
+
+    ::Logger.stubs(:new).with("NUL").returns(stub(:level=)).once
+
+    @config[:agent_enabled] = false
+    logger = NewRelic::Agent::AgentLogger.new(@config)
+  end
+
+  def test_maps_log_levels
+    assert_equal Logger::FATAL, NewRelic::Agent::AgentLogger.log_level_for(:fatal)
+    assert_equal Logger::ERROR, NewRelic::Agent::AgentLogger.log_level_for(:error)
+    assert_equal Logger::WARN,  NewRelic::Agent::AgentLogger.log_level_for(:warn)
+    assert_equal Logger::INFO,  NewRelic::Agent::AgentLogger.log_level_for(:info)
+    assert_equal Logger::DEBUG, NewRelic::Agent::AgentLogger.log_level_for(:debug)
+
+    assert_equal Logger::INFO, NewRelic::Agent::AgentLogger.log_level_for("")
+    assert_equal Logger::INFO, NewRelic::Agent::AgentLogger.log_level_for(:unknown)
+  end
+
+  def test_sets_log_level
+    override_logger = mock()
+    override_logger.expects(:level=).with(Logger::DEBUG)
+    @config[:log_level] = :debug
+
+    logger = NewRelic::Agent::AgentLogger.new(@config, "", override_logger)
+  end
+
+  def test_log_to_stdout_and_warns_if_failed_on_create
+    NewRelic::Agent::AgentLogger.any_instance.stubs(:find_or_create_file_path).returns(nil)
+
+    stdout = stub(:level=)
+    stdout.expects(:warn)
+    ::Logger.stubs(:new).with(STDOUT).returns(stdout)
+
+    logger = NewRelic::Agent::AgentLogger.new(@config)
+    assert_equal stdout, logger.instance_variable_get(:@log)
+  end
+
+  def test_log_to_stdout_based_on_config
+    @config[:log_file_path] = "STDOUT"
+
+    stdout = stub(:level=)
+    stdout.expects(:warn).never
+    ::Logger.stubs(:new).with(STDOUT).returns(stdout)
+
+    logger = NewRelic::Agent::AgentLogger.new(@config)
+    assert_equal stdout, logger.instance_variable_get(:@log)
+  end
+
+  def test_startup_purges_memory_logger
+    [:fatal, :error, :warn, :info, :debug].each do |level|
+      ::NewRelic::Agent::StartupLogger.instance.send(level, "boo!")
+
+      override_logger = stub(:level=)
+      override_logger.expects(level).with("boo!")
+
+      NewRelic::Agent::AgentLogger.new(@config, "", override_logger)
+    end
+  end
+
+  def test_format_message_allows_nil_backtrace
+    override_logger = stub(:level=)
+    override_logger.expects(:debug)
+
+    logger = ::NewRelic::Agent::AgentLogger.new(@config, "", override_logger)
+
+    logger.debug(Exception.new("Look Ma, no backtrace!"))
+  end
+
+
+  def test_logs_to_stdout_if_fails_on_file
+    stdout = stub_everything()
+    ::Logger.stubs(:new).with(STDOUT).returns(stdout)
+    ::Logger.stubs(:new).with(instance_of(String)).raises(Errno::EACCES)
+
+    logger = NewRelic::Agent::AgentLogger.new(@config, "")
+
+    assert_equal stdout, logger.instance_variable_get(:@log)
+  end
+end

data/test/new_relic/agent/agent_test.rb

@@ -0,0 +1,301 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+require 'new_relic/agent/thread_profiler'
+
+module NewRelic
+  module Agent
+    class AgentTest < Test::Unit::TestCase
+
+      def setup
+        super
+        @agent = NewRelic::Agent::Agent.new
+        @agent.service = default_service
+      end
+
+      #
+      # Helpers
+      #
+
+      def with_profile(opts)
+        profile = NewRelic::Agent::ThreadProfile.new(-1, 0, 0, true)
+        profile.aggregate(["chunky.rb:42:in `bacon'"], profile.traces[:other])
+        profile.instance_variable_set(:@finished, opts[:finished])
+
+        @agent.thread_profiler.instance_variable_set(:@profile, profile)
+        profile
+      end
+
+      #
+      # Tests
+      #
+
+      def test_after_fork_reporting_to_channel
+        @agent.stubs(:connected?).returns(true)
+        @agent.after_fork(:report_to_channel => 123)
+        assert(@agent.service.kind_of?(NewRelic::Agent::PipeService),
+               'Agent should use PipeService when directed to report to pipe channel')
+        NewRelic::Agent::PipeService.any_instance.expects(:shutdown).never
+        assert_equal 123, @agent.service.channel_id
+      end
+
+      def test_after_fork_should_close_pipe_if_parent_not_connected
+        pipe = mock
+        pipe.expects(:write).with('EOF')
+        pipe.expects(:close)
+        dummy_channels = { 123 => pipe }
+        NewRelic::Agent::PipeChannelManager.stubs(:channels).returns(dummy_channels)
+
+        @agent.stubs(:connected?).returns(false)
+        @agent.after_fork(:report_to_channel => 123)
+        assert(@agent.disconnected?)
+      end
+
+      def test_transmit_data_should_transmit
+        @agent.service.expects(:metric_data).at_least_once
+        @agent.instance_eval { transmit_data }
+      end
+
+      def test_transmit_data_should_use_one_http_handle_per_harvest
+        @agent.service.expects(:session).once
+        @agent.instance_eval { transmit_data }
+      end
+
+      def test_transmit_data_should_close_explain_db_connections
+        NewRelic::Agent::Database.expects(:close_connections)
+        @agent.instance_eval { transmit_data }
+      end
+
+      def test_transmit_data_should_not_close_db_connections_if_forked
+        NewRelic::Agent::Database.expects(:close_connections).never
+        @agent.after_fork
+        @agent.instance_eval { transmit_data }
+      end
+
+      def test_harvest_transaction_traces
+        assert_equal([], @agent.send(:harvest_transaction_traces), 'should return transaction traces')
+      end
+
+      def test_harvest_and_send_slowest_sample
+        with_config(:'transaction_tracer.explain_threshold' => 2,
+                    :'transaction_tracer.explain_enabled' => true,
+                    :'transaction_tracer.record_sql' => 'raw') do
+          trace = stub('transaction trace', :force_persist => true,
+                       :truncate => 4000)
+          trace.expects(:prepare_to_send).with(:record_sql => :raw,
+                                               :explain_sql => 2,
+                                               :keep_backtraces => true)
+          @agent.instance_variable_set(:@traces, [ trace ])
+          @agent.send :harvest_and_send_slowest_sample
+        end
+      end
+
+      def test_graceful_shutdown_ends_thread_profiling
+        @agent.thread_profiler.expects(:stop).once
+        @agent.stubs(:connected?).returns(true)
+        @agent.send(:graceful_disconnect)
+      end
+
+      def test_harvest_and_send_thread_profile
+        profile = with_profile(:finished => true)
+        @agent.service.expects(:profile_data).with(any_parameters)
+        @agent.send(:harvest_and_send_thread_profile, false)
+      end
+
+      def test_harvest_and_send_thread_profile_when_not_finished
+        with_profile(:finished => false)
+        @agent.service.expects(:profile_data).never
+        @agent.send(:harvest_and_send_thread_profile, false)
+      end
+
+      def test_harvest_and_send_thread_profile_when_not_finished_but_disconnecting
+        profile = with_profile(:finished => false)
+        @agent.service.expects(:profile_data).with(any_parameters)
+        @agent.send(:harvest_and_send_thread_profile, true)
+      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
+      # via this path that happen concurrently with harvests will not cause
+      # 'hash modified during iteration' errors.
+      def test_harvest_timeslice_data_should_be_thread_safe
+        threads = []
+        nthreads = 10
+        nmetrics = 100
+
+        assert_nothing_raised do
+          nthreads.times do |tid|
+            t = Thread.new do
+              nmetrics.times do |mid|
+                @agent.stats_engine.get_stats("m#{mid}").record_data_point(1)
+              end
+            end
+            t.abort_on_exception = true
+            threads << t
+          end
+
+          100.times { @agent.send(:harvest_timeslice_data) }
+          threads.each { |t| t.join }
+        end
+      end
+
+      def test_harvest_errors
+        assert_equal([], @agent.send(:harvest_errors), 'should return errors')
+      end
+
+      def test_check_for_agent_commands
+        @agent.service.expects(:get_agent_commands).returns([]).once
+        @agent.send :check_for_agent_commands
+      end
+
+      def test_merge_data_from_empty
+        unsent_timeslice_data = mock('unsent timeslice data')
+        unsent_errors = mock('unsent errors')
+        unsent_traces = mock('unsent traces')
+        @agent.instance_eval {
+          @unsent_errors = unsent_errors
+          @unsent_timeslice_data = unsent_timeslice_data
+          @traces = unsent_traces
+        }
+        # nb none of the others should receive merge requests
+        @agent.merge_data_from([{}])
+      end
+
+      def test_unsent_errors_size_empty
+        @agent.instance_eval {
+          @unsent_errors = nil
+        }
+        assert_equal(nil, @agent.unsent_errors_size)
+      end
+
+      def test_unsent_errors_size_with_errors
+        @agent.instance_eval {
+          @unsent_errors = ['an error']
+        }
+        assert_equal(1, @agent.unsent_errors_size)
+      end
+
+      def test_unsent_traces_size_empty
+        @agent.instance_eval {
+          @traces = nil
+        }
+        assert_equal(nil, @agent.unsent_traces_size)
+      end
+
+      def test_unsent_traces_size_with_traces
+        @agent.instance_eval {
+          @traces = ['a trace']
+        }
+        assert_equal(1, @agent.unsent_traces_size)
+      end
+
+      def test_unsent_timeslice_data_empty
+        @agent.instance_eval {
+          @unsent_timeslice_data = nil
+        }
+        assert_equal(0, @agent.unsent_timeslice_data, "should have zero timeslice data to start")
+        assert_equal({}, @agent.instance_variable_get('@unsent_timeslice_data'), "should initialize the timeslice data to an empty hash if it is empty")
+      end
+
+      def test_unsent_timeslice_data_with_errors
+        @agent.instance_eval {
+          @unsent_timeslice_data = {:key => 'value'}
+        }
+        assert_equal(1, @agent.unsent_timeslice_data, "should have the key from above")
+      end
+
+      def test_merge_data_traces
+        unsent_traces = mock('unsent traces')
+        @agent.instance_eval {
+          @traces = unsent_traces
+        }
+        unsent_traces.expects(:+).with([1,2,3])
+        @agent.merge_data_from([{}, [1,2,3], []])
+      end
+
+      def test_merge_data_from_abides_by_error_queue_limit
+        errors = []
+        40.times { |i| errors << Exception.new("boo #{i}") }
+
+        @agent.merge_data_from([{}, [], errors])
+
+        assert_equal 20, @agent.error_collector.errors.length
+
+        # This method should NOT increment error counts, since that has already
+        # been counted in the child
+        assert_equal 0, NewRelic::Agent.get_stats("Errors/all").call_count
+      end
+
+      def test_connect_retries_on_timeout
+        service = @agent.service
+        def service.connect(opts={})
+          unless @tried
+            @tried = true
+            raise Timeout::Error
+          end
+          nil
+        end
+        @agent.stubs(:connect_retry_period).returns(0)
+        @agent.send(:connect)
+        assert(@agent.connected?)
+      end
+
+      def test_connect_does_not_retry_if_keep_retrying_false
+        @agent.service.expects(:connect).once.raises(Timeout::Error)
+        @agent.send(:connect, :keep_retrying => false)
+        assert(@agent.disconnected?)
+      end
+
+      def test_connect_does_not_retry_on_license_error
+        @agent.service.expects(:connect).raises(NewRelic::Agent::LicenseException)
+        @agent.send(:connect)
+        assert(@agent.disconnected?)
+      end
+
+      def test_connect_does_not_reconnect_by_default
+        @agent.stubs(:connected?).returns(true)
+        @agent.service.expects(:connect).never
+        @agent.send(:connect)
+      end
+
+      def test_connect_does_not_reconnect_if_disconnected
+        @agent.stubs(:disconnected?).returns(true)
+        @agent.service.expects(:connect).never
+        @agent.send(:connect)
+      end
+
+      def test_connect_does_reconnect_if_forced
+        @agent.stubs(:connected?).returns(true)
+        @agent.service.expects(:connect)
+        @agent.send(:connect, :force_reconnect => true)
+      end
+
+      def test_defer_start_if_resque_dispatcher_and_channel_manager_isnt_started
+        NewRelic::Agent::PipeChannelManager.listener.expects(:started?).returns(false)
+
+        # :send_data_on_exit setting to avoid setting an at_exit
+        with_config( :send_data_on_exit => false, :dispatcher => :resque ) do
+          @agent.start
+        end
+
+        assert !@agent.started?
+      end
+
+      def test_doesnt_defer_start_if_resque_dispatcher_and_channel_manager_started
+        NewRelic::Agent::PipeChannelManager.listener.expects(:started?).returns(true)
+
+        # :send_data_on_exit setting to avoid setting an at_exit
+        with_config( :send_data_on_exit => false, :dispatcher => :resque ) do
+          @agent.start
+        end
+
+        assert @agent.started?
+      end
+
+    end
+  end
+end