newrelic_rpm 2.9.9 → 2.10.3

data/test/new_relic/agent/stats_engine/metric_stats_test.rb

@@ -0,0 +1,79 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper')) 
+
+
+class NewRelic::Agent::MetricStatsTest < Test::Unit::TestCase
+  def setup
+    NewRelic::Agent.manual_start
+    @engine = NewRelic::Agent.instance.stats_engine
+  rescue => e
+    puts e
+    puts e.backtrace.join("\n")
+  end
+  def teardown
+    @engine.harvest_timeslice_data({},{})
+  end
+  def test_get_no_scope
+    s1 = @engine.get_stats "a"
+    s2 = @engine.get_stats "a"
+    s3 = @engine.get_stats "b"
+    
+    assert_not_nil s1
+    assert_not_nil s2
+    assert_not_nil s3
+    
+    assert s1 == s2
+    assert s1 != s3
+  end
+  
+  def test_harvest
+    s1 = @engine.get_stats "a"
+    s2 = @engine.get_stats "c"
+    
+    s1.trace_call 10
+    s2.trace_call 1
+    s2.trace_call 3
+    
+    assert @engine.get_stats("a").call_count == 1
+    assert @engine.get_stats("a").total_call_time == 10
+    
+    assert @engine.get_stats("c").call_count == 2
+    assert @engine.get_stats("c").total_call_time == 4
+    
+    metric_data = @engine.harvest_timeslice_data({}, {}).values
+    
+    # after harvest, all the metrics should be reset
+    assert @engine.get_stats("a").call_count == 0
+    assert @engine.get_stats("a").total_call_time == 0
+    
+    assert @engine.get_stats("c").call_count == 0
+    assert @engine.get_stats("c").total_call_time == 0
+    
+    metric_data = metric_data.reverse if metric_data[0].metric_spec.name != "a"
+    
+    assert metric_data[0].metric_spec.name == "a"
+    
+    assert metric_data[0].stats.call_count == 1
+    assert metric_data[0].stats.total_call_time == 10
+  end
+  
+  def test_harvest_with_merge
+    s = @engine.get_stats "a"
+    s.trace_call 1
+    
+    assert @engine.get_stats("a").call_count == 1
+    
+    harvest = @engine.harvest_timeslice_data({}, {})
+    assert s.call_count == 0
+    s.trace_call 2
+    assert s.call_count == 1
+    
+    # this calk should merge the contents of the previous harvest,
+    # so the stats for metric "a" should have 2 data points
+    harvest = @engine.harvest_timeslice_data(harvest, {})
+    stats = harvest.fetch(NewRelic::MetricSpec.new("a")).stats
+    assert stats.call_count == 2
+    assert stats.total_call_time == 3
+  end
+
+end
+

data/test/new_relic/{samplers_test.rb → agent/stats_engine/samplers_test.rb}

@@ -1,10 +1,11 @@
-require File.expand_path(File.join(File.dirname(__FILE__),'..', 'test_helper'))
+require File.expand_path(File.join(File.dirname(__FILE__),'..', '..','..','test_helper'))
 require 'new_relic/agent/samplers/cpu_sampler'
 
-class NewRelic::SamplersTest < Test::Unit::TestCase
+class NewRelic::Agent::StatsEngine::SamplersTest < Test::Unit::TestCase
   
   def setup
     @stats_engine = NewRelic::Agent::StatsEngine.new
+    NewRelic::Agent.instance.stubs(:stats_engine).returns(@stats_engine)
   end
   def test_cpu
     s = NewRelic::Agent::Samplers::CpuSampler.new
@@ -29,6 +30,7 @@ class NewRelic::SamplersTest < Test::Unit::TestCase
     assert s.stats.total_call_time > 0.5, "cpu greater than 0.5 ms: #{s.stats.total_call_time}"
   end
   def test_memory__linux
+    return if RUBY_PLATFORM =~ /darwin/
     NewRelic::Agent::Samplers::MemorySampler.any_instance.stubs(:platform).returns 'linux'
     s = NewRelic::Agent::Samplers::MemorySampler.new
     s.stats_engine = @stats_engine
@@ -39,33 +41,32 @@ class NewRelic::SamplersTest < Test::Unit::TestCase
     assert s.stats.total_call_time > 0.5, "cpu greater than 0.5 ms: #{s.stats.total_call_time}"
   end
   def test_memory__solaris
+    return if defined? JRuby
     NewRelic::Agent::Samplers::MemorySampler.any_instance.stubs(:platform).returns 'solaris'
