sundawg_newrelic_rpm 3.5.8.1

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,184 @@
+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
+
+  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/stats_hash_test.rb

@@ -0,0 +1,93 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..', '..','test_helper'))
+
+class NewRelic::Agent::StatsHashTest < Test::Unit::TestCase
+  def setup
+    @hash = NewRelic::Agent::StatsHash.new
+  end
+
+  def test_creates_default_entries
+    stats = @hash['a/b/c/d']
+    assert_kind_of(NewRelic::Agent::Stats, stats)
+  end
+
+  def test_record_accpets_single_metric_spec
+    spec = NewRelic::MetricSpec.new('foo/bar')
+    stats = @hash[spec]
+    stats.expects(:record_data_point).with(42)
+    @hash.record(spec, 42)
+  end
+
+  def test_record_accepts_multiple_metric_specs
+    spec1 = NewRelic::MetricSpec.new('foo/bar', 'scope1')
+    spec2 = NewRelic::MetricSpec.new('foo/bar', 'scope2')
+    stats1 = @hash[spec1]
+    stats2 = @hash[spec2]
+    stats1.expects(:record_data_point).with(42)
+    stats2.expects(:record_data_point).with(42)
+    @hash.record([spec1, spec2], 42)
+  end
+
+  def test_record_accepts_single_metric_spec_with_block
+    spec = NewRelic::MetricSpec.new('foo')
+    stats = @hash[spec]
+    stats.expects(:do_stuff)
+    @hash.record(spec) do |s|
+      s.do_stuff
+    end
+  end
+
+  def test_record_accepts_multiple_metric_specs_with_block
+    specs = [
+      NewRelic::MetricSpec.new('foo'),
+      NewRelic::MetricSpec.new('bar')
+    ]
+    stats = specs.map { |spec| @hash[spec] }
+    stats.each { |stat| stat.expects(:do_stuff) }
+    @hash.record(specs) do |s|
+      s.do_stuff
+    end
+  end
+
+  def test_record_accepts_stats_value
+    spec = NewRelic::MetricSpec.new('foo')
+    other_stats = NewRelic::Agent::Stats.new
+    stats = @hash[spec]
+    stats.expects(:merge!).with(other_stats)
+    @hash.record(spec, other_stats)
+  end
+
+  def test_merge_merges
+    specs = [
+      NewRelic::MetricSpec.new('foo'),
+      NewRelic::MetricSpec.new('bar'),
+      NewRelic::MetricSpec.new('baz'),
+      NewRelic::MetricSpec.new('baz', 'a_scope')
+    ]
+
+    hash1 = NewRelic::Agent::StatsHash.new
+    hash1.record(specs[0], 1)
+    hash1.record(specs[1], 2)
+    hash1.record(specs[2], 3)
+
+    hash2 = NewRelic::Agent::StatsHash.new
+    hash2.record(specs[0], 1)
+    hash2.record(specs[1], 2)
+    hash2.record(specs[3], 3) # no scope
+
+    hash1.merge!(hash2)
+
+    assert_equal(4, hash1.keys.size)
+    assert_equal(2, hash1[specs[0]].call_count)
+    assert_equal(2, hash1[specs[1]].call_count)
+    assert_equal(1, hash1[specs[2]].call_count)
+    assert_equal(1, hash1[specs[3]].call_count)
+  end
+
+  def test_marshal_dump
+    hash = NewRelic::Agent::StatsHash.new()
+    hash.record('foo', 1)
+    hash.record('bar', 2)
+    copy = Marshal.load(Marshal.dump(hash))
+    assert_equal(hash, copy)
+  end
+end

data/test/new_relic/agent/stats_test.rb

