newrelic_rpm 2.13.4 → 2.13.5.beta1

data/test/new_relic/agent/method_tracer_test.rb

@@ -134,10 +134,10 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
   def test_tt_only
     
     assert_nil @scope_listener.scope["c2"]
-    self.class.add_method_tracer :method_c1, "c1", true
+    self.class.add_method_tracer :method_c1, "c1", :push_scope => true
     
     self.class.add_method_tracer :method_c2, "c2", :metric => false
-    self.class.add_method_tracer :method_c3, "c3", false
+    self.class.add_method_tracer :method_c3, "c3", :push_scope => false
     
     method_c1
     

data/test/new_relic/agent/method_tracer_trace_execution_scoped_test.rb

@@ -0,0 +1,233 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+class NewRelic::Agent::MethodTracer::TraceExecutionScopedTest < Test::Unit::TestCase
+  require 'new_relic/agent/method_tracer'
+  include NewRelic::Agent::MethodTracer::InstanceMethods::TraceExecutionScoped
+  
+  def test_trace_disabled_negative
+    self.expects(:traced?).returns(false)
+    options = {:force => false}
+    assert trace_disabled?(options)
+  end
+  
+  def test_trace_disabled_forced
+    self.expects(:traced?).returns(false)
+    options = {:force => true}
+    assert !(trace_disabled?(options))
+  end
+
+  def test_trace_disabled_positive
+    self.expects(:traced?).returns(true)
+    options = {:force => false}
+    assert !(trace_disabled?(options))
+  end  
+
+  def test_get_stats_unscoped
+    fake_engine = mocked_object('stat_engine')
+    fake_engine.expects(:get_stats_no_scope).with('foob').returns('fakestats')
+    assert_equal 'fakestats', get_stats_unscoped('foob')
+  end
+
+  def test_get_stats_scoped_scoped_only
+    fake_engine = mocked_object('stat_engine')    
+    fake_engine.expects(:get_stats).with('foob', true, true).returns('fakestats')
+    assert_equal 'fakestats', get_stats_scoped('foob', true)
+  end
+
+  def test_get_stats_scoped_no_scoped_only
+    fake_engine = mocked_object('stat_engine')    
+    fake_engine.expects(:get_stats).with('foob', true, false).returns('fakestats')
+    assert_equal 'fakestats', get_stats_scoped('foob', false)
+  end
+
+  def test_stat_engine
+    assert_equal agent_instance.stats_engine, stat_engine
+  end
+
+  def test_agent_instance
+    assert_equal NewRelic::Agent.instance, agent_instance
+  end
+
+  def test_main_stat
+    self.expects(:get_stats_scoped).with('hello', true)
+    opts = {:scoped_metric_only => true}
+    main_stat('hello', opts)
+  end
+
+  def test_get_metric_stats_metric
+    metrics = ['foo', 'bar', 'baz']
+    opts = {:metric => true}
+    self.expects(:get_stats_unscoped).twice
+    self.expects(:main_stat).with('foo', opts)
+    first_name, stats = get_metric_stats(metrics, opts)
+    assert_equal 'foo', first_name
+    assert_equal 3, stats.length
+  end
+
+  def test_get_metric_stats_no_metric
+    metrics = ['foo', 'bar', 'baz']
+    opts = {:metric => false}
+    self.expects(:get_stats_unscoped).twice
+    first_name, stats = get_metric_stats(metrics, opts)
+    assert_equal 'foo', first_name
+    assert_equal 2, stats.length
+  end
+
+  def test_set_if_nil
+    h = {}
+    set_if_nil(h, :foo)
+    assert h[:foo]
+    h[:bar] = false
+    set_if_nil(h, :bar)
+    assert !h[:bar]
+  end
+
+  def test_push_flag_true
+    fake_agent = mocked_object('agent_instance')
+    fake_agent.expects(:push_trace_execution_flag).with(true)
+    push_flag!(true)
+  end
+
+  def test_push_flag_false
+    self.expects(:agent_instance).never
+    push_flag!(false)
+  end
+
+  def test_pop_flag_true
+    fake_agent = mocked_object('agent_instance')
+    fake_agent.expects(:pop_trace_execution_flag)
+    pop_flag!(true)
+  end
+
+  def test_pop_flag_false
+    self.expects(:agent_instance).never
+    pop_flag!(false)
+  end
+
+  def test_log_errors_base
+    self.expects(:log).never
+    ran = false
+    log_errors("name", "metric") do
+      ran = true
+    end
+    assert ran, "should run the contents of the block"
+  end
+
+  def test_log_errors_with_return
+    self.expects(:log).never
+    ran = false
+    return_val = log_errors('name', 'metric') do
+      ran = true
+      'happy trees'
+    end
+
+    assert ran, "should run contents of block"
+    assert_equal 'happy trees', return_val, "should return contents of the block"
+  end
+
+  def test_log_errors_with_error
+    fakelog = mocked_log
+    # normally I don't do this, but we really don't care what the
+    # backtrace looks like, beyond that it actually gets logged. Also,
+    # the mocks are reversed because apparently order matters.
+    fakelog.expects(:error).with(any_parameters)
+    fakelog.expects(:error).with("Caught exception in name. Metric name = metric, exception = should not propagate out of block")
+    
+    log_errors("name", "metric") do
+      raise "should not propagate out of block"
+    end
+  end
+
+  def test_trace_execution_scoped_header
+    options = {:force => false, :deduct_call_time_from_parent => false}
+    self.expects(:log_errors).with('trace_execution_scoped header', 'foo').yields
+    self.expects(:push_flag!).with(false)
+    fakestats = mocked_object('stat_engine')
+    fakestats.expects(:push_scope).with('foo', 1.0, false)
+    trace_execution_scoped_header('foo', options, 1.0)
+  end
+
+  def test_trace_execution_scoped_footer
+    t0 = 1.0
+    t1 = 2.0
+    metric = 'foo'
+    metric_stats = [mock('fakestat')]
+    metric_stats.first.expects(:trace_call).with(1.0, 0.5)
+    expected_scope = 'an expected scope'
+    engine = mocked_object('stat_engine')
+    scope = mock('scope')
+    engine.expects(:pop_scope).with('an expected scope', 1.0, 2.0).returns(scope)
+    scope.expects(:children_time).returns(0.5)
+    self.expects(:pop_flag!).with(false)
+    self.expects(:log_errors).with('trace_method_execution footer', 'foo').yields
+
+    trace_execution_scoped_footer(t0, metric, metric_stats, expected_scope, false, t1)
+  end
+  
+  def test_trace_execution_scoped_disabled
+    self.expects(:trace_disabled?).returns(true)
+    # make sure the method doesn't beyond the abort
+    self.expects(:set_if_nil).never
+    ran = false
+    value = trace_execution_scoped(nil, {:options => 'hash'}) do
+      ran = true
+      1172
+    end
+
+    assert ran, 'should run contents of block'
+    assert_equal 1172, value, 'should return contents of block'
+  end
+
+  def test_trace_execution_scoped_default
+    passed_in_opts = {}
+    opts_after_correction = {:metric => true, :deduct_call_time_from_parent => true}
+    self.expects(:trace_disabled?).returns(false)
+    self.expects(:get_metric_stats).with(['metric', 'array'], opts_after_correction).returns(['metric', ['stats']])
+    self.expects(:trace_execution_scoped_header).with('metric', opts_after_correction).returns(['start_time', 'expected_scope'])
+    self.expects(:trace_execution_scoped_footer).with('start_time', 'metric', ['stats'], 'expected_scope', nil)
+    ran = false
+    value = trace_execution_scoped(['metric', 'array'], passed_in_opts) do
+      ran = true
+      1172
+    end
+
+    assert ran, 'should run contents of the block'
+    assert_equal 1172, value, 'should return the contents of the block'
+  end
+  
+  def test_trace_execution_scoped_with_error
+    passed_in_opts = {}
+    opts_after_correction = {:metric => true, :deduct_call_time_from_parent => true}
+    self.expects(:trace_disabled?).returns(false)
+    self.expects(:get_metric_stats).with(['metric', 'array'], opts_after_correction).returns(['metric', ['stats']])
+    self.expects(:trace_execution_scoped_header).with('metric', opts_after_correction).returns(['start_time', 'expected_scope'])
+    self.expects(:trace_execution_scoped_footer).with('start_time', 'metric', ['stats'], 'expected_scope', nil)
+    ran = false
+    assert_raises(RuntimeError) do
+      trace_execution_scoped(['metric', 'array'], passed_in_opts) do
+        ran = true
+        raise 'wtfmate'
+      end
+    end
+
+    assert ran, 'should run contents of the block'
+  end
+  
+  private
+
+  def mocked_object(name)
+    object = mock(name)
+    self.stubs(name).returns(object)
+    object
+  end
+  
+  
+  def mocked_log
+    mocked_object('log')
+  end
+
+
+  def mocked_control
+    mocked_object('control')
+  end
+end
+

