wd_newrelic_rpm 3.3.4.1

data/test/new_relic/agent/instrumentation/controller_instrumentation_test.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper'))
+class NewRelic::Agent::Instrumentation::ControllerInstrumentationTest < Test::Unit::TestCase
+  require 'new_relic/agent/instrumentation/controller_instrumentation'
+  class TestObject
+    include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+  end
+
+  def test_detect_upstream_wait_basic
+    start_time = Time.now
+    object = TestObject.new
+    # should return the start time above by default
+    object.expects(:newrelic_request_headers).returns({:request => 'headers'}).twice
+    object.expects(:parse_frontend_headers).with({:request => 'headers'}).returns(start_time)
+    assert_equal(start_time, object.send(:_detect_upstream_wait, start_time))
+  end
+
+  def test_detect_upstream_wait_with_upstream
+    start_time = Time.now
+    runs_at = start_time + 1
+    object = TestObject.new
+    object.expects(:newrelic_request_headers).returns(true).twice
+    object.expects(:parse_frontend_headers).returns(start_time)
+    assert_equal(start_time, object.send(:_detect_upstream_wait, runs_at))
+  end
+
+  def test_detect_upstream_wait_swallows_errors
+    start_time = Time.now
+    object = TestObject.new
+    # should return the start time above when an error is raised
+    object.expects(:newrelic_request_headers).returns({:request => 'headers'}).twice
+    object.expects(:parse_frontend_headers).with({:request => 'headers'}).raises("an error")
+    assert_equal(start_time, object.send(:_detect_upstream_wait, start_time))
+  end
+end

data/test/new_relic/agent/instrumentation/instrumentation_test.rb

@@ -0,0 +1,11 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper'))
+class NewRelic::Agent::Instrumentation::InstrumentationTest < Test::Unit::TestCase
+  def test_load_all_instrumentation_files
+    # just checking for syntax errors and unguarded code
+    Dir.glob('new_relic/agent/instrumentation/**/*.rb') do |f|
+      require f
+    end
+    require 'new_relic/delayed_job_injection'
+  end
+end
+

data/test/new_relic/agent/instrumentation/metric_frame/pop_test.rb