-    assert_raise RuntimeError, /Unable to run command/ do
-      NewRelic::Agent::Samplers::MemorySampler.new
-    end
+    NewRelic::Agent::Samplers::MemorySampler::ShellPS.any_instance.stubs(:get_memory).returns 999
+    s = NewRelic::Agent::Samplers::MemorySampler.new
+    s.stats_engine = @stats_engine
+    s.poll
+    assert_equal 1, s.stats.call_count
+    assert_equal 999, s.stats.total_call_time
   end
   def test_memory__windows
+    return if defined? JRuby
     NewRelic::Agent::Samplers::MemorySampler.any_instance.stubs(:platform).returns 'win32'
-    assert_raise RuntimeError, /Unsupported platform/ do
+    assert_raise NewRelic::Agent::Sampler::Unsupported do
       NewRelic::Agent::Samplers::MemorySampler.new
     end
   end
-  def test_mongrel 
-    NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.stubs('is_busy?'.to_sym).returns(false)  
-    mongrel = mock()
-    NewRelic::Control.instance.local_env.stubs(:mongrel).returns(mongrel)
-    list = mock()
-    workers = mock()
-    workers.stubs(:list).returns(list)
-    list.stubs(:length).returns(3)
-    mongrel.expects(:workers).returns(workers).at_least_once
-    s = NewRelic::Agent::Samplers::MongrelSampler.new
-    s.stats_engine = @stats_engine
-    s.poll
-    s.poll
-    s.poll
-    assert_equal 3, s.queue_stats.call_count
-    assert_equal 3, s.queue_stats.average_call_time, "mongrel queue length"
+  def test_load_samplers
+    @stats_engine.expects(:add_harvest_sampler).once unless defined? JRuby
+    @stats_engine.expects(:add_sampler).never
+    NewRelic::Control.instance.load_samplers
+    sampler_count = 4
+    assert_equal sampler_count, NewRelic::Agent::Sampler.sampler_classes.size, NewRelic::Agent::Sampler.sampler_classes.inspect
+  end
+  def test_memory__is_supported
+    NewRelic::Agent::Samplers::MemorySampler.stubs(:platform).returns 'windows'
+    assert !NewRelic::Agent::Samplers::MemorySampler.supported_on_this_platform? || defined? JRuby
   end
   
 end

data/test/new_relic/agent/{stats_engine_test.rb → stats_engine/stats_engine_test.rb}

@@ -1,106 +1,17 @@
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..', 'test_helper')) 
 
 
-class NewRelic::Agent::StatsEngineTest < Test::Unit::TestCase
+class NewRelic::Agent::StatsEngine::TransactionsTest < Test::Unit::TestCase
   def setup
     NewRelic::Agent.manual_start
-    @engine = NewRelic::Agent.instance.stats_engine
+    @engine = NewRelic::Agent::StatsEngine.new 
+  rescue => e
+    puts e
+    puts e.backtrace.join("\n")
   end
   def teardown
     @engine.harvest_timeslice_data({},{})
   end