data/test/new_relic/agent/net_instrumentation_test.rb

@@ -7,6 +7,13 @@ class NewRelic::Agent::NetInstrumentationTest < Test::Unit::TestCase
     @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|
@@ -14,7 +21,7 @@ class NewRelic::Agent::NetInstrumentationTest < Test::Unit::TestCase
     }
     assert_match /<head>/, res.body
     assert_equal %w[External/www.google.com/Net::HTTP/GET External/allOther External/www.google.com/all].sort,
-       @engine.metrics.sort 
+    metrics_without_gc.sort 
   end
 
   def test_background
@@ -25,9 +32,8 @@ class NewRelic::Agent::NetInstrumentationTest < Test::Unit::TestCase
       }
       assert_match /<head>/, res.body
     end
-    assert_equal @engine.metrics.select{|m| m =~ /^External/}.sort, 
-       %w[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::NetInstrumentationTest/task].sort
+    assert_equal %w[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::NetInstrumentationTest/task].sort, metrics_without_gc.select{|m| m =~ /^External/}.sort
   end
 
   def test_transactional
@@ -38,14 +44,13 @@ class NewRelic::Agent::NetInstrumentationTest < Test::Unit::TestCase
       }
       assert_match /<head>/, res.body
     end
-    assert_equal @engine.metrics.select{|m| m =~ /^External/}.sort, 
-       %w[External/www.google.com/Net::HTTP/GET External/allWeb External/www.google.com/all
-       External/www.google.com/Net::HTTP/GET:Controller/NewRelic::Agent::NetInstrumentationTest/task].sort
+    assert_equal %w[External/www.google.com/Net::HTTP/GET External/allWeb External/www.google.com/all
+       External/www.google.com/Net::HTTP/GET:Controller/NewRelic::Agent::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 @engine.metrics.sort, 
-       %w[External/www.google.com/Net::HTTP/GET External/allOther External/www.google.com/all].sort
+    assert_equal metrics_without_gc.sort, 
+    %w[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
@@ -54,7 +59,7 @@ class NewRelic::Agent::NetInstrumentationTest < Test::Unit::TestCase
         http.post('/index.html','data')
       }
     end
-    assert_equal 0, @engine.metrics.size 
+    assert_equal 0, metrics_without_gc.size 
   end
   def test_head
     url = URI.parse('http://www.google.com/index.html')
@@ -62,7 +67,7 @@ class NewRelic::Agent::NetInstrumentationTest < Test::Unit::TestCase
       http.head('/index.html')
     }
     assert_equal %w[External/www.google.com/Net::HTTP/HEAD External/allOther External/www.google.com/all].sort,
