onyx_newrelic_rpm 2.12.5

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

@@ -0,0 +1,72 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..', '..','..','test_helper'))
+require 'new_relic/agent/samplers/cpu_sampler'
+
+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
+    # need to sleep because if you go to fast it will skip the points
+    s.stats_engine = @stats_engine
+    sleep 2
+    s.poll
+    sleep 2
+    s.poll
+    assert_equal 2, s.systemtime_stats.call_count
+    assert_equal 2, s.usertime_stats.call_count
+    assert s.usertime_stats.total_call_time >= 0, "user cpu greater/equal to 0: #{s.usertime_stats.total_call_time}"
+    assert s.systemtime_stats.total_call_time >= 0, "system cpu greater/equal to 0: #{s.systemtime_stats.total_call_time}"
+  end
+  def test_memory__default
+    s = NewRelic::Agent::Samplers::MemorySampler.new
+    s.stats_engine = @stats_engine
+    s.poll
+    s.poll
+    s.poll
+    assert_equal 3, s.stats.call_count
+    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
+    s.poll
+    s.poll
+    s.poll
+    assert_equal 3, s.stats.call_count
+    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'
+    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 NewRelic::Agent::Sampler::Unsupported do
+      NewRelic::Agent::Samplers::MemorySampler.new
+    end
+  end
+  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/stats_engine_test.rb

@@ -0,0 +1,184 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..', 'test_helper')) 
+
+
+class NewRelic::Agent::StatsEngine::TransactionsTest < Test::Unit::TestCase
+  def setup
+    NewRelic::Agent.manual_start
+    @engine = NewRelic::Agent::StatsEngine.new 
+  rescue => e
+    puts e
+    puts e.backtrace.join("\n")
+  end
+  def teardown
+    @engine.harvest_timeslice_data({},{})
+  end
+  
+  def test_scope
+    @engine.push_scope "scope1"
+    assert @engine.peek_scope.name == "scope1"
+    
+    expected = @engine.push_scope "scope2"
+    @engine.pop_scope expected, 0
+    
+    scoped = @engine.get_stats "a"
+    scoped.trace_call 3
+    
+    assert scoped.total_call_time == 3
+    unscoped = @engine.get_stats "a"
+    
+    assert scoped == @engine.get_stats("a")
+    assert unscoped.total_call_time == 3
+  end
+  
+  def test_scope__overlap
+    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.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"
+    
+    assert_not_same orlando_disney, anaheim_disney
+    assert_not_equal orlando_disney, anaheim_disney
+    assert_equal 1, orlando_disney.call_count 
+    assert_equal 1, anaheim_disney.call_count
+    assert_same disney, orlando_disney.unscoped_stats
+    assert_same disney, anaheim_disney.unscoped_stats
+    assert_equal 2, disney.call_count
+    assert_equal disney.total_call_time, orlando_disney.total_call_time + anaheim_disney.total_call_time
+    
+  end
+  
+  def test_simplethrowcase(depth=0)
+    
+    fail "doh" if depth == 10
+    
+    scope = @engine.push_scope "scope#{depth}"    
+    
+    begin
+      test_simplethrowcase(depth+1)
+    rescue StandardError => e
+      if (depth != 0)
+        raise e
+      end
+    ensure
+      @engine.pop_scope scope, 0
+    end
+    
+    if depth == 0
+      assert @engine.peek_scope.nil?
+    end
+  end
+  
+  
+  def test_scope_failure
+    scope1 = @engine.push_scope "scope1"
+    @engine.push_scope "scope2"
+    
+    begin
+      @engine.pop_scope scope1
+      fail "Didn't throw when scope push/pop mismatched"
+    rescue
+      # success
+    end
+  end
+  
+  def test_children_time
+    t1 = Time.now
+    
+    expected1 = @engine.push_scope "a"
+    sleep 0.1
+    t2 = Time.now
+    
+    expected2 = @engine.push_scope "b"
+    sleep 0.2
+    t3 = Time.now
+    
+    expected = @engine.push_scope "c"
+    sleep 0.3
+    scope = @engine.pop_scope expected, Time.now - t3
+    
+    t4 = Time.now
+    
+    check_time_approximate 0, scope.children_time
+    check_time_approximate 0.3, @engine.peek_scope.children_time
+    
+    sleep 0.1
+    t5 = Time.now
+    
+    expected = @engine.push_scope "d"
+    sleep 0.2
+    scope = @engine.pop_scope expected, Time.now - t5
+    
+    t6 = Time.now
+    
+    check_time_approximate 0, scope.children_time
+    
+    scope = @engine.pop_scope expected2, Time.now - t2
+    assert_equal scope.name, 'b'
+    
+    check_time_approximate (t4 - t3) + (t6 - t5), scope.children_time
+    
+    scope = @engine.pop_scope expected1, Time.now - t1
+    assert_equal scope.name, 'a'
+    
+    check_time_approximate (t6 - t2), scope.children_time
+  end
+  
+  def test_simple_start_transaction
+    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 
+  
+  
+  # test for when the scope stack contains an element only used for tts and not metrics
+  def test_simple_tt_only_scope
+    scope1 = @engine.push_scope "a", 0, true
+    scope2 = @engine.push_scope "b", 10, false
+    scope3 = @engine.push_scope "c", 20, true
+    
+    @engine.pop_scope scope3, 10
+    @engine.pop_scope scope2, 10
+    @engine.pop_scope scope1, 10
+    
+    assert_equal 0, scope3.children_time
+    assert_equal 10, scope2.children_time
+    assert_equal 10, scope1.children_time 
+  end
+  
+  def test_double_tt_only_scope
+    scope1 = @engine.push_scope "a", 0, true
+    scope2 = @engine.push_scope "b", 10, false
+    scope3 = @engine.push_scope "c", 20, false
+    scope4 = @engine.push_scope "d", 30, true
+    
+    @engine.pop_scope scope4, 10
+    @engine.pop_scope scope3, 10
+    @engine.pop_scope scope2, 10
+    @engine.pop_scope scope1, 10
+    
+    assert_equal 0, scope4.children_time
+    assert_equal 10, scope3.children_time
+    assert_equal 10, scope2.children_time
+    assert_equal 10, scope1.children_time 
+  end
+  
+  
+  private 
+  def check_time_approximate(expected, 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,193 @@
+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_custom_params
+    @agent.error_collector.stubs(:enabled).returns(true)
+    @agent.error_collector.ignore_error_filter
+    @agent.error_collector.harvest_errors([])
+    assert_equal @agent.error_collector, NewRelic::Agent.instance.error_collector
+    assert_raise RuntimeError do
+      run_task_exception
+    end
+    errors = @agent.error_collector.harvest_errors([])
+    assert_equal 1, errors.size
+    error = errors.first
+    assert_equal "Controller/TaskInstrumentationTest/run_task_exception", error.path
+    assert_not_nil error.params[:stack_trace]
+    assert_not_nil error.params[:custom_params]
+  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
+    NewRelic::Agent.add_custom_parameters(:custom_one => 'one custom val')
+    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