@@ -0,0 +1,171 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'test_helper'))
+require 'new_relic/agent/instrumentation/metric_frame/pop'
+class NewRelic::Agent::Instrumentation::MetricFrame::PopTest < Test::Unit::TestCase
+  include NewRelic::Agent::Instrumentation::MetricFrame::Pop
+
+  attr_reader :agent
+  attr_reader :transaction_sampler
+  attr_reader :sql_sampler
+
+  def setup
+    @agent = mock('agent')
+    @transaction_sampler = mock('transaction sampler')
+    @sql_sampler = mock('sql sampler')
+  end
+
+  def teardown
+    Thread.current[:newrelic_metric_frame] = nil
+  end
+
+  def test_clear_thread_metric_frame
+    Thread.current[:newrelic_metric_frame] = 'whee'
+    clear_thread_metric_frame!
+    assert_equal nil, Thread.current[:newrelic_metric_frame], 'should nil out the thread var'
+  end
+
+  def test_set_new_scope
+    fakeagent = mock('agent')
+    self.expects(:agent).returns(fakeagent)
+    fakeengine = mock('stats_engine')
+    fakeagent.expects(:stats_engine).returns(fakeengine)
+    fakeengine.expects(:scope_name=).with('A METRIC')
+
+    set_new_scope!('A METRIC')
+  end
+
+  def test_log_underflow
+    NewRelic::Agent.logger.expects(:error).with(regexp_matches(/Underflow in metric frames: /))
+    log_underflow
+  end
+
+  def test_notice_scope_empty
+    transaction_sampler.expects(:notice_scope_empty)
+    sql_sampler.expects(:notice_scope_empty)
+    notice_scope_empty
+  end
+
+  def test_record_transaction_cpu_positive
+    self.expects(:cpu_burn).once.returns(1.0)
+    transaction_sampler.expects(:notice_transaction_cpu_time).with(1.0)
+    record_transaction_cpu
+  end
+
+  def test_record_transaction_cpu_negative
+    self.expects(:cpu_burn).once.returns(nil)
+    # should not be called for the nil case
+    transaction_sampler.expects(:notice_transaction_cpu_time).never
+    record_transaction_cpu
+  end
+
+  def test_normal_cpu_burn_positive
+    @process_cpu_start = 3
+    self.expects(:process_cpu).returns(4)
+    assert_equal 1, normal_cpu_burn
+  end
+
+  def test_normal_cpu_burn_negative
+    @process_cpu_start = nil
+    self.expects(:process_cpu).never
+    assert_equal nil, normal_cpu_burn
+  end
+
+  def test_jruby_cpu_burn_positive
+    @jruby_cpu_start = 3
+    self.expects(:jruby_cpu_time).returns(4)
+    self.expects(:record_jruby_cpu_burn).with(1)
+    assert_equal 1, jruby_cpu_burn
+  end
+
+  def test_jruby_cpu_burn_negative
+    @jruby_cpu_start = nil
+    self.expects(:jruby_cpu_time).never
+    self.expects(:record_jruby_cpu_burn).never
+    assert_equal nil, jruby_cpu_burn
+  end
+
+  def test_record_jruby_cpu_burn
+    NewRelic::Agent.get_stats_no_scope(NewRelic::Metrics::USER_TIME).expects(:record_data_point).with(1.0)
+    record_jruby_cpu_burn(1.0)
+  end
+
+  def test_cpu_burn_normal
+    self.expects(:normal_cpu_burn).returns(1)
+    self.expects(:jruby_cpu_burn).never
+    assert_equal 1, cpu_burn
+  end
+
+  def test_cpu_burn_jruby
+    self.expects(:normal_cpu_burn).returns(nil)
+    self.expects(:jruby_cpu_burn).returns(2)
+    assert_equal 2, cpu_burn
+  end
+
+  def test_end_transaction
+    fake_stats_engine = mock('stats engine')
+    agent.expects(:stats_engine).returns(fake_stats_engine)
+    fake_stats_engine.expects(:end_transaction)
+    end_transaction!
+  end
+
+  def test_notify_transaction_sampler_true
+    self.expects(:record_transaction_cpu)
+    self.expects(:notice_scope_empty)
+    notify_transaction_sampler(true)
+  end
+
+  def test_notify_transaction_sampler_false
+    self.expects(:record_transaction_cpu)
+    self.expects(:notice_scope_empty)
+    notify_transaction_sampler(false)
+  end
+
+  def test_traced
+    NewRelic::Agent.expects(:is_execution_traced?)
+    traced?
+  end
+
+  def test_handle_empty_path_stack_default
+    @path_stack = [] # it is empty
+    self.expects(:traced?).returns(true)
+    fakemetric = mock('metric')
+    fakemetric.expects(:is_web_transaction?).returns(true)
+    self.expects(:notify_transaction_sampler).with(true)
+    self.expects(:end_transaction!)
+    self.expects(:clear_thread_metric_frame!)
+    handle_empty_path_stack(fakemetric)
+  end
+
+  def test_handle_empty_path_stack_non_web
+    @path_stack = [] # it is empty
+    self.expects(:traced?).returns(true)
+    fakemetric = mock('metric')
+    fakemetric.expects(:is_web_transaction?).returns(false)
+    self.expects(:notify_transaction_sampler).with(false)
+    self.expects(:end_transaction!)
+    self.expects(:clear_thread_metric_frame!)
+    handle_empty_path_stack(fakemetric)
+  end
+
+  def test_handle_empty_path_stack_error
+    @path_stack = ['not empty']
+    assert_raise(RuntimeError) do
+      handle_empty_path_stack(mock('metric'))
+    end
+  end
+
+  def test_handle_empty_path_stack_untraced
+    @path_stack = [] # it is empty
+    self.expects(:traced?).returns(false)
+    fakemetric = mock('metric')
+    fakemetric.expects(:is_web_transaction?).never
+    self.expects(:end_transaction!)
+    self.expects(:clear_thread_metric_frame!)
+    handle_empty_path_stack(fakemetric)
+  end
+
+  def test_current_stack_metric
+    self.expects(:metric_name)
+    current_stack_metric
+  end
+end
+

