wd_newrelic_rpm 3.5.6 → 3.5.8

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

@@ -1,6 +1,5 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
 
-
 class NewRelic::Agent::MetricStatsTest < Test::Unit::TestCase
   def setup
     NewRelic::Agent.manual_start
@@ -9,9 +8,9 @@ class NewRelic::Agent::MetricStatsTest < Test::Unit::TestCase
     puts e
     puts e.backtrace.join("\n")
   end
-  
+
   def teardown
-    @engine.harvest_timeslice_data({},{})
+    @engine.harvest_timeslice_data({})
     super
   end
 
@@ -25,7 +24,7 @@ class NewRelic::Agent::MetricStatsTest < Test::Unit::TestCase
     assert_not_nil s3
 
     assert s1 == s2
-    assert s1 != s3
+    assert_not_same(s1, s3)
   end
 
   def test_harvest
@@ -43,51 +42,139 @@ class NewRelic::Agent::MetricStatsTest < Test::Unit::TestCase
     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
+    harvested = @engine.harvest_timeslice_data({})
 
     # 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
+    spec_a = NewRelic::MetricSpec.new('a')
+    assert(harvested.has_key?(spec_a))
+    assert_equal(1, harvested[spec_a].call_count)
+    assert_equal(10, harvested[spec_a].total_call_time)
+  end
 
-    assert_equal 1, metric_data[0].stats.call_count
-    assert_equal 10, metric_data[0].stats.total_call_time
+  def test_harvest_timeslice_data_applies_metric_rename_rules
+    rule = NewRelic::Agent::RulesEngine::Rule.new(
+      'match_expression' => '[0-9]+',
+      'replacement'      => '*',
+      'replace_all'      => true
+    )
+    rules_engine = NewRelic::Agent::RulesEngine.new([rule])
+
+    @engine.get_stats_no_scope('Custom/foo/1/bar/22').record_data_point(1)
+    @engine.get_stats_no_scope('Custom/foo/3/bar/44').record_data_point(1)
+    @engine.get_stats_no_scope('Custom/foo/5/bar/66').record_data_point(1)
+
+    harvested = @engine.harvest_timeslice_data({}, rules_engine)
+
+    assert !harvested.has_key?(NewRelic::MetricSpec.new('Custom/foo/1/bar/22'))
+    assert !harvested.has_key?(NewRelic::MetricSpec.new('Custom/foo/3/bar/44'))
+    assert !harvested.has_key?(NewRelic::MetricSpec.new('Custom/foo/5/bar/66'))
+    merged = harvested[NewRelic::MetricSpec.new('Custom/foo/*/bar/*')]
+    assert_equal(3, merged.call_count)
   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({}, {})
+    harvest = @engine.harvest_timeslice_data({})
+
+    s = @engine.get_stats "a"
     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,
+    # this call 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
+    harvest = @engine.harvest_timeslice_data(harvest)
+    stats = harvest.fetch(NewRelic::MetricSpec.new("a"))
     assert_equal 2, stats.call_count
     assert_equal 3, stats.total_call_time
   end
 
-  def test_rescues_from_synchronization_failure_on_write
-    hash = NewRelic::Agent::StatsEngine::MetricStats::SynchronizedHash.new
-    10.times { |i| hash[i] = i }
+  def test_merge_merges
+    @engine.get_stats("foo").record_data_point(1)
+
+    other_stats_hash = NewRelic::Agent::StatsHash.new()
+    other_stats_hash.record(NewRelic::MetricSpec.new('foo'), 1)
+    other_stats_hash.record(NewRelic::MetricSpec.new('bar'), 1)
+
+    @engine.merge!(other_stats_hash)
+
+    foo_stats = @engine.get_stats('foo')
+    bar_stats = @engine.get_stats('bar')
+    assert_equal(2, foo_stats.call_count)
+    assert_equal(1, bar_stats.call_count)
+  end
+
+  def test_record_metric_unscoped_metrics_only_by_default
+    @engine.stubs(:default_scope).returns('scopey')
+    @engine.record_metric('foo', 42)
+    unscoped_stats = @engine.get_stats('foo', false)
+    scoped_stats = @engine.get_stats('foo', true, true, 'scopey')
+    assert_equal(1, unscoped_stats.call_count)
+    assert_equal(0, scoped_stats.call_count)
+  end
+
+  def test_record_metric_records_to_scoped_metric_if_requested
+    @engine.stubs(:default_scope).returns('scopey')
+    @engine.record_metric('foo', 42, :scoped => true)
+    unscoped_stats = @engine.get_stats('foo', false)
+    scoped_stats = @engine.get_stats('foo', true, true, 'scopey')
+    assert_equal(1, unscoped_stats.call_count)
+    assert_equal(1, scoped_stats.call_count)
+  end
 