-  def test_get_no_scope
-    s1 = @engine.get_stats "a"
-    s2 = @engine.get_stats "a"
-    s3 = @engine.get_stats "b"
-    
-    assert_not_nil s1
-    assert_not_nil s2
-    assert_not_nil s3
-    
-    assert s1 == s2
-    assert s1 != s3
-  end
-  
-  # The default agent configuration when running tests does not
-  # install the samplers so this test just creates them and polls them
-  # just like the stats_engine does.
-  def test_samplers
-    
-    samplers = []
-    cpu_sampler = NewRelic::Agent::Samplers::CpuSampler.new
-    samplers << cpu_sampler unless defined? Java
-    samplers << NewRelic::Agent::Samplers::MemorySampler.new 
-    samplers.each { |s| s.stats_engine = @engine }
-    msg = ["Running sampler at #{Time.now}"]
-    @engine.instance_eval do
-      poll(samplers)
-      sleep 2
-      msg << "Polling again at #{Time.now}, last time polled=#{cpu_sampler.last_time}"
-      poll(samplers)
-      sleep 2
-      msg << "Polling again at #{Time.now}, last time polled=#{cpu_sampler.last_time}"
-      poll(samplers)
-    end
-    msg << "Last time polled: #{cpu_sampler.last_time}"
-    data = @engine.harvest_timeslice_data({},{})
-    cpu_user = data[NewRelic::MetricSpec.new('CPU/User Time')]
-    cpu_utilization = data[NewRelic::MetricSpec.new('CPU/User/Utilization')]
-    memory = data[NewRelic::MetricSpec.new('Memory/Physical')]
-    # might get 1, 2 or 3 stats depending on timing factors.  short intervals are skipped.
-    assert_equal 2, cpu_user.stats.call_count, cpu_user.stats.inspect unless defined? Java
-    assert_equal 2, cpu_utilization.stats.call_count, msg.join("; ") unless defined? Java
-    assert_equal 3, memory.stats.call_count
-  end
-  def test_harvest
-    s1 = @engine.get_stats "a"
-    s2 = @engine.get_stats "c"
-    
-    s1.trace_call 10
-    s2.trace_call 1
-    s2.trace_call 3
-    
-    assert @engine.get_stats("a").call_count == 1
-    assert @engine.get_stats("a").total_call_time == 10
-    
-    assert @engine.get_stats("c").call_count == 2
-    assert @engine.get_stats("c").total_call_time == 4
-    
-    metric_data = @engine.harvest_timeslice_data({}, {}).values
-    
-    # after harvest, all the metrics should be reset
-    assert @engine.get_stats("a").call_count == 0
-    assert @engine.get_stats("a").total_call_time == 0
-    
-    assert @engine.get_stats("c").call_count == 0
-    assert @engine.get_stats("c").total_call_time == 0
-    
-    metric_data = metric_data.reverse if metric_data[0].metric_spec.name != "a"
-    
-    assert metric_data[0].metric_spec.name == "a"
-    
-    assert metric_data[0].stats.call_count == 1
-    assert metric_data[0].stats.total_call_time == 10
-  end
-  
-  def test_harvest_with_merge
-    s = @engine.get_stats "a"
-    s.trace_call 1
-    
-    assert @engine.get_stats("a").call_count == 1
-    
-    harvest = @engine.harvest_timeslice_data({}, {})
-    assert s.call_count == 0
-    s.trace_call 2
-    assert s.call_count == 1
-    
-    # this calk should merge the contents of the previous harvest,
-    # so the stats for metric "a" should have 2 data points
-    harvest = @engine.harvest_timeslice_data(harvest, {})
-    stats = harvest.fetch(NewRelic::MetricSpec.new("a")).stats
-    assert stats.call_count == 2
-    assert stats.total_call_time == 3
-  end
   
   def test_scope
     @engine.push_scope "scope1"
@@ -120,12 +31,14 @@ class NewRelic::Agent::StatsEngineTest < Test::Unit::TestCase
   end
   
   def test_scope__overlap
-    @engine.transaction_name = 'orlando'
-    self.class.trace_method_execution_with_scope('disney', true, false) { sleep 0.1 }
+    NewRelic::Agent.instance.stubs(:stats_engine).returns(@engine)
+    
+    @engine.scope_name = 'orlando'
+    self.class.trace_execution_scoped('disney', :deduct_call_time_from_parent => false) { sleep 0.1 }
     orlando_disney = @engine.get_stats 'disney'
     
-    @engine.transaction_name = 'anaheim'
-    self.class.trace_method_execution_with_scope('disney', true, false) { sleep 0.1 }
+    @engine.scope_name = 'anaheim'
+    self.class.trace_execution_scoped('disney', :deduct_call_time_from_parent => false) { sleep 0.1 }
     anaheim_disney = @engine.get_stats 'disney'
 
     disney = @engine.get_stats_no_scope "disney"
@@ -218,8 +131,13 @@ class NewRelic::Agent::StatsEngineTest < Test::Unit::TestCase
   end
   
   def test_simple_start_transaction
-    @engine.push_scope "scope"
+    assert @engine.peek_scope.nil?
+    scope = @engine.push_scope "scope"
     @engine.start_transaction
+    assert !@engine.peek_scope.nil?
+    @engine.pop_scope scope, 0.01
+    assert @engine.peek_scope.nil?
+    @engine.end_transaction
     assert @engine.peek_scope.nil?
   end 
   
@@ -259,7 +177,7 @@ class NewRelic::Agent::StatsEngineTest < Test::Unit::TestCase
   
   private 
   def check_time_approximate(expected, actual)
-    assert((expected - actual).abs < 0.05, "Expected between #{expected - 0.05} and #{expected + 0.05}, got #{actual}")
+    assert((expected - actual).abs < 0.1, "Expected between #{expected - 0.1} and #{expected + 0.1}, got #{actual}")
   end
   
 end

