wd_newrelic_rpm 3.3.4.1

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

@@ -0,0 +1,82 @@
+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({},{})
+    super
+  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
+    @engine.clear_stats
+    s1 = @engine.get_stats "a"
+    s2 = @engine.get_stats "c"
+
+    s1.trace_call 10
+    s2.trace_call 1
+    s2.trace_call 3
+
+    assert_equal 1, @engine.get_stats("a").call_count
+    assert_equal 10, @engine.get_stats("a").total_call_time
+
+    assert_equal 2, @engine.get_stats("c").call_count
+    assert_equal 4, @engine.get_stats("c").total_call_time
+
+    metric_data = @engine.harvest_timeslice_data({}, {}).values
+    
+    # after harvest, all the metrics should be reset
+    assert_equal 0, @engine.get_stats("a").call_count
+    assert_equal 0, @engine.get_stats("a").total_call_time
+
+    assert_equal 0, @engine.get_stats("c").call_count
+    assert_equal 0, @engine.get_stats("c").total_call_time
+
+    metric_data = metric_data.reverse if metric_data[0].metric_spec.name != "a"
+
+    assert_equal 'a', metric_data[0].metric_spec.name
+
+    assert_equal 1, metric_data[0].stats.call_count
+    assert_equal 10, metric_data[0].stats.total_call_time
+  end
+
+  def test_harvest_with_merge
+    s = @engine.get_stats "a"
+    s.trace_call 1
+
+    assert_equal 1, @engine.get_stats("a").call_count
+
+    harvest = @engine.harvest_timeslice_data({}, {})
+    assert_equal 0, s.call_count
+    s.trace_call 2
+    assert_equal 1, s.call_count
+
+    # 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_equal 2, stats.call_count
+    assert_equal 3, stats.total_call_time
+  end
+end
+

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

@@ -0,0 +1,99 @@
+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
+
+  class TestObject
+    include NewRelic::Agent::StatsEngine::Samplers
+  end
+
+  def setup
+    @stats_engine = NewRelic::Agent::StatsEngine.new
+    NewRelic::Agent.instance.stubs(:stats_engine).returns(@stats_engine)
+  end
+
+  def test_add_sampler_to_positive
+    object = TestObject.new
+    sampler = mock('sampler')
+    sampler_array = mock('sampler_array')
+    sampler_array.expects(:include?).with(sampler).returns(false)
+    sampler_array.expects(:<<).with(sampler)
+    sampler.expects(:stats_engine=).with(object)
+
+    object.send(:add_sampler_to, sampler_array, sampler)
+  end
+
+  def test_add_sampler_to_negative
+    object = TestObject.new
+    sampler = mock('sampler')
+    sampler_array = mock('sampler_array')
+    sampler_array.expects(:include?).with(sampler).returns(true)
+    assert_raise(RuntimeError) do
+      object.send(:add_sampler_to, sampler_array, sampler)
+    end
+  end
+
+  def test_cpu
+    s = NewRelic::Agent::Samplers::CpuSampler.new
+    # need to set this instance value to prevent it skipping a 'too
+    # fast' poll time
+    s.stats_engine = @stats_engine
+    s.instance_eval { @last_time = Time.now - 1.1 }
+    s.poll
+    s.instance_eval { @last_time = Time.now - 1.1 }
+    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).at_least_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

