wd_newrelic_rpm 3.3.4.1

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

@@ -0,0 +1,153 @@
+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')
+    @connected = true
+    self.expects(:check_transaction_sampler_status)
+    self.expects(:check_sql_sampler_status)    
+    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')
+    @connected = false
+    fake_log = mocked_log
+    fake_log.expects(:debug).with("No connection.  Worker thread ending.")
+    deferred_work!('connection_options')
+  end
+
+  def test_check_transaction_sampler_status_enabled
+    control = mocked_control
+    control.expects(:developer_mode?).returns(false)
+    @should_send_samples = true
+    @transaction_sampler = mock('transaction_sampler')
+    @transaction_sampler.expects(:enable)
+    check_transaction_sampler_status
+  end
+
+  def test_check_transaction_sampler_status_devmode
+    control = mocked_control
+    control.expects(:developer_mode?).returns(true)
+    @should_send_samples = false
+    @transaction_sampler = mock('transaction_sampler')
+    @transaction_sampler.expects(:enable)
+    check_transaction_sampler_status
+  end
+
+  def test_check_transaction_sampler_status_disabled
+    control = mocked_control
+    control.expects(:developer_mode?).returns(false)
+    @should_send_samples = false
+    @transaction_sampler = mock('transaction_sampler')
+    @transaction_sampler.expects(:disable)
+    check_transaction_sampler_status
+  end
+
+  def test_log_worker_loop_start
+    @report_period = 30
+    log = mocked_log
+    log.expects(:info).with("Reporting performance data every 30 seconds.")
+    log.expects(:debug).with("Running worker loop")
+    log_worker_loop_start
+  end
+
+  def test_create_and_run_worker_loop
+    @report_period = 30
+    @should_send_samples = true
+    wl = mock('worker loop')
+    NewRelic::Agent::WorkerLoop.expects(:new).returns(wl)
+    wl.expects(:run).with(30).yields
+    self.expects(:save_or_transmit_data)
+    create_and_run_worker_loop
+  end
+
+  def test_handle_force_restart
+    # hooray for methods with no branches
+    error = mock('exception')
+    log = mocked_log
+    error.expects(:message).returns('a message')
+    log.expects(:info).with('a message')
+    self.expects(:reset_stats)
+    self.expects(:sleep).with(30)
+
+    @metric_ids = 'this is not an empty hash'
+    @connected = true
+
+    handle_force_restart(error)
+
+    assert_equal({}, @metric_ids)
+    assert @connected.nil?
+  end
+
+  def test_handle_force_disconnect
+    error = mock('exception')
+    error.expects(:message).returns('a message')
+    log = mocked_log
+    log.expects(:error).with("New Relic forced this agent to disconnect (a message)")
+    self.expects(:disconnect)
+    handle_force_disconnect(error)
+  end
+
+  def test_handle_server_connection_problem
+    error_class = mock('class of exception')
+    error = mock('exception')
+    log = mocked_log
+    log.expects(:error).with('Unable to establish connection with the server.  Run with log level set to debug for more information.')
+    error.expects(:class).returns(error_class)
+    error_class.expects(:name).returns('an error class')
+    error.expects(:message).returns('a message')
+    error.expects(:backtrace).returns(['first line', 'second line'])
+    log.expects(:debug).with("an error class: a message\nfirst line")
+    self.expects(:disconnect)
+    handle_server_connection_problem(error)
+  end
+
+  def test_handle_other_error
+    error_class = mock('class of exception')
+    error = mock('exception')
+    log = mocked_log
+    error.expects(:class).returns(error_class)
+    error_class.expects(:name).returns('an error class')
+    error.expects(:message).returns('a message')
+    error.expects(:backtrace).returns(['first line', 'second line'])
+    log.expects(:error).with("Terminating worker loop: an error class: a message\n  first line\n  second line")
+    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_log
+    fake_log = mock('log')
+    self.stubs(:log).returns(fake_log)
+    fake_log
+  end
+
+
+  def mocked_control
+    fake_control = mock('control')
+    self.stubs(:control).returns(fake_control)
+    fake_control
+  end
+end
+

data/test/new_relic/agent/agent_test.rb

