honkster-newrelic_rpm 2.13.1

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,188 @@
+# Run faster standalone
+ENV['SKIP_RAILS'] = 'true'
+
+require File.expand_path('../../../test_helper', __FILE__) 
+
+class TaskInstrumentationTest < Test::Unit::TestCase
+  include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+  extend TestContexts
+  attr_accessor :agent
+  
+  with_running_agent do
+    
+    should "run" do
+      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
+    
+    should "run_recursive" do
+      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
+    
+    should "run_nested" do
+      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
+    
+    should "reentrancy" do
+      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
+    
+    should "transaction" do
+      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
+    
+    should "abort" do
+      @acct = 'Redrocks'
+      perform_action_with_newrelic_trace(:name => 'hello', :force => true, :params => { :account => @acct}) do
+        self.class.inspect
+        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
+    should "block" do
+      assert_equal @agent, NewRelic::Agent.instance
+      @acct = 'Redrocks'
+      perform_action_with_newrelic_trace(:name => 'hello', :force => true, :params => { :account => @acct}) do
+        self.class.inspect
+      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
+    
+    should "error_handling" do
+      @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
+    
+    should "custom_params" do
+      @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
+    
+    should "instrument_bg" do
+      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
+  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

data/test/new_relic/agent/testable_agent.rb

@@ -0,0 +1,13 @@
+
+##require 'new_relic/agent'
+
+
+RAILS_ROOT='.' if !defined? RAILS_ROOT
+
+
+class String
+  def titleize
+    self
+  end
+end
+

data/test/new_relic/agent/transaction_sample_builder_test.rb

@@ -0,0 +1,195 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+
+class NewRelic::Agent::TransationSampleBuilderTest < Test::Unit::TestCase
+  
+  def setup
+    @builder = NewRelic::Agent::TransactionSampleBuilder.new
+  end
+  
+  def test_build_sample
+    build_segment("a") do
+      build_segment("aa") do
+        build_segment("aaa")
+      end
+      build_segment("ab") do
+        build_segment("aba") do
+          build_segment("abaa")
+        end
+        build_segment("aba")
+        build_segment("abc") do
+          build_segment("abca")
+          build_segment("abcd")
+        end
+      end
+    end
+    build_segment "b"
+    build_segment "c" do
+      build_segment "ca" 
+      build_segment "cb" do
+        build_segment "cba"
+      end
+    end
+    
+    @builder.finish_trace(Time.now.to_f)
+    validate_builder
+  end
+  
+  def test_freeze
+    build_segment "a" do
+      build_segment "aa"
+    end
+    
+    begin 
+      builder.sample
+      assert false
+    rescue Exception => e
+      # expected
+    end
+    
+    @builder.finish_trace(Time.now.to_f)
+    
+    validate_builder
+    
+    begin
+      build_segment "b"
+      assert_false
+    rescue TypeError => e
+      # expected
+    end
+  end
+  
+  # this is really a test for transaction sample
+  def test_omit_segments_with
+    build_segment "Controller/my_controller/index" do
+      sleep 0.010
+      
+      build_segment "Rails/Application Code Loading" do
+        sleep 0.020
+        
+        build_segment "foo/bar" do
+          sleep 0.010
+        end
+      end
+      
+      build_segment "a" do
+        build_segment "ab"
+        sleep 0.010
+      end
+      build_segment "b" do
+        build_segment "ba"
+        sleep 0.05
+        build_segment "bb"
+        build_segment "bc" do
+          build_segment "bca"
+          sleep 0.05
+        end
+      end
+      build_segment "c"
+    end
+    @builder.finish_trace(Time.now.to_f)
+    
+    validate_builder false
+    
+    sample = @builder.sample
+    
+    should_be_a_copy = sample.omit_segments_with('OMIT NOTHING')
+    validate_segment should_be_a_copy.root_segment, false
+    
+    assert sample.to_s == should_be_a_copy.to_s
+    
+    without_code_loading = sample.omit_segments_with('Rails/Application Code Loading')
+    validate_segment without_code_loading.root_segment, false
+    
+    # after we take out code loading, the delta should be approximately
+    # 30 milliseconds
+    delta = (sample.duration - without_code_loading.duration) * 1000
+    
+    # Need to allow substantial headroom on the upper bound to prevent 
+    # spurious errors.
+    assert delta >= 28, "delta #{delta} should be between 28 and 100"
+    # disable this test for a couple days:
+    assert delta <= 100, "delta #{delta} should be between 28 and 100"
+    
+    # ensure none of the segments have this regex
+    without_code_loading.each_segment do |segment|
+      assert_nil segment.metric_name =~ /Rails\/Application Code Loading/
+    end
+  end
+  def test_unbalanced_handling
+    assert_raise RuntimeError do
+      build_segment("a") do
+        begin
+          build_segment("aa") do
+            build_segment("aaa") do
+              raise "a problem"
+            end
+          end
+          rescue; end
+      end
+    end
+  end
+  def test_marshal
+    build_segment "a" do
+      build_segment "ab"
+    end
+    build_segment "b" do
+      build_segment "ba"
+      build_segment "bb"
+      build_segment "bc" do
+        build_segment "bca"
+      end
+    end
+    build_segment "c"
+    
+    @builder.finish_trace(Time.now.to_f)
+    validate_builder
+    
+    dump = Marshal.dump @builder.sample
+    sample = Marshal.restore(dump)
+    validate_segment(sample.root_segment)
+  end
+  
+  def test_parallel_first_level_segments
+    build_segment "a" do
+      build_segment "ab"
+    end
+    build_segment "b"
+    build_segment "c"
+    
+    @builder.finish_trace(Time.now.to_f)
+    validate_builder
+  end
+  
+  def validate_builder(check_names = true)
+    validate_segment @builder.sample.root_segment, check_names
+  end
+  
+  def validate_segment(s, check_names = true)
+    p = s.parent_segment
+    
+    unless p.nil? || p.metric_name == 'ROOT'
+      assert p.called_segments.include?(s) 
+      assert_equal p.metric_name.length, s.metric_name.length - 1, "p: #{p.metric_name}, s: #{s.metric_name}" if check_names
+      assert p.metric_name < s.metric_name if check_names
+      assert p.entry_timestamp <= s.entry_timestamp
+    end
+    
+    assert s.exit_timestamp >= s.entry_timestamp
+    
+    children = s.called_segments
+    last_segment = s
+    children.each do |child|
+      assert child.metric_name > last_segment.metric_name if check_names
+      assert child.entry_timestamp >= last_segment.entry_timestamp
+      last_metric = child
+      
+      validate_segment(child, check_names)
+    end
+  end
+  
+  def build_segment(metric, time = 0, &proc)
+    @builder.trace_entry(metric, Time.now.to_f)
+    proc.call if proc
+    @builder.trace_exit(metric, Time.now.to_f)
+  end
+end