@@ -0,0 +1,220 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..', 'test_helper'))
+
+
+class NewRelic::Agent::StatsEngineTest < 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({},{})
+    mocha_teardown
+    super
+  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.001
+    t2 = Time.now
+
+    expected2 = @engine.push_scope "b"
+    sleep 0.002
+    t3 = Time.now
+
+    expected = @engine.push_scope "c"
+    sleep 0.003
+    scope = @engine.pop_scope expected, Time.now - t3
+
+    t4 = Time.now
+
+    check_time_approximate 0, scope.children_time
+    check_time_approximate 0.003, @engine.peek_scope.children_time
+
+    sleep 0.001
+    t5 = Time.now
+
+    expected = @engine.push_scope "d"
+    sleep 0.002
+    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.round
+    assert_equal 10, scope3.children_time.round
+    assert_equal 10, scope2.children_time.round
+    assert_equal 10, scope1.children_time.round
+  end
+
+
+  def test_collect_gc_data
+    GC.disable unless NewRelic::LanguageSupport.using_engine?('jruby')
+    if NewRelic::LanguageSupport.using_engine?('rbx')
+      agent = ::Rubinius::Agent.loopback
+      agent.stubs(:get).with('system.gc.young.total_wallclock') \
+        .returns([:value, 1000], [:value, 2500])
+      agent.stubs(:get).with('system.gc.full.total_wallclock') \
+        .returns([:value, 2000], [:value, 3500])
+      agent.stubs(:get).with('system.gc.young.count') \
+        .returns([:value, 1], [:value, 2])
+      agent.stubs(:get).with('system.gc.full.count') \
+        .returns([:value, 1], [:value, 2])
+      ::Rubinius::Agent.stubs(:loopback).returns(agent)
+    elsif NewRelic::LanguageSupport.using_version?('1.9')
+      ::GC::Profiler.stubs(:enabled?).returns(true)
+      ::GC::Profiler.stubs(:total_time).returns(1.0, 4.0) 
+      ::GC.stubs(:count).returns(1, 3)      
+    elsif NewRelic::LanguageSupport.using_version?('1.8')
+      ::GC.stubs(:time).returns(1000000, 4000000)
+      ::GC.stubs(:collections).returns(1, 3)
+    end
+    
+    engine = NewRelic::Agent.instance.stats_engine
+    scope = engine.push_scope "scope"
+    engine.start_transaction
+    engine.pop_scope scope, 0.01
+    engine.end_transaction
+    
+    gc_stats = engine.get_stats('GC/cumulative')
+    assert_equal 2, gc_stats.call_count
+    assert_equal 3.0, gc_stats.total_call_time
+  ensure
+    GC.enable unless NewRelic::LanguageSupport.using_engine?('jruby')
+  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/transaction_info_test.rb

@@ -0,0 +1,13 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+require 'ostruct'
+
+class NewRelic::Agent::TransactionInfoTest < Test::Unit::TestCase
+  def setup
+    @request = OpenStruct.new(:cookies => {'NRAGENT' => 'tk=1234<tag>evil</tag>5678'})
+  end
+  
+  def test_get_token_gets_sanitized_token_from_cookie
+    assert_equal('1234&lt;tag&gt;evil&lt;/tag&gt;5678',
+                 NewRelic::Agent::TransactionInfo.get_token(@request))
+  end
+end

data/test/new_relic/agent/transaction_sample_builder_test.rb

@@ -0,0 +1,219 @@
+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
+
+  # if it doesn't the core app tests will break.  Not strictly necessary but
+  # we'll enforce it with this test for now.
+  def test_trace_entry_returns_segment
+    segment = @builder.trace_entry("/Foo/Bar", Time.now)
+    assert segment, "Segment should not be nil"
+    assert segment.is_a?(NewRelic::TransactionSample::Segment), "Segment should not be a #{segment.class.name}"
+  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 => 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_equal sample.params, should_be_a_copy.params
+    assert_equal(sample.root_segment.to_debug_str(0),
+                 should_be_a_copy.root_segment.to_debug_str(0))
+
+    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 test_trace_should_not_record_more_than_segment_limit
+    @builder.segment_limit = 3
+    8.times {|i| build_segment i.to_s }
+    assert_equal 3, @builder.sample.count_segments
+  end
+
+  # regression
+  def test_trace_should_log_segment_reached_once
+    @builder.segment_limit = 3
+    NewRelic::Control.instance.log.expects(:debug).once
+    8.times {|i| build_segment i.to_s }
+  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