@@ -0,0 +1,140 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+module NewRelic
+  module Agent
+    class AgentTest < Test::Unit::TestCase
+
+      def setup
+        super
+        @agent = NewRelic::Agent::Agent.new
+      end
+
+      def test_save_or_transmit_data_should_save
+        NewRelic::Agent.expects(:save_data).once
+        @agent.expects(:harvest_and_send_timeslice_data).never
+        NewRelic::DataSerialization.expects(:should_send_data?).returns(false)
+        @agent.instance_eval { save_or_transmit_data }
+      end
+      
+      def test_save_or_transmit_data_should_transmit
+        NewRelic::Control.instance.stubs(:disable_serialization?).returns(false)
+        NewRelic::Agent.expects(:load_data)
+        @agent.expects(:harvest_and_send_timeslice_data)
+        @agent.expects(:harvest_and_send_slowest_sample)
+        @agent.expects(:harvest_and_send_errors)
+        NewRelic::DataSerialization.expects(:should_send_data?).returns(true)
+        @agent.instance_eval { save_or_transmit_data }
+      end
+      
+      def test_serialize
+        assert_equal([{}, [], []], @agent.send(:serialize), "should return nil when shut down")
+      end
+
+      def test_harvest_transaction_traces
+        assert_equal([], @agent.send(:harvest_transaction_traces), 'should return transaction traces')
+      end
+
+      def test_harvest_timeslice_data
+        assert_equal({}, @agent.send(:harvest_timeslice_data),
+                     'should return timeslice data')
+      end
+
+      def test_harvest_timelice_data_should_be_thread_safe
+        2000.times do |i|
+          @agent.stats_engine.stats_hash[i.to_s] = NewRelic::StatsBase.new
+        end
+        
+        harvest = Thread.new do
+          @agent.send(:harvest_timeslice_data)
+        end
+
+        app = Thread.new do
+          @agent.stats_engine.stats_hash["a"] = NewRelic::StatsBase.new
+        end
+        
+        assert_nothing_raised do
+          [app, harvest].each{|t| t.join}
+        end
+      end
+
+      def test_harvest_errors
+        assert_equal([], @agent.send(:harvest_errors), 'should return errors')
+      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_from_all_three_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
+        }
+        unsent_errors.expects(:+).with([])
+        unsent_traces.expects(:+).with([])
+        @agent.merge_data_from([{}, [], []])
+      end
+
+      def test_should_not_log_log_file_location_if_no_log_file
+        NewRelic::Control.instance.stubs(:log_file).returns('/vasrkjn4b3b4')
+        @agent.expects(:log).never
+        @agent.notify_log_file_location
+      end
+    end
+  end
+end

data/test/new_relic/agent/agent_test_controller.rb

@@ -0,0 +1,77 @@
+# Defining a test controller class with a superclass, used to
+# verify correct attribute inheritence
+class NewRelic::Agent::SuperclassController <  ActionController::Base
+  def base_action
+    render :text => 'none'
+  end
+end
+# This is a controller class used in testing controller instrumentation
+class NewRelic::Agent::AgentTestController < NewRelic::Agent::SuperclassController
+  # filter_parameter_logging :social_security_number
+
+  @@headers_to_add = nil
+
+  def index
+    sleep params['wait'].to_i if params['wait']
+    render :text => params.inspect
+  end
+  def _filter_parameters(params)
+    filter_parameters params
+  end
+  def action_inline
+    render(:inline => "<%= 'foo' %>fah")
+  end
+
+  def action_to_render
+    render :text => params.inspect
+  end
+  def action_to_ignore
+    render :text => 'unmeasured'
+  end
+  def action_to_ignore_apdex
+    render :text => 'unmeasured'
+  end
+  before_filter :oops, :only => :action_with_before_filter_error
+  def action_with_before_filter_error
+    render :text => 'nothing'
+  end
+  def oops
+    raise "error in before filter"
+  end
+  class TestException < RuntimeError
+  end
+
+  def rescue_action_locally(exception)
+    if exception.is_a? TestException
+      raise "error in the handler"
+    end
+  end
+  def action_with_error
+    raise "error in action"
+  end
+  def entry_action
+    perform_action_with_newrelic_trace('internal_action') do
+      internal_action
+    end
+  end
+
+  def self.set_some_headers(hash_of_headers)
+    @@headers_to_add ||= {}
+    @@headers_to_add.merge!(hash_of_headers)
+  end
+
+  def self.clear_headers
+    @@headers_to_add = nil
+  end
+
+  def newrelic_request_headers
+    @@headers_to_add ||= {}
+  end
+
+  private
+  def internal_action
+    perform_action_with_newrelic_trace(:name => 'internal_traced_action', :force => true) do
+      render :text => 'internal action'
+    end
+  end
+end

