newrelic_rpm 3.12.0.288 → 9.10.2

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

@@ -1,347 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
-
-class NewRelic::Agent::MetricStatsTest < Minitest::Test
-  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.reset!
-    super
-  end
-
-  def test_record_unscoped_metrics_records_to_transaction_stats_if_in_txn
-    in_transaction do
-      @engine.tl_record_unscoped_metrics(['a', 'b'], 20, 10)
-
-      # txn is still active, so metrics should not be merged into global
-      # stats hash yet
-      assert_metrics_not_recorded(['a', 'b'])
-    end
-
-    expected = {
-      :call_count           => 1,
-      :total_call_time      => 20,
-      :total_exclusive_time => 10
-    }
-    assert_metrics_recorded(
-      'a' => expected,
-      'b' => expected
-    )
-  end
-
-  def test_record_unscoped_metrics_records_to_global_metrics_if_no_txn
-    @engine.tl_record_unscoped_metrics(['a', 'b'], 20, 10)
-    expected = {
-      :call_count           => 1,
-      :total_call_time      => 20,
-      :total_exclusive_time => 10
-    }
-    assert_metrics_recorded(
-      'a' => expected,
-      'b' => expected
-    )
-  end
-
-  def test_record_unscoped_metrics_takes_single_metric_name
-    @engine.tl_record_unscoped_metrics('a', 20)
-    assert_metrics_recorded(
-      'a' => {
-        :call_count           => 1,
-        :total_call_time      => 20,
-        :total_exclusive_time => 20
-      }
-    )
-  end
-
-  def test_record_unscoped_metrics_takes_block_in_txn
-    in_transaction('txn') do
-      @engine.tl_record_unscoped_metrics('a') do |stat|
-        stat.total_call_time = 42
-        stat.call_count = 99
-      end
-    end
-
-    expected = { :total_call_time => 42, :call_count => 99 }
-    assert_metrics_recorded('a' => expected)
-  end
-
-  def test_record_unscoped_metrics_takes_block_outside_txn
-    @engine.tl_record_unscoped_metrics('a') do |stat|
-      stat.total_call_time = 42
-      stat.call_count = 99
-    end
-
-    expected = { :total_call_time => 42, :call_count => 99 }
-    assert_metrics_recorded('a' => expected)
-  end
-
-  def test_record_unscoped_metrics_is_thread_safe
-    threads = []
-    nthreads = 25
-    iterations = 100
-
-    nthreads.times do |tid|
-      threads << Thread.new do
-        iterations.times do
-          @engine.tl_record_unscoped_metrics('m1', 1)
-          @engine.tl_record_unscoped_metrics('m2', 1)
-        end
-      end
-    end
-    threads.each { |t| t.join }
-
-    assert_metrics_recorded(
-      'm1' => { :call_count => nthreads * iterations },
-      'm2' => { :call_count => nthreads * iterations }
-    )
-  end
-
-  def test_record_scoped_and_unscoped_metrics_records_scoped_and_unscoped
-    in_transaction('txn') do
-      @engine.tl_record_scoped_and_unscoped_metrics('a', nil, 20, 10)
-      assert_metrics_not_recorded('a')
-    end
-
-    expected = {
-      :call_count           => 1,
-      :total_call_time      => 20,
-      :total_exclusive_time => 10
-    }
-    assert_metrics_recorded(
-      'a'          => expected,
-      ['a', 'txn'] => expected
-    )
-  end
-
-  def test_record_scoped_and_unscoped_metrics_takes_block
-    in_transaction('txn') do
-      @engine.tl_record_scoped_and_unscoped_metrics('a', ['b']) do |stat|
-        stat.total_call_time = 42
-        stat.call_count = 99
-      end
-    end
-
-    expected = { :total_call_time => 42, :call_count => 99 }
-    assert_metrics_recorded(
-      'a'          => expected,
-      ['a', 'txn'] => expected,
-      'b'          => expected
-    )
-  end
-
-  def test_record_scoped_and_unscoped_metrics_records_multiple_unscoped_metrics
-    in_transaction('txn') do
-      @engine.tl_record_scoped_and_unscoped_metrics('a', ['b', 'c'], 20, 10)
-      assert_metrics_not_recorded(['a', 'b', 'c'])
-    end
-
-    expected = {
-      :call_count           => 1,
-      :total_call_time      => 20,
-      :total_exclusive_time => 10
-    }
-    assert_metrics_recorded(
-      'a'          => expected,
-      ['a', 'txn'] => expected,
-      'b'          => expected,
-      'c'          => expected
-    )
-    assert_metrics_not_recorded([
-      ['b', 'txn'],
-      ['c', 'txn']
-    ])
-  end
-
-  def test_record_scoped_and_unscoped_metrics_is_thread_safe
-    threads = []
-    nthreads = 25
-    iterations = 100
-
-    nthreads.times do |tid|
-      threads << Thread.new do
-        iterations.times do
-          in_transaction('txn') do
-            @engine.tl_record_scoped_and_unscoped_metrics('m1', ['m3'], 1)
-            @engine.tl_record_scoped_and_unscoped_metrics('m2', ['m4'], 1)
-          end
-        end
-      end
-    end
-    threads.each { |t| t.join }
-
-    expected = { :call_count => nthreads * iterations }
-    assert_metrics_recorded(
-      'm1'          => expected,
-      'm2'          => expected,
-      ['m1', 'txn'] => expected,
-      ['m2', 'txn'] => expected,
-      'm3'          => expected,
-      'm4'          => expected
-    )
-  end
-
-  def test_record_scoped_and_unscoped_metrics_records_unscoped_if_not_in_txn
-    @engine.tl_record_scoped_and_unscoped_metrics('a', ['b'], 20, 10)
-
-    expected = {
-      :call_count           => 1,
-      :total_call_time      => 20,
-      :total_exclusive_time => 10
-    }
-    assert_metrics_recorded_exclusive(
-      'a' => expected,
-      'b' => expected
-    )
-  end
-
-  def test_get_no_scope
-    s1 = @engine.get_stats "a"
-    s2 = @engine.get_stats "a"
-    s3 = @engine.get_stats "b"
-
-    refute_nil s1
-    refute_nil s2
-    refute_nil s3
-
-    assert s1 == s2
-    refute_same(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
-
-    harvested = @engine.harvest!.to_h
-
-    # 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
-
-    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
-
-  def test_harvest_applies_metric_rename_rules
-    rule = NewRelic::Agent::RulesEngine::ReplacementRule.new(
-      'match_expression' => '[0-9]+',
-      'replacement'      => '*',
-      'replace_all'      => true
-    )
-    rules_engine = NewRelic::Agent::RulesEngine.new([rule])
-
-    @engine.metric_rules = rules_engine
-    @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!.to_h
-
-    refute harvested.has_key?(NewRelic::MetricSpec.new('Custom/foo/1/bar/22'))
-    refute harvested.has_key?(NewRelic::MetricSpec.new('Custom/foo/3/bar/44'))
-    refute 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_apply_rules_to_metric_data_respects_ignore_rules
-    rule = NewRelic::Agent::RulesEngine::ReplacementRule.new(
-      'match_expression' => 'bar',
-      'ignore'           => 'true'
-    )
-    rules_engine = NewRelic::Agent::RulesEngine.new([rule])
-
-    stats_hash = NewRelic::Agent::StatsHash.new
-
-    stats_hash.record(NewRelic::MetricSpec.new('foo'), 90210)
-    stats_hash.record(NewRelic::MetricSpec.new('bar'), 90210)
-
-    renamed = @engine.apply_rules_to_metric_data(rules_engine, stats_hash)
-
-    assert_equal(1    , renamed.size)
-    assert_equal('foo', renamed.to_h.keys.first.name)
-  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!
-
-    s = @engine.get_stats "a"
-    assert_equal 0, s.call_count
-    s.trace_call 2
-    assert_equal 1, s.call_count
-
-    # this should merge the contents of the previous harvest,
-    # so the stats for metric "a" should have 2 data points
-    @engine.merge!(harvest)
-    harvest = @engine.harvest!
-    stats = harvest[NewRelic::MetricSpec.new("a")]
-    assert_equal 2, stats.call_count
-    assert_equal 3, stats.total_call_time
-  end
-
-  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_harvest_adds_harvested_at_time
-    t0 = freeze_time
-    result = @engine.harvest!
-    assert_equal(t0, result.harvested_at)
-  end
-
-  def test_record_unscoped_metrics_unscoped_metrics_only
-    in_transaction('scopey') do
-      @engine.tl_record_unscoped_metrics('foo', 42)
-    end
-    assert_metrics_recorded('foo' => { :call_count => 1, :total_call_time => 42 })
-    assert_metrics_not_recorded([['foo', 'scopey']])
-  end
-
-  def test_record_supportability_metric_count_records_counts_only
-    @engine.tl_record_supportability_metric_count('foo/bar',  1)
-    @engine.tl_record_supportability_metric_count('foo/bar', 42)
-    assert_metrics_recorded(['Supportability/foo/bar'] => {
-      :call_count => 42,
-      :total_call_time => 0
-    })
-  end
-end

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

@@ -1,98 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require File.expand_path(File.join(File.dirname(__FILE__),'..', '..','..','test_helper'))
-require 'new_relic/agent/samplers/cpu_sampler'
-
-class NewRelic::Agent::StatsEngine::SamplersTest < Minitest::Test
-
-  class OurSamplers
-    include NewRelic::Agent::StatsEngine::Samplers
-  end
-
-  class OurSampler
-    attr_accessor :id, :stats_engine
-  end
-
-  def setup
-    @stats_engine = NewRelic::Agent::StatsEngine.new
-    NewRelic::Agent.instance.stubs(:stats_engine).returns(@stats_engine)
-  end
-
-  def test_cpu_sampler_records_user_and_system_time
-    timeinfo0 = mock
-    timeinfo0.stubs(:utime).returns(10.0)
-    timeinfo0.stubs(:stime).returns(5.0)
-
-    timeinfo1 = mock
-    timeinfo1.stubs(:utime).returns(14.0) # +5s
-    timeinfo1.stubs(:stime).returns(7.0)  # +2s
-
-    elapsed = 10
-
-    freeze_time
-    Process.stubs(:times).returns(timeinfo0, timeinfo1)
-    NewRelic::Agent::SystemInfo.stubs(:num_logical_processors).returns(4)
-
-    s = NewRelic::Agent::Samplers::CpuSampler.new # this calls poll
-    advance_time(elapsed)
-    s.poll
-
-    assert_metrics_recorded({
-      'CPU/User Time'   => { :call_count => 1, :total_call_time => 4.0 },
-      'CPU/System Time' => { :call_count => 1, :total_call_time => 2.0 },
-      # (4s user time)   / ((10s elapsed time) * 4 cpus) = 0.1
-      'CPU/User/Utilization'   => { :call_count => 1, :total_call_time => 0.1 },
-      # (2s system time) / ((10s elapsed time) * 4 cpus) = 0.05
-      'CPU/System/Utilization' => { :call_count => 1, :total_call_time => 0.05 }
-    })
-  end
-
-  def test_memory__default
-    s = NewRelic::Agent::Samplers::MemorySampler.new
-    s.poll
-    s.poll
-    s.poll
-    stats = @stats_engine.get_stats_no_scope("Memory/Physical")
-    assert_equal(3, stats.call_count)
-    assert stats.total_call_time > 0.5, "cpu greater than 0.5 ms: #{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.poll
-    s.poll
-    s.poll
-    stats = @stats_engine.get_stats_no_scope("Memory/Physical")
-    assert_equal 3, stats.call_count
-    assert stats.total_call_time > 0.5, "cpu greater than 0.5 ms: #{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.poll
-    stats = @stats_engine.get_stats_no_scope("Memory/Physical")
-    assert_equal 1, stats.call_count
-    assert_equal 999, stats.total_call_time
-  end
-
-  def test_memory__windows
-    return if defined? JRuby
-    NewRelic::Agent::Samplers::MemorySampler.any_instance.stubs(:platform).returns 'win32'
-    assert_raises NewRelic::Agent::Sampler::Unsupported do
-      NewRelic::Agent::Samplers::MemorySampler.new
-    end
-  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_hash_test.rb

@@ -1,198 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..','test_helper'))
-
-class NewRelic::Agent::StatsHashTest < Minitest::Test
-  def setup
-    @hash = NewRelic::Agent::StatsHash.new
-    NewRelic::Agent.instance.error_collector.errors.clear
-  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, 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, 42)
-    stats2.expects(:record_data_point).with(42, 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_record_accepts_exclusive_time_with_numeric
-    spec = NewRelic::MetricSpec.new('foo')
-    stats = @hash[spec]
-    stats.expects(:record_data_point).with(42, 10)
-    @hash.record(spec, 42, 10)
-  end
-
-  def test_record_accepts_apdex_t_with_symbol
-    spec = NewRelic::MetricSpec.new('foo')
-    apdex_t = 99
-    1.times { @hash.record(spec, :apdex_s, apdex_t) }
-    2.times { @hash.record(spec, :apdex_t, apdex_t) }
-    3.times { @hash.record(spec, :apdex_f, apdex_t) }
-    stats = @hash[spec]
-    assert_equal(1, stats.apdex_s)
-    assert_equal(2, stats.apdex_t)
-    assert_equal(3, stats.apdex_f)
-    assert_equal(99, stats.min_call_time)
-    assert_equal(99, stats.max_call_time)
-  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)
-
-    hash1.merge!(hash2)
-
-    assert_equal(4, hash1.to_h.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_merge_re_sets_started_at_if_needed
-    t0 = Time.at(0)
-    t1 = Time.at(100)
-
-    hash0 = NewRelic::Agent::StatsHash.new(t0)
-    hash1 = NewRelic::Agent::StatsHash.new(t1)
-
-    hash1.merge!(hash0)
-    assert_equal(t0.to_f, hash1.started_at)
-  end
-
-  def test_merge_transaction_metrics
-    specs = [
-      NewRelic::MetricSpec.new('foo'),
-      NewRelic::MetricSpec.new('bar'),
-      NewRelic::MetricSpec.new('baz'),
-      NewRelic::MetricSpec.new('baz', 'a_scope')
-    ]
-
-    hash = NewRelic::Agent::StatsHash.new
-    hash.record(specs[0], 1)
-    hash.record(specs[1], 2)
-    hash.record(specs[2], 3)
-
-    txn_metrics = NewRelic::Agent::TransactionMetrics.new
-    txn_metrics.record_unscoped(specs[0].name, 1)
-    txn_metrics.record_unscoped(specs[1].name, 2)
-    txn_metrics.record_scoped(specs[3].name, 3)
-
-    hash.merge_transaction_metrics!(txn_metrics, 'a_scope')
-
-    assert_equal(4, hash.to_h.keys.size)
-    assert_equal(2, hash[specs[0]].call_count)
-    assert_equal(2, hash[specs[1]].call_count)
-    assert_equal(1, hash[specs[2]].call_count)
-    assert_equal(1, hash[specs[3]].call_count)
-  end
-
-  def test_marshal_dump
-    @hash.record('foo', 1)
-    @hash.record('bar', 2)
-    copy = Marshal.load(Marshal.dump(@hash))
-    assert_equal(@hash, copy)
-    assert_equal(@hash.started_at, copy.started_at)
-  end
-
-  def test_borked_default_proc_can_record_metric
-    fake_borked_default_proc(@hash)
-
-    @hash.record(DEFAULT_SPEC, 1)
-
-    assert_equal(1, @hash.fetch(DEFAULT_SPEC, nil).call_count)
-  end
-
-  def test_borked_default_proc_notices_agent_error
-    fake_borked_default_proc(@hash)
-
-    @hash.record(DEFAULT_SPEC, 1)
-
-    assert_has_error NewRelic::Agent::StatsHash::StatsHashLookupError
-  end
-
-  # We can only fix up the default proc on Rubies that let us set it
-  if {}.respond_to?(:default_proc=)
-    def test_borked_default_proc_heals_thyself
-      fake_borked_default_proc(@hash)
-
-      @hash.record(DEFAULT_SPEC, 1)
-      NewRelic::Agent.instance.error_collector.errors.clear
-
-      @hash.record(NewRelic::MetricSpec.new('something/else/entirely'), 1)
-      assert_equal 0, NewRelic::Agent.instance.error_collector.errors.size
-    end
-  end
-
-  DEFAULT_SPEC = NewRelic::MetricSpec.new('foo')
-
-  def fake_borked_default_proc(hash)
-    exception = NoMethodError.new("borked default proc gives a NoMethodError on `yield'")
-    if hash.respond_to?(:default_proc=)
-      hash.default_proc = Proc.new { raise exception }
-    else
-      hash.stubs(:[]).raises(exception)
-    end
-  end
-
-end

data/test/new_relic/agent/stats_engine_test.rb

@@ -1,32 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..', 'test_helper'))
-require File.expand_path(File.join(File.dirname(__FILE__),'..','data_container_tests'))
-
-class NewRelic::Agent::StatsEngineTest < Minitest::Test
-  def setup
-    @engine = NewRelic::Agent::StatsEngine.new
-  end
-
-  def teardown
-    @engine.reset!
-    super
-  end
-
-  # Helpers for DataContainerTests
-
-  def create_container
-    NewRelic::Agent::StatsEngine.new
-  end
-
-  def populate_container(engine, n)
-    n.times do |i|
-      engine.tl_record_unscoped_metrics("metric#{i}", i)
-    end
-  end
-
-  include NewRelic::DataContainerTests
-
-end