data/test/new_relic/agent/instrumentation/metric_frame_test.rb

@@ -0,0 +1,50 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+
+class NewRelic::Agent::Instrumentation::MetricFrameTest < Test::Unit::TestCase
+
+  attr_reader :f
+  def setup
+    @f = NewRelic::Agent::Instrumentation::MetricFrame.new
+  end
+
+  def test_request_parsing__none
+    assert_nil f.uri
+    assert_nil f.referer
+  end
+  def test_request_parsing__path
+    request = stub(:path => '/path?hello=bob#none')
+    f.request = request
+    assert_equal "/path", f.uri
+  end
+  def test_request_parsing__fullpath
+    request = stub(:fullpath => '/path?hello=bob#none')
+    f.request = request
+    assert_equal "/path", f.uri
+  end
+  def test_request_parsing__referer
+    request = stub(:referer => 'https://www.yahoo.com:8080/path/hello?bob=none&foo=bar')
+    f.request = request
+    assert_nil f.uri
+    assert_equal "https://www.yahoo.com:8080/path/hello", f.referer
+  end
+
+  def test_request_parsing__uri
+    request = stub(:uri => 'http://creature.com/path?hello=bob#none', :referer => '/path/hello?bob=none&foo=bar')
+    f.request = request
+    assert_equal "/path", f.uri
+    assert_equal "/path/hello", f.referer
+  end
+
+  def test_request_parsing__hostname_only
+    request = stub(:uri => 'http://creature.com')
+    f.request = request
+    assert_equal "/", f.uri
+    assert_nil f.referer
+  end
+  def test_request_parsing__slash
+    request = stub(:uri => 'http://creature.com/')
+    f.request = request
+    assert_equal "/", f.uri
+    assert_nil f.referer
+  end
+end

data/test/new_relic/agent/instrumentation/net_instrumentation_test.rb