@@ -0,0 +1,197 @@
+ENV['SKIP_RAILS'] = 'true'
+require File.expand_path(File.join(File.dirname(__FILE__),'..', '..', 'test_helper'))
+
+class NewRelic::Agent::StatsTest < Test::Unit::TestCase
+  def mock_plusequals(first, second, method, first_value, second_value)
+    first.expects(method).returns(first_value)
+    second.expects(method).returns(second_value)
+    first.expects("#{method}=".to_sym).with(first_value + second_value)
+  end
+
+  def test_update_totals
+    attrs = [:total_call_time, :total_exclusive_time, :sum_of_squares]
+    merged = setup_merge do |a, b|
+      attrs.each do |attr|
+        a.send("#{attr}=", 2)
+        b.send("#{attr}=", 3)
+      end
+    end
+    attrs.each do |attr|
+      assert_equal(5, merged.send(attr))
+    end
+  end
+
+  def setup_merge
+    a = NewRelic::Agent::Stats.new
+    b = NewRelic::Agent::Stats.new
+    a.reset
+    b.reset
+    yield a, b
+    a.merge(b)
+  end
+
+  def test_merge_expands_min_max_call_time
+    merged = setup_merge do |a, b|
+      a.call_count = 1
+      b.call_count = 1
+      a.min_call_time = 0.5
+      a.max_call_time = 3.0
+      b.min_call_time = 1.0
+      b.max_call_time = 4.0
+    end
+    assert_equal(0.5, merged.min_call_time)
+    assert_equal(4.0, merged.max_call_time)
+  end
+
+  def test_simple
+    stats = NewRelic::Agent::Stats.new
+    validate stats, 0, 0, 0, 0
+
+    assert_equal stats.call_count,0
+    stats.trace_call 10
+    stats.trace_call 20
+    stats.trace_call 30
+
+    validate stats, 3, (10+20+30), 10, 30
+  end
+
+  def test_to_s
+    s1 = NewRelic::Agent::Stats.new
+    s1.trace_call 10
+    assert_equal("[ 1 calls 10.0000s]", s1.to_s)
+  end
+
+  def test_apdex_recording
+    s = NewRelic::Agent::Stats.new
+
+    s.record_apdex_s
+    s.record_apdex_t
+
+    s.record_apdex_f
+    s.record_apdex_t
+
+    assert_equal(1, s.apdex_s)
+    assert_equal(1, s.apdex_f)
+    assert_equal(2, s.apdex_t)
+  end
+
+  def test_merge
+    s1 = NewRelic::Agent::Stats.new
+    s2 = NewRelic::Agent::Stats.new
+
+    s1.trace_call 10
+    s2.trace_call 20
+    s2.freeze
+
+    validate s2, 1, 20, 20, 20
+    s3 = s1.merge s2
+    validate s3, 2, (10+20), 10, 20
+    validate s1, 1, 10, 10, 10
+    validate s2, 1, 20, 20, 20
+
+    s1.merge! s2
+    validate s1, 2, (10+20), 10, 20
+    validate s2, 1, 20, 20, 20
+  end
+
+  def test_merge_with_exclusive
+    s1 = NewRelic::Agent::Stats.new
+
+    s2 = NewRelic::Agent::Stats.new
+
+    s1.trace_call 10, 5
+    s2.trace_call 20, 10
+    s2.freeze
+
+    validate s2, 1, 20, 20, 20, 10
+    s3 = s1.merge s2
+    validate s3, 2, (10+20), 10, 20, (10+5)
+    validate s1, 1, 10, 10, 10, 5
+    validate s2, 1, 20, 20, 20, 10
+
+    s1.merge! s2
+    validate s1, 2, (10+20), 10, 20, (5+10)
+    validate s2, 1, 20, 20, 20, 10
+  end
+
+  def test_merge_array
+    s1 = NewRelic::Agent::Stats.new
+    merges = []
+    merges << (NewRelic::Agent::Stats.new.trace_call 1)
+    merges << (NewRelic::Agent::Stats.new.trace_call 1)
+    merges << (NewRelic::Agent::Stats.new.trace_call 1)
+
+    s1.merge! merges
+    validate s1, 3, 3, 1, 1
+  end
+
+  def test_freeze
+    s1 = NewRelic::Agent::Stats.new
+
+    s1.trace_call 10
+    s1.freeze
+
+    begin
+      # the following should throw an exception because s1 is frozen
+      s1.trace_call 20
+      assert false
+    rescue StandardError
+      assert s1.frozen?
+      validate s1, 1, 10, 10, 10
+    end
+  end
+
+  def test_sum_of_squares_merge
+    s1 = NewRelic::Agent::Stats.new
+    s1.trace_call 4
+    s1.trace_call 7
+
+    s2 = NewRelic::Agent::Stats.new
+    s2.trace_call 13
+    s2.trace_call 16
+
+    s3 = s1.merge(s2)
+
+    assert_equal(s1.sum_of_squares, 4*4 + 7*7)
+    assert_equal(s3.sum_of_squares, 4*4 + 7*7 + 13*13 + 16*16, "check sum of squares")
+  end
+
+  def test_chained_stats_proxies_calls_to_scoped_and_unscoped
+    scoped_stats = NewRelic::Agent::Stats.new
+    unscoped_stats = NewRelic::Agent::Stats.new
+    chained_stats = NewRelic::Agent::ChainedStats.new(scoped_stats, unscoped_stats)
+    chained_stats.record_data_point(42)
+    assert_equal(1, scoped_stats.call_count)
+    assert_equal(1, unscoped_stats.call_count)
+    assert_equal(42, scoped_stats.total_call_time)
+    assert_equal(42, unscoped_stats.total_call_time)
+  end
+
+  def test_chained_stats_returns_values_from_scoped
+    scoped_stats = NewRelic::Agent::Stats.new
+    unscoped_stats = NewRelic::Agent::Stats.new
+    chained_stats = NewRelic::Agent::ChainedStats.new(scoped_stats, unscoped_stats)
+    scoped_stats.record_data_point(42)
+    assert_equal(1, chained_stats.call_count)
+    assert_equal(42, chained_stats.total_call_time)
+  end
+
+  if RUBY_VERSION >= '1.9'
+    def test_to_json_enforces_float_values
+      s1 = NewRelic::Agent::Stats.new
+      s1.trace_call 3.to_r
+      s1.trace_call 7.to_r
+
+      assert_equal 3.0, JSON.load(s1.to_json)['min_call_time']
+    end
+  end
+
+  private
+  def validate (stats, count, total, min, max, exclusive = nil)
+    assert_equal count, stats.call_count
+    assert_equal total, stats.total_call_time
+    assert_equal min,   stats.min_call_time
+    assert_equal max,   stats.max_call_time
+    assert_equal exclusive, stats.total_exclusive_time if exclusive
+  end
+end