data/test/new_relic/agent/task_instrumentation_test.rb

@@ -0,0 +1,176 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+
+class TaskInstrumentationTest < Test::Unit::TestCase
+  include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+  attr_accessor :agent
+  def setup
+    super
+    NewRelic::Agent.manual_start
+    @agent = NewRelic::Agent.instance
+    @agent.transaction_sampler.send :clear_builder
+    @agent.transaction_sampler.reset!
+    @agent.stats_engine.clear_stats
+  end
+  def teardown
+    NewRelic::Agent.shutdown
+    super
+  end
+  
+  def test_run
+    run_task_inner 0
+    stat_names = %w[Controller/TaskInstrumentationTest/inner_task_0
+                    HttpDispatcher
+                    Apdex Apdex/TaskInstrumentationTest/inner_task_0].sort
+    expected_but_missing = stat_names - @agent.stats_engine.metrics
+    assert_equal 0, expected_but_missing.size, @agent.stats_engine.metrics.map  { |n|
+      stat = @agent.stats_engine.get_stats_no_scope(n)
+      "#{'%-26s' % n}: #{stat.call_count} calls @ #{stat.average_call_time} sec/call"
+    }.join("\n  ") + "\nmissing: #{expected_but_missing.inspect}"
+    assert_equal 0, @agent.stats_engine.get_stats_no_scope('Controller').call_count
+    assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/TaskInstrumentationTest/inner_task_0').call_count
+  end
+  
+  def test_run_recursive
+    run_task_inner(3)
+    assert_equal 1, @agent.stats_engine.lookup_stats(
+                          'Controller/TaskInstrumentationTest/inner_task_0',
+                          'Controller/TaskInstrumentationTest/inner_task_1').call_count
+    assert_equal 1, @agent.stats_engine.lookup_stats(
+                          'Controller/TaskInstrumentationTest/inner_task_1',
+                          'Controller/TaskInstrumentationTest/inner_task_2').call_count
+    assert_equal 1, @agent.stats_engine.lookup_stats(
+                          'Controller/TaskInstrumentationTest/inner_task_2',
+                          'Controller/TaskInstrumentationTest/inner_task_3').call_count
+    assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/TaskInstrumentationTest/inner_task_0').call_count
+    assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/TaskInstrumentationTest/inner_task_1').call_count
+    assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/TaskInstrumentationTest/inner_task_2').call_count
+    assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/TaskInstrumentationTest/inner_task_3').call_count
+    assert_equal 0, @agent.stats_engine.get_stats_no_scope('Controller').call_count
+  end
+  
+  def test_run_nested
+    run_task_outer(3)
+    @agent.stats_engine.metrics.sort.each do |n|
+      stat = @agent.stats_engine.get_stats_no_scope(n)
+      #      puts "#{'%-26s' % n}: #{stat.call_count} calls @ #{stat.average_call_time} sec/call"
+    end
+    assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/TaskInstrumentationTest/outer_task').call_count
+    assert_equal 2, @agent.stats_engine.get_stats_no_scope('Controller/TaskInstrumentationTest/inner_task_0').call_count
+  end
+  
+  def test_reentrancy
+    assert_equal 0, NewRelic::Agent::BusyCalculator.busy_count
+    run_task_inner(1)
+    assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/TaskInstrumentationTest/inner_task_0').call_count
+    assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/TaskInstrumentationTest/inner_task_1').call_count
+    compare_metrics %w[
+      Controller/TaskInstrumentationTest/inner_task_0:Controller/TaskInstrumentationTest/inner_task_1
+      Controller/TaskInstrumentationTest/inner_task_0
+      Controller/TaskInstrumentationTest/inner_task_1
+      ], @agent.stats_engine.metrics.grep(/^Controller/)
+  end
+  
+  def test_transaction
+    assert_equal 0, @agent.transaction_sampler.scope_depth, "existing unfinished sample"
+    assert_nil @agent.transaction_sampler.last_sample
+    assert_equal @agent.transaction_sampler, @agent.stats_engine.instance_variable_get("@transaction_sampler")
+    run_task_outer(10)
+    assert_equal 0, @agent.transaction_sampler.scope_depth, "existing unfinished sample"
+    @agent.stats_engine.metrics.sort.each do |n|
+      stat = @agent.stats_engine.get_stats_no_scope(n)
+      #      puts "#{'%-26s' % n}: #{stat.call_count} calls @ #{stat.average_call_time} sec/call"
+    end
+    assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/TaskInstrumentationTest/outer_task').call_count
+    assert_equal 0, @agent.stats_engine.get_stats_no_scope('Controller').call_count
+    assert_equal 2, @agent.stats_engine.get_stats_no_scope('Controller/TaskInstrumentationTest/inner_task_0').call_count
+    assert_equal 0, @agent.transaction_sampler.scope_depth, "existing unfinished sample"
+    sample = @agent.transaction_sampler.last_sample
+    assert_not_nil sample
+    assert_not_nil sample.params[:cpu_time], "cpu time nil: \n#{sample}"
+    assert sample.params[:cpu_time] >= 0, "cpu time: #{sample.params[:cpu_time]},\n#{sample}"
+    assert_equal '10', sample.params[:request_params][:level]
+  end
+  
+  def test_abort
+    @acct = 'Redrocks'
+    perform_action_with_newrelic_trace(:name => 'hello', :force => true, :params => { :account => @acct}) do
+      RAILS_DEFAULT_LOGGER.info "Hello world"
+      NewRelic::Agent.abort_transaction!
+    end
+    # We record the controller metric still, but abort any transaction recording.
+    assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/TaskInstrumentationTest/hello').call_count
+    assert_nil @agent.transaction_sampler.last_sample
+  end
+  
+  def test_block
+    assert_equal @agent, NewRelic::Agent.instance
+    @acct = 'Redrocks'
+    perform_action_with_newrelic_trace(:name => 'hello', :force => true, :params => { :account => @acct}) do
+      RAILS_DEFAULT_LOGGER.info "Hello world"
+    end
+    @agent.stats_engine.metrics.sort.each do |n|
+      stat = @agent.stats_engine.get_stats_no_scope(n)
+      #puts "#{'%-26s' % n}: #{stat.call_count} calls @ #{stat.average_call_time} sec/call"
+    end
+    assert_equal @agent, NewRelic::Agent.instance
+    assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/TaskInstrumentationTest/hello').call_count
+    sample = @agent.transaction_sampler.last_sample
+    assert_not_nil sample
+    assert_equal 'Redrocks', sample.params[:request_params][:account]
+    
+  end
+  
+  def test_error_handling
+    @agent.error_collector.ignore_error_filter
+    @agent.error_collector.harvest_errors([])
+    @agent.error_collector.expects(:notice_error).once
+    assert_equal @agent.error_collector, NewRelic::Agent.instance.error_collector
+    assert_raise RuntimeError do
+      run_task_exception
+    end
+  end
+  
+  def test_instrument_bg
+    run_background_job
+    stat_names = %w[OtherTransaction/Background/TaskInstrumentationTest/run_background_job
+                    OtherTransaction/Background/all
+                    OtherTransaction/all].sort
+                    
+    expected_but_missing = stat_names - @agent.stats_engine.metrics
+    assert_equal 0, expected_but_missing.size, @agent.stats_engine.metrics.map  { |n|
+      stat = @agent.stats_engine.get_stats_no_scope(n)
+      "#{'%-26s' % n}: #{stat.call_count} calls @ #{stat.average_call_time} sec/call"
+    }.join("\n  ") + "\nmissing: #{expected_but_missing.inspect}"
+    assert_equal 1, @agent.stats_engine.get_stats_no_scope('OtherTransaction/all').call_count
+    assert_equal 1, @agent.stats_engine.get_stats_no_scope('OtherTransaction/Background/all').call_count
+  end
+  private
+  
+  def run_task_inner(n)
+    sleep 0.1
+    return if n == 0
+    assert_equal 1, NewRelic::Agent::BusyCalculator.busy_count
+    run_task_inner(n-1)
+  end
+  
+  def run_task_outer(n=0)
+    assert_equal 1, NewRelic::Agent::BusyCalculator.busy_count
+    run_task_inner(n)
+    run_task_inner(n)
+  end
+  
+  def run_task_exception
+    assert_equal 1, NewRelic::Agent::BusyCalculator.busy_count
+    raise "This is an error"
+  end
+  
+  def run_background_job
+    "This is a background job"
+  end
+  
+  add_transaction_tracer :run_task_exception
+  add_transaction_tracer :run_task_inner, :name => 'inner_task_#{args[0]}'
+  add_transaction_tracer :run_task_outer, :name => 'outer_task', :params => '{ :level => args[0] }'
+  # Eventually we need th change this to :category => :task
+  add_transaction_tracer :run_background_job, :category => 'OtherTransaction/Background'
+end