-    @engine.metrics.sort 
+    metrics_without_gc.sort 
   end
   
   def test_post
@@ -71,7 +76,7 @@ class NewRelic::Agent::NetInstrumentationTest < Test::Unit::TestCase
       http.post('/index.html','data')
     }
     assert_equal %w[External/www.google.com/Net::HTTP/POST External/allOther External/www.google.com/all].sort, 
-    @engine.metrics.sort 
+    metrics_without_gc.sort 
   end
   
 end

data/test/new_relic/agent/queue_time_test.rb

@@ -0,0 +1,333 @@
+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
+    self.expects(:current_time).returns('END_TIME')
+    self.expects(:add_end_time_header).with('END_TIME', {: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'})
+    self.expects(:parse_queue_time_from).with({:env => 'hash'})
+    self.expects(:parse_server_time_from).with({:env => 'hash'})
+    parse_frontend_headers({:env => 'hash'})
+  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
+      parse_middleware_time_from(env)
+      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)    
+    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)      
+      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
+      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
+      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
+      parse_queue_time_from(env)
+    end
+
+    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
+
+  
+  # check all the combinations to make sure that ordering doesn't
+  # affect the return value
+  def test_find_oldest_time
+    test_arrays = [
+                   ['a', Time.at(1000)],
+                   ['b', Time.at(1001)],
+                   ['c', Time.at(1002)],
+                   ['d', Time.at(1000)],
+                  ]
+    test_arrays = test_arrays.permutation
+    test_arrays.each do |test_array|
+      assert_equal find_oldest_time(test_array), Time.at(1000), "Should be the oldest time in the array"
+    end
+  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', 2, 1)
+  rescue RuntimeError => e
+    assert_equal("should not provide an end time less than start time: 1 is less than 2", 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