-    assert_nothing_raised do
-      hash.each do |k, v|
-        hash[11] = 1
+  def test_record_metric_elides_scoped_metric_if_not_in_transaction
+    @engine.clear_stats
+    @engine.stubs(:default_scope).returns(nil)
+    @engine.record_metric('foo', 42, :scoped => true)
+    unscoped_stats = @engine.get_stats('foo', false)
+    assert_equal(1, unscoped_stats.call_count)
+    assert_equal(1, @engine.metrics.size)
+  end
+
+  def test_record_metric_accepts_explicit_scope
+    @engine.stubs(:default_scope).returns('scopey')
+    @engine.record_metric('foo', 42, :scoped => true, :scope => 'not scopey')
+    unscoped_stats = @engine.get_stats('foo', false)
+    scoped_stats_scopey = @engine.get_stats('foo', true, true, 'scopey')
+    scoped_stats_not_scopey = @engine.get_stats('foo', true, true, 'not scopey')
+    assert_equal(1, unscoped_stats.call_count)
+    assert_equal(0, scoped_stats_scopey.call_count)
+    assert_equal(1, scoped_stats_not_scopey.call_count)
+  end
+
+  def test_record_metric_accepts_block
+    @engine.record_metric('foo') do |stats|
+      stats.call_count = 999
+    end
+    stats = @engine.get_stats_no_scope('foo')
+    assert_equal(999, stats.call_count)
+  end
+
+  def test_record_metric_is_thread_safe
+    threads = []
+    nthreads = 25
+    iterations = 100
+    nthreads.times do |tid|
+      threads << Thread.new do
+        iterations.times do
+          @engine.record_metric('m1', 1)
+          @engine.record_metric('m2', 1)
+        end
       end
     end
+    threads.each { |t| t.join }
+
+    stats_m1 = @engine.get_stats_no_scope('m1')
+    stats_m2 = @engine.get_stats_no_scope('m2')
+    assert_equal(nthreads * iterations, stats_m1.call_count)
+    assert_equal(nthreads * iterations, stats_m2.call_count)
   end
 end
-

data/test/new_relic/agent/stats_engine_test.rb

@@ -11,7 +11,7 @@ class NewRelic::Agent::StatsEngineTest < Test::Unit::TestCase
   end
 
   def teardown
-    @engine.harvest_timeslice_data({},{})
+    @engine.harvest_timeslice_data({})
     mocha_teardown
     super
   end
@@ -177,51 +177,6 @@ class NewRelic::Agent::StatsEngineTest < Test::Unit::TestCase
     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)
-      ::GC::Profiler.stubs(:clear).returns(nil)
-    elsif NewRelic::LanguageSupport.using_version?('1.8.7') &&
-        RUBY_DESCRIPTION =~ /Ruby Enterprise Edition/
-      ::GC.stubs(:time).returns(1000000, 4000000)
-      ::GC.stubs(:collections).returns(1, 3)
-    else
-      return true # no need to test if we're not collecting GC metrics
-    end
-
-    engine = NewRelic::Agent.instance.stats_engine
-    tracer = NewRelic::Agent::TransactionSampler.new
-    tracer.instance_variable_set(:@last_sample,
-                                 NewRelic::TransactionSample.new)
-    engine.transaction_sampler = tracer
-    engine.start_transaction
-    scope = engine.push_scope "scope"
-    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
-    assert_equal(3.0, tracer.last_sample.params[:custom_params][:gc_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}")

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