data/test/new_relic/agent/agent_test_controller_test.rb

@@ -0,0 +1,382 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+require 'action_controller/test_case'
+class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
+  require 'action_controller/base'
+  require 'new_relic/agent/agent_test_controller'
+
+  self.controller_class = NewRelic::Agent::AgentTestController
+
+  attr_accessor :agent, :engine
+  
+  def test_initialization
+  # Suggested by cee-dub for merb tests.  I'm actually amazed if our tests work with merb.
+    if defined?(Merb::Router)
+      Merb::Router.prepare do |r|
+        match('/:controller(/:action)(.:format)').register
+      end
+    elsif NewRelic::Control.instance.rails_version < NewRelic::VersionNumber.new("3.0")
+      ActionController::Routing::Routes.draw do |map|
+        map.connect '/:controller/:action.:format'
+        map.connect '/:controller/:action'
+      end
+    else
+      Rails.application.routes.draw do
+        match '/:controller/:action.:format'
+        match '/:controller/:action'
+      end    
+    end
+
+    if defined?(Rails) && Rails.respond_to?(:application) && Rails.application.respond_to?(:routes)
+      @routes = Rails.application.routes
+    end
+
+    Thread.current[:newrelic_ignore_controller] = nil
+    NewRelic::Agent.manual_start
+    @agent = NewRelic::Agent.instance
+    #    @agent.instrument_app
+    agent.transaction_sampler.harvest
+    NewRelic::Agent::AgentTestController.class_eval do
+      newrelic_ignore :only => [:action_to_ignore, :entry_action, :base_action]
+      newrelic_ignore_apdex :only => :action_to_ignore_apdex
+    end
+    @engine = @agent.stats_engine
+  end
+  
+  # Normally you can do this with #setup but for some reason in rails 2.0.2
+  # setup is not called.
+  if NewRelic::Control.instance.rails_version <= '2.1.0'
+    def initialize name
+      super name
+      test_initialization
+    end
+  else
+    alias_method :setup, :test_initialization
+  end
+
+  def teardown
+    Thread.current[:newrelic_ignore_controller] = nil
+    NewRelic::Agent.shutdown
+    NewRelic::Agent::AgentTestController.clear_headers
+    super
+  end
+
+  def test_mongrel_queue
+    NewRelic::Agent::AgentTestController.clear_headers
+    engine.clear_stats
+    NewRelic::Control.instance.local_env.stubs(:mongrel).returns( stub('mongrel', :workers => stub('workers', :list => stub('list', :length => '10'))))
+
+    get :index
+    assert_equal 1, stats('HttpDispatcher').call_count
+    assert_equal 1, engine.get_stats_no_scope('Mongrel/Queue Length').call_count
+    assert_equal 9, engine.get_stats_no_scope('Mongrel/Queue Length').total_call_time
+    assert_equal 0, engine.get_stats_no_scope('WebFrontend/Mongrel/Average Queue Time').call_count
+  end
+
+  def test_heroku_queue
+    engine.clear_stats
+    NewRelic::Agent::AgentTestController.set_some_headers 'HTTP_X_HEROKU_QUEUE_DEPTH'=>'15'
+    get :index
+    assert_equal 1, stats('HttpDispatcher').call_count
+    assert_equal 1, engine.get_stats_no_scope('Mongrel/Queue Length').call_count
+    assert_equal 15, engine.get_stats_no_scope('Mongrel/Queue Length').total_call_time
+    assert_equal 0, engine.get_stats_no_scope('WebFrontend/Mongrel/Average Queue Time').call_count
+  end
+
+  def test_new_queue_integration
+    # make this test deterministic
+    Time.stubs(:now => Time.at(2))
+
+    NewRelic::Agent::AgentTestController.clear_headers
+    engine.clear_stats
+    start = ((Time.now - 1).to_f * 1_000_000).to_i
+    NewRelic::Agent::AgentTestController.set_some_headers 'HTTP_X_QUEUE_START'=> "t=#{start}"
+    get :index
+
+    check_metric_time('WebFrontend/QueueTime', 1, 0.1)
+  end
+
+
+  def test_new_middleware_integration
+    # make this test deterministic
+    Time.stubs(:now => Time.at(2))
+
+    engine.clear_stats
+    start = ((Time.now - 1).to_f * 1_000_000).to_i
+    NewRelic::Agent::AgentTestController.set_some_headers 'HTTP_X_MIDDLEWARE_START'=> "t=#{start}"
+    get :index
+
+    check_metric_time('Middleware/all', 1, 0.1)
+  end
+
+  def test_new_server_time_integration
+    # make this test deterministic
+    Time.stubs(:now => Time.at(2))
+
+    NewRelic::Agent::AgentTestController.clear_headers
+    engine.clear_stats
+    start = ((Time.now - 1).to_f * 1_000_000).to_i
+    NewRelic::Agent::AgentTestController.set_some_headers 'HTTP_X_REQUEST_START'=> "t=#{start}"
+    get :index
+
+    check_metric_time('WebFrontend/WebServer/all', 1, 0.1)
+  end
+
+  def test_new_frontend_work_integration
+    # make this test deterministic
+    Time.stubs(:now => Time.at(10))
+
+    engine.clear_stats
+    times = [Time.now - 3, Time.now - 2, Time.now - 1]
+    times.map! {|t| (t.to_f * 1_000_000).to_i }
+    NewRelic::Agent::AgentTestController.set_some_headers({
+                                                            'HTTP_X_REQUEST_START'=> "t=#{times[0]}", 'HTTP_X_QUEUE_START' => "t=#{times[1]}", 'HTTP_X_MIDDLEWARE_START' => "t=#{times[2]}"})
+    get :index
+
+
+    check_metric_time('WebFrontend/WebServer/all', 1, 0.1)
+    check_metric_time('Middleware/all', 1, 0.1)
+    check_metric_time('WebFrontend/QueueTime', 1, 0.1)
+  end
+
+  def test_render_inline
+    engine.clear_stats
+    get :action_inline
+    assert_equal 'foofah', @response.body
+    compare_metrics %w[Controller/new_relic/agent/agent_test/action_inline], engine.metrics.grep(/^Controller/)
+  end
+  def test_metric__ignore
+    engine.clear_stats
+    compare_metrics [], engine.metrics
+    get :action_to_ignore
+    compare_metrics [], engine.metrics
+  end
+
+  def test_controller_rescued_error
+    engine.clear_stats
+    assert_raise RuntimeError do
+      get :action_with_error
+    end
+    metrics =  ['Apdex',
+                'Apdex/new_relic/agent/agent_test/action_with_error',
+                'HttpDispatcher',
+                'Controller/new_relic/agent/agent_test/action_with_error',
+                'Errors/all',
+                'Middleware/all',
+                'WebFrontend/WebServer/all',
+                'WebFrontend/QueueTime']
+
+    compare_metrics metrics, engine.metrics.reject{|m| m.index('Response')==0 || m.index('CPU')==0}
+    assert_equal 1, engine.get_stats_no_scope("Controller/new_relic/agent/agent_test/action_with_error").call_count
+    assert_equal 1, engine.get_stats_no_scope("Errors/all").call_count
+    apdex = engine.get_stats_no_scope("Apdex")
+    score = apdex.get_apdex
+    assert_equal 1, score[2], 'failing'
+    assert_equal 0, score[1], 'tol'
+    assert_equal 0, score[0], 'satisfied'
+
+  end
+  def test_controller_error
+    engine.clear_stats
+    assert_raise RuntimeError do
+      get :action_with_error
+    end
+    metrics =  ['Apdex',
+                'Apdex/new_relic/agent/agent_test/action_with_error',
+                'HttpDispatcher',
+                'Controller/new_relic/agent/agent_test/action_with_error',
+                'Errors/all',
+                'WebFrontend/QueueTime',
+                'Middleware/all',
+                'WebFrontend/WebServer/all']
+
+    compare_metrics metrics, engine.metrics.reject{|m| m.index('Response')==0 || m.index('CPU')==0}
+    assert_equal 1, engine.get_stats_no_scope("Controller/new_relic/agent/agent_test/action_with_error").call_count
+    assert_equal 1, engine.get_stats_no_scope("Errors/all").call_count
+    apdex = engine.get_stats_no_scope("Apdex")
+    score = apdex.get_apdex
+    assert_equal 1, score[2], 'failing'
+    assert_equal 0, score[1], 'tol'
+    assert_equal 0, score[0], 'satisfied'
+
+  end
+  def test_filter_error
+    engine.clear_stats
+    assert_raise RuntimeError do
+      get :action_with_before_filter_error
+    end
+    metrics =  ['Apdex',
+                'Apdex/new_relic/agent/agent_test/action_with_before_filter_error',
+                'HttpDispatcher',
+                'Controller/new_relic/agent/agent_test/action_with_before_filter_error',
+                'Errors/all',
+                'WebFrontend/QueueTime',
+                'Middleware/all',
+                'WebFrontend/WebServer/all']
+
+    compare_metrics metrics, engine.metrics.reject{|m| m.index('Response')==0 || m.index('CPU')==0 || m.index('GC')==0}
+    assert_equal 1, engine.get_stats_no_scope("Controller/new_relic/agent/agent_test/action_with_before_filter_error").call_count
+    assert_equal 1, engine.get_stats_no_scope("Errors/all").call_count
+    apdex = engine.get_stats_no_scope("Apdex")
+    score = apdex.get_apdex
+    assert_equal 1, score[2], 'failing'
+    assert_equal 0, score[1], 'tol'
+    assert_equal 0, score[0], 'satisfied'
+  end
+  def test_metric__ignore_base
+    engine.clear_stats
+    get :base_action
+    compare_metrics [], engine.metrics
+  end
+  def test_metric__no_ignore
+    path = 'new_relic/agent/agent_test/index'
+    index_stats = stats("Controller/#{path}")
+    index_apdex_stats = engine.get_custom_stats("Apdex/#{path}", NewRelic::ApdexStats)
+    assert_difference 'index_stats.call_count' do
+      assert_difference 'index_apdex_stats.call_count' do
+        get :index
+      end
+    end
+    assert_nil Thread.current[:newrelic_ignore_controller]
+  end
+  def test_metric__ignore_apdex
+    engine = @agent.stats_engine
+    path = 'new_relic/agent/agent_test/action_to_ignore_apdex'
+    cpu_stats = stats("ControllerCPU/#{path}")
+    index_stats = stats("Controller/#{path}")
+    index_apdex_stats = engine.get_custom_stats("Apdex/#{path}", NewRelic::ApdexStats)
+    assert_difference 'index_stats.call_count' do
+      assert_no_difference 'index_apdex_stats.call_count' do
+        get :action_to_ignore_apdex
+      end
+    end
+    assert_nil Thread.current[:newrelic_ignore_controller]
+
+  end
+  def test_metric__dispatched
+    engine = @agent.stats_engine
+    get :entry_action
+    assert_nil Thread.current[:newrelic_ignore_controller]
+    assert_nil engine.lookup_stats('Controller/agent_test/entry_action')
+    assert_nil engine.lookup_stats('Controller/agent_test_controller/entry_action')
+    assert_nil engine.lookup_stats('Controller/AgentTestController/entry_action')
+    assert_nil engine.lookup_stats('Controller/NewRelic::Agent::AgentTestController/internal_action')
+    assert_nil engine.lookup_stats('Controller/NewRelic::Agent::AgentTestController_controller/internal_action')
+    assert_not_nil engine.lookup_stats('Controller/NewRelic::Agent::AgentTestController/internal_traced_action')
+  end
+  def test_action_instrumentation
+    get :index, :foo => 'bar'
+    assert_match /bar/, @response.body
+  end
+
+  def test_controller_params
+    assert agent.transaction_sampler
+    num_samples = NewRelic::Agent.instance.transaction_sampler.samples.length
+    assert_equal "[FILTERED]", @controller._filter_parameters({'social_security_number' => 'test'})['social_security_number']
+    get :index, 'social_security_number' => "001-555-1212"
+    samples = agent.transaction_sampler.samples
+    assert_equal num_samples + 1, samples.length
+    assert_equal "[FILTERED]", samples.last.params[:request_params]["social_security_number"]
+  end
+
+  def test_controller_params
+    agent.transaction_sampler.reset!
+    get :index, 'number' => "001-555-1212"
+    s = agent.transaction_sampler.harvest(nil, 0.0)
+    assert_equal 1, s.size
+    assert_equal 6, s.first.params.size
+  end
+
+
+  def test_busycalculation
+    engine.clear_stats
+    assert_equal 0, NewRelic::Agent::BusyCalculator.busy_count
+    get :index, 'social_security_number' => "001-555-1212", 'wait' => '0.05'
+    NewRelic::Agent::BusyCalculator.harvest_busy
+
+    assert_equal 1, stats('Instance/Busy').call_count
+    assert_equal 1, stats('HttpDispatcher').call_count
+    # We are probably busy about 99% of the time, but lets make sure it's at least 50
+    assert stats('Instance/Busy').total_call_time > (0.5 * 0.05), stats('Instance/Busy').inspect
+    assert_equal 0, stats('WebFrontend/Mongrel/Average Queue Time').call_count
+  end
+
+  def test_queue_headers_no_header
+    engine.clear_stats
+    queue_length_stat = stats('Mongrel/Queue Length')
+    queue_time_stat = stats('WebFrontend/QueueTime')
+
+    # no request start header
+    get 'index'
+    assert_equal 0, queue_length_stat.call_count
+  end
+
+  def test_queue_headers_apache
+    # make this test deterministic
+    Time.stubs(:now => Time.at(10))
+
+    NewRelic::Agent::AgentTestController.clear_headers
+    engine.clear_stats
+    queue_length_stat = stats('Mongrel/Queue Length')
+    queue_time_stat = stats('WebFrontend/QueueTime')
+
+    # apache version of header
+    request_start = ((Time.now.to_f - 0.5) * 1e6).to_i.to_s
+    NewRelic::Agent::AgentTestController.set_some_headers({'HTTP_X_QUEUE_START' => "t=#{request_start}"})
+    get :index
+    assert_equal(0, queue_length_stat.call_count, 'We should not be seeing a queue length yet')
+    assert_equal(1, queue_time_stat.call_count, 'We should have seen the queue header once')
+    assert(queue_time_stat.total_call_time > 0.1, "Queue time should be longer than 100ms")
+    assert(queue_time_stat.total_call_time < 10, "Queue time should be under 10 seconds (sanity check)")
+
+  end
+  def test_queue_headers_heroku
+    # make this test deterministic
+    Time.stubs(:now => Time.at(10))
+
+    engine.clear_stats
+    NewRelic::Agent::AgentTestController.clear_headers
+
+    queue_length_stat = stats('Mongrel/Queue Length')
+    queue_time_stat = stats('WebFrontend/QueueTime')
+
+    # heroku version
+    request_start = ((Time.now.to_f - 0.5) * 1e6).to_i.to_s
+    NewRelic::Agent::AgentTestController.set_some_headers({'HTTP_X_QUEUE_START' => "t=#{request_start}", 'HTTP_X_HEROKU_QUEUE_DEPTH' => '0'})
+    get :index
+    assert_equal(0, queue_length_stat.total_call_time, 'queue should be empty')
+    assert_equal(1, queue_time_stat.call_count, 'should have seen the queue header once')
+    assert(queue_time_stat.total_call_time > 0.1, "Queue time should be longer than 100ms")
+    assert(queue_time_stat.total_call_time < 10, "Queue time should be under 10 seconds (sanity check)")
+  end
+
+  def test_queue_headers_heroku_queue_length
+    # make this test deterministic
+    Time.stubs(:now => Time.at(10))
+
+    engine.clear_stats
+    NewRelic::Agent::AgentTestController.clear_headers
+
+    queue_length_stat = stats('Mongrel/Queue Length')
+    queue_time_stat = stats('WebFrontend/QueueTime')
+
+    # heroku version with queue length > 0
+    request_start = ((Time.now.to_f - 0.5) * 1e6).to_i.to_s
+    NewRelic::Agent::AgentTestController.set_some_headers({'HTTP_X_QUEUE_START' => "t=#{request_start}", 'HTTP_X_HEROKU_QUEUE_DEPTH' => '3'})
+    get :index
+
+    assert_equal(1, queue_length_stat.call_count, 'queue should have been seen once')
+    assert_equal(1, queue_time_stat.call_count, 'should have seen the queue header once')
+    assert(queue_time_stat.total_call_time > 0.1, "Queue time should be longer than 100ms")
+    assert(queue_time_stat.total_call_time < 10, "Queue time should be under 10 seconds (sanity check)")
+    assert_equal(3, queue_length_stat.total_call_time, 'queue should be 3 long')
+
+    NewRelic::Agent::AgentTestController.clear_headers
+  end
+
+  private
+  def stats(name)
+    engine.get_stats_no_scope(name)
+  end
+
+end if defined? Rails
+