newrelic_rpm 3.0.1 → 3.1.0.beta1

data/test/new_relic/agent/error_collector/notice_error_test.rb

@@ -139,20 +139,22 @@ class NewRelic::Agent::ErrorCollector::NoticeErrorTest < Test::Unit::TestCase
   end
 
   def test_add_to_error_queue_positive
-    exception = mock('exception')
+    noticed_error = mock('noticed_error')
+    noticed_error.expects(:message).returns('a message')
     @lock = Mutex.new
     @errors = []
-    self.expects(:over_queue_limit?).with(exception).returns(false)
-    add_to_error_queue('foo', exception)
-    assert_equal(['foo'], @errors)
+    self.expects(:over_queue_limit?).with('a message').returns(false)
+    add_to_error_queue(noticed_error)
+    assert_equal([noticed_error], @errors)
   end
 
   def test_add_to_error_queue_negative
-    exception = mock('exception')
+    noticed_error = mock('noticed_error')
+    noticed_error.expects(:message).returns('a message')
     @lock = Mutex.new
     @errors = []
-    self.expects(:over_queue_limit?).with(exception).returns(true)
-    add_to_error_queue('foo', exception)
+    self.expects(:over_queue_limit?).with('a message').returns(true)
+    add_to_error_queue(noticed_error)
     assert_equal([], @errors)
   end
 

data/test/new_relic/agent/error_collector_test.rb

@@ -72,22 +72,21 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
 
     @error_collector.notice_error(Exception.new("message"), :metric => 'second', :request_params => {:x => 'y'})
     @error_collector.notice_error(Exception.new("message"), :metric => 'path', :request_params => {:x => 'y'})
-    @error_collector.notice_error(Exception.new("message"), :metric => 'path', :request_params => {:x => 'y'})
+    @error_collector.notice_error(Exception.new("message"), :metric => 'last', :request_params => {:x => 'y'})
 
     errors = @error_collector.harvest_errors(errors)
 
-    assert_equal 1, errors.length
+    assert_equal 4, errors.length
     assert_equal 'first', errors.first.path
+    assert_equal 'last', errors.last.path
 
-    # add two more
-    @error_collector.notice_error(Exception.new("message"), :metric => 'path', :request_params => {:x => 'y'})
+    @error_collector.notice_error(Exception.new("message"), :metric => 'first', :request_params => {:x => 'y'})
     @error_collector.notice_error(Exception.new("message"), :metric => 'last', :request_params => {:x => 'y'})
 
     errors = @error_collector.harvest_errors(nil)
-    assert_equal 5, errors.length
-    assert_equal 'second', errors.first.path
+    assert_equal 2, errors.length
+    assert_equal 'first', errors.first.path
     assert_equal 'last', errors.last.path
-
   end
 
   def test_queue_overflow

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

@@ -2,20 +2,24 @@ require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_h
 class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::Unit::TestCase
   require 'active_record_fixtures'
   include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+
+  @@setup = false
   def setup
     super
-    NewRelic::Agent.manual_start
+    unless @@setup
+      NewRelic::Agent.manual_start
+      @setup = true
+    end
     ActiveRecordFixtures.setup
     NewRelic::Agent.instance.transaction_sampler.reset!
     NewRelic::Agent.instance.stats_engine.clear_stats
-  rescue
+  rescue Exception => e
     puts e
     puts e.backtrace.join("\n")
   end
 
   def teardown
     super
-    ActiveRecordFixtures.teardown
     NewRelic::Agent.shutdown
   end
 
@@ -373,6 +377,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
 
   def test_transaction_mysql
     return unless isMysql? && !defined?(JRuby)
+    ActiveRecordFixtures.setup
     sample = NewRelic::Agent.instance.transaction_sampler.reset!
     perform_action_with_newrelic_trace :name => 'bogosity' do
       ActiveRecordFixtures::Order.add_delay
@@ -386,9 +391,11 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
     explanations = segment.params[:explanation]
     assert_not_nil explanations, "No explains in segment: #{segment}"
     assert_equal 1, explanations.size,"No explains in segment: #{segment}"
-    assert_equal 1, explanations.first.size
+    assert_equal 1, explanations.first.size, "should be one row of explanation"
 