@@ -0,0 +1,84 @@
+unless ENV['FAST_TESTS']
+  require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+
+  class NewRelic::Agent::Instrumentation::NetInstrumentationTest < Test::Unit::TestCase
+    include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+    def setup
+      NewRelic::Agent.manual_start
+      @engine = NewRelic::Agent.instance.stats_engine
+      @engine.clear_stats
+    end
+
+    def metrics_without_gc
+      @engine.metrics - ['GC/cumulative']
+    end
+
+    private :metrics_without_gc
+
+    def test_get
+      url = URI.parse('http://www.google.com/index.html')
+      res = Net::HTTP.start(url.host, url.port) {|http|
+        http.get('/index.html')
+      }
+      assert_match /<head>/i, res.body
+      assert_equal %w[External/all External/www.google.com/Net::HTTP/GET External/allOther External/www.google.com/all].sort,
+      metrics_without_gc.sort
+    end
+
+    def test_background
+      perform_action_with_newrelic_trace("task", :category => :task) do
+        url = URI.parse('http://www.google.com/index.html')
+        res = Net::HTTP.start(url.host, url.port) {|http|
+          http.get('/index.html')
+        }
+        assert_match /<head>/i, res.body
+      end
+      assert_equal %w[External/all External/www.google.com/Net::HTTP/GET External/allOther External/www.google.com/all
+       External/www.google.com/Net::HTTP/GET:OtherTransaction/Background/NewRelic::Agent::Instrumentation::NetInstrumentationTest/task].sort, metrics_without_gc.select{|m| m =~ /^External/}.sort
+    end
+
+    def test_transactional
+      perform_action_with_newrelic_trace("task") do
+        url = URI.parse('http://www.google.com/index.html')
+        res = Net::HTTP.start(url.host, url.port) {|http|
+          http.get('/index.html')
+        }
+        assert_match /<head>/i, res.body
+      end
+      assert_equal %w[External/all External/www.google.com/Net::HTTP/GET External/allWeb External/www.google.com/all
+       External/www.google.com/Net::HTTP/GET:Controller/NewRelic::Agent::Instrumentation::NetInstrumentationTest/task].sort, metrics_without_gc.select{|m| m =~ /^External/}.sort
+    end
+    def test_get__simple
+      Net::HTTP.get URI.parse('http://www.google.com/index.html')
+      assert_equal metrics_without_gc.sort,
+      %w[External/all External/www.google.com/Net::HTTP/GET External/allOther External/www.google.com/all].sort
+    end
+    def test_ignore
+      NewRelic::Agent.disable_all_tracing do
+        url = URI.parse('http://www.google.com/index.html')
+        res = Net::HTTP.start(url.host, url.port) {|http|
+          http.post('/index.html','data')
+        }
+      end
+      assert_equal 0, metrics_without_gc.size
+    end
+    def test_head
+      url = URI.parse('http://www.google.com/index.html')
+      res = Net::HTTP.start(url.host, url.port) {|http|
+        http.head('/index.html')
+      }
+      assert_equal %w[External/all External/www.google.com/Net::HTTP/HEAD External/allOther External/www.google.com/all].sort,
+      metrics_without_gc.sort
+    end
+
+    def test_post
+      url = URI.parse('http://www.google.com/index.html')
+      res = Net::HTTP.start(url.host, url.port) {|http|
+        http.post('/index.html','data')
+      }
+      assert_equal %w[External/all External/www.google.com/Net::HTTP/POST External/allOther External/www.google.com/all].sort,
+      metrics_without_gc.sort
+    end
+
+  end
+end

data/test/new_relic/agent/instrumentation/queue_time_test.rb

@@ -0,0 +1,382 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper'))
+class NewRelic::Agent::Instrumentation::QueueTimeTest < Test::Unit::TestCase
+  require 'new_relic/agent/instrumentation/queue_time'
+  include NewRelic::Agent::Instrumentation::QueueTime
+
+  def setup
+    NewRelic::Agent.instance.stats_engine.clear_stats
+  end
+
+  def create_test_start_time(env)
+    env[APP_HEADER] = "t=#{convert_to_microseconds(Time.at(1002))}"
+  end
+
+  def test_parse_frontend_headers
+    middleware_start = Time.at(1002)
+    queue_start = Time.at(1001)
+    server_start = Time.at(1000)
+    Time.stubs(:now).returns(Time.at(1003)) # whee!
+    self.expects(:add_end_time_header).with(Time.at(1003), {:env => 'hash'})
+    # ordering is important here, unfortunately, the mocks don't
+    # support that kind of checking.
+    self.expects(:parse_middleware_time_from).with({:env => 'hash'}).returns(middleware_start)
+    self.expects(:parse_queue_time_from).with({:env => 'hash'}).returns(queue_start)
+    self.expects(:parse_server_time_from).with({:env => 'hash'}).returns(server_start)
+    assert_equal(server_start, parse_frontend_headers({:env => 'hash'}), "should return the oldest start time")
+  end
+
+  def test_parse_frontend_headers_should_return_earliest_start
+    middleware_start = Time.at(1002)
+    queue_start = Time.at(1000)
+    server_start = Time.at(1001)
+    Time.stubs(:now).returns(Time.at(1003)) # whee!
+    self.expects(:add_end_time_header).with(Time.at(1003), {:env => 'hash'})
+    # ordering is important here, unfortunately, the mocks don't
+    # support that kind of checking.
+    self.expects(:parse_middleware_time_from).with({:env => 'hash'}).returns(middleware_start)
+    self.expects(:parse_queue_time_from).with({:env => 'hash'}).returns(queue_start)
+    self.expects(:parse_server_time_from).with({:env => 'hash'}).returns(server_start)
+    assert_equal(queue_start, parse_frontend_headers({:env => 'hash'}), "should return the oldest start time")
+  end
+
+  def test_all_combined_frontend_headers
+    env = {}
+    env[MAIN_HEADER] = "t=#{convert_to_microseconds(Time.at(1000))}"
+    env[QUEUE_HEADER] = "t=#{convert_to_microseconds(Time.at(1001))}"
+    env[MIDDLEWARE_HEADER] = "t=#{convert_to_microseconds(Time.at(1002))}"
+
+    env[APP_HEADER] = "t=#{convert_to_microseconds(Time.at(1003))}"
+
+    assert_calls_metrics('WebFrontend/WebServer/all', 'WebFrontend/QueueTime', 'Middleware/all') do
+      assert_equal(Time.at(1002), parse_middleware_time_from(env))
+      assert_equal(Time.at(1001), parse_queue_time_from(env))
+      assert_equal(Time.at(1000), parse_server_time_from(env))
+    end
+
+    check_metric_time('WebFrontend/WebServer/all', 1.0, 0.001)
+    check_metric_time('WebFrontend/QueueTime', 1.0, 0.001)
+    check_metric_time('Middleware/all', 1.0, 0.001)
+  end
+
+  def test_combined_middleware_and_queue
+    env = {}
+    env[QUEUE_HEADER] = "t=#{convert_to_microseconds(Time.at(1000))}"
+    env[MIDDLEWARE_HEADER] = "t=#{convert_to_microseconds(Time.at(1001))}"
+    create_test_start_time(env)
+
+    assert_calls_metrics('Middleware/all', 'WebFrontend/QueueTime') do
+      parse_middleware_time_from(env)
+      assert_equal(Time.at(1000), parse_queue_time_from(env))
+    end
+
+    check_metric_time('Middleware/all', 1.0, 0.001)
+    check_metric_time('WebFrontend/QueueTime', 1.0, 0.001)
+  end
+
+  def test_combined_queue_and_server
+    env = {}
+    env[MAIN_HEADER] = "t=#{convert_to_microseconds(Time.at(1000))}"
+    env[QUEUE_HEADER] = "t=#{convert_to_microseconds(Time.at(1001))}"
+    create_test_start_time(env)
+
+    assert_calls_metrics('WebFrontend/WebServer/all', 'WebFrontend/QueueTime') do
+      assert_equal(Time.at(1001), parse_queue_time_from(env))
+      parse_server_time_from(env)
+    end
+
+    check_metric_time('WebFrontend/WebServer/all', 1.0, 0.001)
+    check_metric_time('WebFrontend/QueueTime', 1.0, 0.001)
+  end
+
+  def test_combined_middleware_and_server
+    env = {}
+    env[MAIN_HEADER] = "t=#{convert_to_microseconds(Time.at(1000))}"
+    env[MIDDLEWARE_HEADER] = "t=#{convert_to_microseconds(Time.at(1001))}"
+    create_test_start_time(env)
+
+    assert_calls_metrics('WebFrontend/WebServer/all', 'Middleware/all') do
+      parse_middleware_time_from(env)
+      parse_server_time_from(env)
+    end
+
+    check_metric_time('WebFrontend/WebServer/all', 1.0, 0.001)
+    check_metric_time('Middleware/all', 1.0, 0.001)
+  end
+
+  # initial base case, a router and a static content server
+  def test_parse_server_time_from_initial
+    env = {}
+    create_test_start_time(env)
+    time1 = convert_to_microseconds(Time.at(1000))
+    time2 = convert_to_microseconds(Time.at(1001))
+    env['HTTP_X_REQUEST_START'] = "servera t=#{time1}, serverb t=#{time2}"
+    assert_calls_metrics('WebFrontend/WebServer/all', 'WebFrontend/WebServer/servera', 'WebFrontend/WebServer/serverb') do
+      parse_server_time_from(env)
+    end
+    check_metric_time('WebFrontend/WebServer/all', 2.0, 0.1)
+    check_metric_time('WebFrontend/WebServer/servera', 1.0, 0.1)
+    check_metric_time('WebFrontend/WebServer/serverb', 1.0, 0.1)
+  end
+
+  # test for backwards compatibility with old header
+  def test_parse_server_time_from_with_no_server_name
+    env = {'HTTP_X_REQUEST_START' => "t=#{convert_to_microseconds(Time.at(1001))}"}
+    create_test_start_time(env)
+    assert_calls_metrics('WebFrontend/WebServer/all') do
+      parse_server_time_from(env)
+    end
+    check_metric_time('WebFrontend/WebServer/all', 1.0, 0.1)
+  end
+
+  def test_parse_server_time_from_with_bad_header
+    env = {'HTTP_X_REQUEST_START' => 't=t=t=t='}
+    create_test_start_time(env)
+    assert_calls_metrics('WebFrontend/WebServer/all') do
+      parse_server_time_from(env)
+    end
+  end
+
+  def test_parse_server_time_from_with_no_header
+    assert_calls_metrics('WebFrontend/WebServer/all') do
+      parse_server_time_from({})
+    end
+  end
+
+  def test_parse_middleware_time
+    env = {}
+    create_test_start_time(env)
+    time1 = convert_to_microseconds(Time.at(1000))
+    time2 = convert_to_microseconds(Time.at(1001))
+
+    env['HTTP_X_MIDDLEWARE_START'] = "base t=#{time1}, second t=#{time2}"
+    assert_calls_metrics('Middleware/all', 'Middleware/base', 'Middleware/second') do
+      parse_middleware_time_from(env)
+    end
+    check_metric_time('Middleware/all', 2.0, 0.1)
+    check_metric_time('Middleware/base', 1.0, 0.1)
+    check_metric_time('Middleware/second', 1.0, 0.1)
+  end
+
+  def test_parse_queue_time
+    env = {}
+    create_test_start_time(env)
+    time1 = convert_to_microseconds(Time.at(1000))
+
+    env['HTTP_X_QUEUE_START'] = "t=#{time1}"
+    assert_calls_metrics('WebFrontend/QueueTime') do
+      assert_equal(Time.at(1000), parse_queue_time_from(env))
+    end
+
+    check_metric_time('WebFrontend/QueueTime', 2.0, 0.1)
+  end
+
+  def test_check_for_alternate_queue_length
+    env = {}
+    create_test_start_time(env)
+    env['HTTP_X_QUEUE_TIME'] = '1000000'
+    assert_calls_metrics('WebFrontend/QueueTime') do
+      assert_equal(Time.at(1001), parse_queue_time_from(env))
+    end
+
+    check_metric_time('WebFrontend/QueueTime', 1.0, 0.001)
+  end
+
+  def test_check_for_alternate_queue_length_override
+    env = {}
+    create_test_start_time(env)
+    env['HTTP_X_QUEUE_START'] = 't=1' # obviously incorrect
+    env['HTTP_X_QUEUE_TIME'] = '1000000'
+    assert_calls_metrics('WebFrontend/QueueTime') do
+      assert_equal(Time.at(1001), parse_queue_time_from(env))
+    end
+
+    # alternate queue should override normal header
+    check_metric_time('WebFrontend/QueueTime', 1.0, 0.001)
+  end
+
+  def test_check_for_heroku_queue_length
+    env = {}
+    create_test_start_time(env)
+    env['HTTP_X_HEROKU_QUEUE_WAIT_TIME'] = '1000'
+    assert_calls_metrics('WebFrontend/QueueTime') do
+      assert_equal(Time.at(1001), parse_queue_time_from(env))
+    end
+
+    check_metric_time('WebFrontend/QueueTime', 1.0, 0.001)
+  end
+
+  def test_check_for_heroku_queue_length_override
+    env = {}
+    create_test_start_time(env)
+    env['HTTP_X_QUEUE_TIME'] = '10000000' # ten MEEELION useconds
+    env['HTTP_X_HEROKU_QUEUE_WAIT_TIME'] = '1000'
+    assert_calls_metrics('WebFrontend/QueueTime') do
+      assert_equal(Time.at(1001), parse_queue_time_from(env))
+    end
+
+    # heroku queue should override alternate queue
+    check_metric_time('WebFrontend/QueueTime', 1.0, 0.001)
+  end
+
+  # each server should be one second, and the total would be 2 seconds
+  def test_record_individual_server_stats
+    matches = [['foo', Time.at(1000)], ['bar', Time.at(1001)]]
+    assert_calls_metrics('WebFrontend/WebServer/foo', 'WebFrontend/WebServer/bar') do
+      record_individual_server_stats(Time.at(1002), matches)
+    end
+    check_metric_time('WebFrontend/WebServer/foo', 1.0, 0.1)
+    check_metric_time('WebFrontend/WebServer/bar', 1.0, 0.1)
+  end
+
+  def test_record_rollup_server_stat
+    assert_calls_metrics('WebFrontend/WebServer/all') do
+      record_rollup_server_stat(Time.at(1001), [['a', Time.at(1000)]])
+    end
+    check_metric_time('WebFrontend/WebServer/all', 1.0, 0.1)
+  end
+
+  def test_record_rollup_server_stat_no_data
+    assert_calls_metrics('WebFrontend/WebServer/all') do
+      record_rollup_server_stat(Time.at(1001), [])
+    end
+    check_metric_time('WebFrontend/WebServer/all', 0.0, 0.001)
+  end
+
+  def test_record_rollup_middleware_stat
+    assert_calls_metrics('Middleware/all') do
+      record_rollup_middleware_stat(Time.at(1001), [['a', Time.at(1000)]])
+    end
+    check_metric_time('Middleware/all', 1.0, 0.1)
+  end
+
+  def test_record_rollup_middleware_stat_no_data
+    assert_calls_metrics('Middleware/all') do
+      record_rollup_middleware_stat(Time.at(1001), [])
+    end
+    check_metric_time('Middleware/all', 0.0, 0.001)
+  end
+
+  def test_record_rollup_queue_stat
+    assert_calls_metrics('WebFrontend/QueueTime') do
+      record_rollup_queue_stat(Time.at(1001), [[nil, Time.at(1000)]])
+    end
+    check_metric_time('WebFrontend/QueueTime', 1.0, 0.1)
+  end
+
+  def test_record_rollup_queue_stat_no_data
+    assert_calls_metrics('WebFrontend/QueueTime') do
+      record_rollup_queue_stat(Time.at(1001), [])
+    end
+    check_metric_time('WebFrontend/QueueTime', 0.0, 0.001)
+  end
+
+  def test_find_oldest_time
+    test_array = [
+                   ['c', Time.at(1002)],                   
+                   ['a', Time.at(1000)],
+                   ['b', Time.at(1001)],
+                   ['d', Time.at(1000)],
+                  ]
+    assert_equal(find_oldest_time(test_array), Time.at(1000),
+                 "Should be the oldest time in the array")
+  end
+
+  # trivial test but the method doesn't do much
+  def test_record_server_time_for
+    name = 'foo'
+    time = Time.at(1000)
+    start_time = Time.at(1001)
+    self.expects(:record_time_stat).with('WebFrontend/WebServer/foo', time, start_time)
+    record_server_time_for(name, time, start_time)
+  end
+
+  def test_record_time_stat
+    assert_calls_metrics('WebFrontend/WebServer/foo') do
+      record_time_stat('WebFrontend/WebServer/foo', Time.at(1000), Time.at(1001))
+    end
+    check_metric_time('WebFrontend/WebServer/foo', 1.0, 0.1)
+    assert_raises(RuntimeError) do
+      record_time_stat('foo', Time.at(1001), Time.at(1000))
+    end
+  end
+
+  def test_record_time_stat_with_end_after_start
+    record_time_stat('WebFrontend/WebServer/foo', Time.at(1.0001), Time.at(1))
+  rescue RuntimeError => e
+    assert_match(/should not provide an end time less than start time/, e.message)
+  end
+
+  def test_convert_to_microseconds
+    assert_equal((1_000_000_000), convert_to_microseconds(Time.at(1000)), 'time at 1000 seconds past epoch should be 1,000,000,000 usec')
+    assert_equal 1_000_000_000, convert_to_microseconds(1_000_000_000), 'should not mess with a number if passed in'
+    assert_raises(TypeError) do
+      convert_to_microseconds('whoo yeah buddy')
+    end
+  end
+
+  def test_convert_from_microseconds
+    assert_equal Time.at(1000), convert_from_microseconds(1_000_000_000), 'time at 1,000,000,000 usec should be 1000 seconds after epoch'
+    assert_equal Time.at(1000), convert_from_microseconds(Time.at(1000)), 'should not mess with a time passed in'
+    assert_raises(TypeError) do
+      convert_from_microseconds('10000000000')
+    end
+  end
+
+  def test_add_end_time_header
+    env = {}
+    start_time = Time.at(1)
+    add_end_time_header(start_time, env)
+    assert_equal({'HTTP_X_APPLICATION_START' => "t=#{convert_to_microseconds(Time.at(1))}"}, env, "should add the header to the env hash")
+  end
+
+  def test_parse_end_time_base
+    env = {}
+    env['HTTP_X_APPLICATION_START'] = "t=#{convert_to_microseconds(Time.at(1))}"
+    start_time = parse_end_time(env)
+    assert_equal(Time.at(1), start_time, "should pull the correct start time from the app header")
+  end
+
+  def test_get_matches_from_header
+    env = {'A HEADER' => 't=1000000'}
+    self.expects(:convert_from_microseconds).with(1000000).returns(Time.at(1))
+    matches = get_matches_from_header('A HEADER', env)
+    assert_equal [[nil, Time.at(1)]], matches, "should pull the correct time from the string"
+  end
+
+  def test_convert_to_name_time_pair
+    name = :foo
+    time = "1000000"
+
+    pair = convert_to_name_time_pair(name, time)
+    assert_equal [:foo, Time.at(1)], pair
+  end
+
+  def test_get_matches
+    str = "servera t=1000000, serverb t=1000000"
+    matches = get_matches(str) # start a fire
+    assert_equal [['servera', '1000000'], ['serverb', '1000000']], matches
+  end
+
+  def test_matches_with_bad_data
+    str = "stephan is a dumb lol"
+    matches = get_matches(str)
+    assert_equal [], matches
+
+    str = "t=100"
+    matches = get_matches(str)
+    assert_equal [[nil, '100']], matches
+
+    str = nil
+    matches = get_matches(str)
+    assert_equal [], matches
+  end
+  # each server should be one second, and the total would be 2 seconds
+  def test_record_individual_middleware_stats
+    matches = [['foo', Time.at(1000)], ['bar', Time.at(1001)]]
+    assert_calls_metrics('Middleware/foo', 'Middleware/bar') do
+      record_individual_middleware_stats(Time.at(1002), matches)
+    end
+    check_metric_time('Middleware/foo', 1.0, 0.1)
+    check_metric_time('Middleware/bar', 1.0, 0.1)
+  end
+end