-    assert_equal "1;SIMPLE;#{ActiveRecordFixtures::Order.table_name};ALL;;;;;1;", explanations.first.first.join(';')
+    row = explanations.first.first
+    assert_equal 10, row.size
+    assert_equal ['1', 'SIMPLE', ActiveRecordFixtures::Order.table_name], row[0..2]
 
     s = NewRelic::Agent.get_stats("ActiveRecord/ActiveRecordFixtures::Order/find")
     assert_equal 1, s.call_count

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

@@ -0,0 +1,195 @@
+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
+
+  def setup
+    @agent = mock('agent')
+    @transaction_sampler = mock('transaction sampler')
+  end
+
+  def teardown
+    Thread.current[:newrelic_start_time] = nil
+    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_last_start_time
+    start_time = Time.now
+    mock_frame = mock('frame')
+    mock_frame.expects(:respond_to?).with(:start).returns(true)
+    mock_frame.expects(:start).returns(start_time)
+    Thread.current[:newrelic_start_time] = nil
+    Thread.current[:newrelic_metric_frame] = mock_frame
+
+    set_last_start_time!
+
+    assert_equal(start_time, Thread.current[:newrelic_start_time], "should set the start time correctly: #{start_time.inspect} expected but was #{Thread.current[:newrelic_start_time].inspect}")
+  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_process_histogram_for_transaction
+    fakehistogram = mock('histogram')
+    agent.expects(:histogram).returns(fakehistogram)
+    self.expects(:start).returns(2)
+    fakehistogram.expects(:process).with(1.0)
+    process_histogram_for_transaction(3)
+  end
+
+  def test_notice_scope_empty
+    transaction_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(:process_histogram_for_transaction)
+    self.expects(:notice_scope_empty)
+    notify_transaction_sampler(true)
+  end
+
+  def test_notify_transaction_sampler_false
+    self.expects(:record_transaction_cpu)
+    self.expects(:process_histogram_for_transaction).never
+    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(:set_last_start_time!)
+    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(:set_last_start_time!)
+    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(:set_last_start_time!)
+    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/net_instrumentation_test.rb

@@ -1,82 +1,84 @@
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+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
+  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
 
-  private :metrics_without_gc
+    def metrics_without_gc
+      @engine.metrics - ['GC/cumulative']
+    end
 
-  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>/, res.body
-    assert_equal %w[External/www.google.com/Net::HTTP/GET External/allOther External/www.google.com/all].sort,
-    metrics_without_gc.sort
-  end
+    private :metrics_without_gc
 
-  def test_background
-    perform_action_with_newrelic_trace("task", :category => :task) do
+    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>/, res.body
+      assert_equal %w[External/www.google.com/Net::HTTP/GET External/allOther External/www.google.com/all].sort,
+      metrics_without_gc.sort
     end
-    assert_equal %w[External/www.google.com/Net::HTTP/GET External/allOther External/www.google.com/all
+
+    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>/, res.body
+      end
+      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::Instrumentation::NetInstrumentationTest/task].sort, metrics_without_gc.select{|m| m =~ /^External/}.sort
-  end
+    end
 
-  def test_transactional
-    perform_action_with_newrelic_trace("task") do
+    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>/, res.body
+      end
+      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::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/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.get('/index.html')
+        http.head('/index.html')
       }
-      assert_match /<head>/, res.body
+      assert_equal %w[External/www.google.com/Net::HTTP/HEAD External/allOther External/www.google.com/all].sort,
+      metrics_without_gc.sort
     end
-    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::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/www.google.com/Net::HTTP/GET External/allOther External/www.google.com/all].sort
-  end
-  def test_ignore
-    NewRelic::Agent.disable_all_tracing do
+
+    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/www.google.com/Net::HTTP/POST External/allOther External/www.google.com/all].sort,
+      metrics_without_gc.sort
     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/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/www.google.com/Net::HTTP/POST External/allOther External/www.google.com/all].sort,
-    metrics_without_gc.sort
   end
-
 end

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

@@ -25,6 +25,20 @@ class NewRelic::Agent::Instrumentation::QueueTimeTest < Test::Unit::TestCase
     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))}"