newrelic_rpm 4.0.0.332 → 6.13.1

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

@@ -1,176 +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::StatsEngine
-  class GCProfilerTest < Minitest::Test
-    def setup
-      NewRelic::Agent.drop_buffered_data
-
-      stub_gc_profiling_enabled
-      GCProfiler.reset
-    end
-
-    def teardown
-      NewRelic::Agent.drop_buffered_data
-      GCProfiler.reset
-    end
-
-    def test_init_profiler_for_rails_bench
-      return unless defined?(::GC) && ::GC.respond_to?(:collections)
-
-      ::GC.stubs(:time)
-      ::GC.stubs(:collections)
-
-      assert_equal(GCProfiler::RailsBenchProfiler,
-                   GCProfiler.init.class)
-    end
-
-    def test_init_profiler_for_ruby_19_and_greater
-      return unless defined?(::GC::Profiler)
-      return if NewRelic::LanguageSupport.jruby?
-
-      ::GC::Profiler.stubs(:enabled?).returns(true)
-
-      assert_equal(GCProfiler::CoreGCProfiler,
-                   GCProfiler.init.class)
-    end
-
-    def test_record_delta_returns_nil_when_snapshots_are_nil
-      result = GCProfiler.record_delta(nil, nil)
-      assert_nil(result)
-      assert_metrics_not_recorded([GCProfiler::GC_ROLLUP, GCProfiler::GC_WEB, GCProfiler::GC_OTHER])
-    end
-
-    # Only run these tests in environments where GCProfiler is usable
-    if !NewRelic::LanguageSupport.jruby?
-      def test_record_delta_returns_delta_in_seconds
-        GCProfiler.init
-
-        start_snapshot = GCProfiler::GCSnapshot.new(1.0, 1)
-        end_snapshot   = GCProfiler::GCSnapshot.new(2.5, 3)
-
-        result = GCProfiler.record_delta(start_snapshot, end_snapshot)
-        assert_equal(1.5, result)
-      end
-
-      def test_record_delta_records_gc_time_and_call_count_in_metric
-        GCProfiler.init
-        start_snapshot = GCProfiler::GCSnapshot.new(1.0, 1)
-        end_snapshot   = GCProfiler::GCSnapshot.new(2.5, 3)
-
-        GCProfiler.record_delta(start_snapshot, end_snapshot)
-
-        assert_gc_metrics(GCProfiler::GC_OTHER,
-                          :call_count => 2, :total_call_time => 1.5)
-      end
-
-      # This test is asserting that the implementation of GC::Profiler provided by
-      # the language implementation currently in use behaves in the way we assume.
-      # Specifically, we expect that GC::Profiler.clear will *not* reset GC.count.
-      def test_gc_profiler_clear_does_not_reset_count
-        return unless defined?(::GC::Profiler)
-
-        GC::Profiler.enable
-
-        count_before_allocations = GC.count
-        100000.times { String.new }
-        GC.start
-        count_after_allocations = GC.count
-        GC::Profiler.clear
-        count_after_clear = GC.count
-
-        assert_operator count_before_allocations, :<=, count_after_allocations
-        assert_operator count_after_allocations,  :<=, count_after_clear
-      ensure
-        GC::Profiler.disable if defined?(::GC::Profiler)
-      end
-
-      def test_take_snapshot_should_return_snapshot
-        stub_gc_timer(5.0)
-        stub_gc_count(10)
-
-        snapshot = GCProfiler.take_snapshot
-
-        assert_equal(5.0, snapshot.gc_time_s)
-        assert_equal(10,  snapshot.gc_call_count)
-      end
-
-      def test_collect_gc_data
-        stub_gc_timer(1.0)
-        stub_gc_count(1)
-
-        with_config(:'transaction_tracer.enabled' => true) do
-          in_transaction do
-            stub_gc_timer(4.0)
-            stub_gc_count(3)
-          end
-        end
-
-        assert_gc_metrics(GCProfiler::GC_OTHER,
-                          :call_count => 2, :total_call_time => 3.0)
-        assert_metrics_not_recorded(GCProfiler::GC_WEB)
-
-        tracer = NewRelic::Agent.instance.transaction_sampler
-        assert_equal(3.0, attributes_for(tracer.last_sample, :intrinsic)[:gc_time])
-      end
-
-      def test_collect_gc_data_web
-        stub_gc_timer(1.0)
-        stub_gc_count(1)
-
-        with_config(:'transaction_tracer.enabled' => true) do
-          in_web_transaction do
-            stub_gc_timer(4.0)
-            stub_gc_count(3)
-          end
-        end
-
-        assert_gc_metrics(GCProfiler::GC_WEB,
-                          :call_count => 2, :total_call_time => 3.0)
-        assert_metrics_not_recorded(GCProfiler::GC_OTHER)
-      end
-    end
-
-    def assert_gc_metrics(name, expected_values={})
-      assert_metrics_recorded(
-        [GCProfiler::GC_ROLLUP, ''] => expected_values,
-        name => expected_values
-      )
-      assert_metrics_not_recorded([[GCProfiler::GC_ROLLUP, 'dummy']])
-    end
-
-    # gc_timer_value should be specified in seconds
-    def stub_gc_timer(gc_timer_value_s)
-      profiler = GCProfiler.init
-
-      gc_timer_value_us = gc_timer_value_s * 1_000_000
-
-      case profiler
-      when GCProfiler::CoreGCProfiler
-        NewRelic::Agent.instance.monotonic_gc_profiler.stubs(:total_time_s).returns(gc_timer_value_s)
-      when GCProfiler::RailsBenchProfiler
-        ::GC.stubs(:time).returns(gc_timer_value_us)
-      end
-    end
-
-    def stub_gc_count(gc_count)
-      profiler = GCProfiler.init
-
-      case profiler
-      when GCProfiler::CoreGCProfiler
-        ::GC.stubs(:count).returns(gc_count)
-      when GCProfiler::RailsBenchProfiler
-        ::GC.stubs(:collections).returns(gc_count)
-      end
-    end
-
-    def stub_gc_profiling_enabled
-      if defined?(::GC::Profiler)
-        ::GC::Profiler.stubs(:enabled?).returns(true)
-      end
-    end
-  end
-end

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

@@ -1,328 +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!
-    NewRelic::Agent.shutdown
-    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_harvest
-    @engine.clear_stats
-
-    @engine.tl_record_unscoped_metrics "a", 10
-    @engine.tl_record_unscoped_metrics "c", 1
-    @engine.tl_record_unscoped_metrics "c", 3
-
-    assert_metrics_recorded({
-      "a" => {:call_count => 1, :total_call_time => 10},
-      "c" => {:call_count => 2, :total_call_time => 4}
-    })
-
-    harvested = @engine.harvest!.to_h
-
-    # after harvest, all the metrics should be reset
-    refute_metrics_recorded %w(a c)
-
-    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.tl_record_unscoped_metrics('Custom/foo/1/bar/22', 1)
-    @engine.tl_record_unscoped_metrics('Custom/foo/3/bar/44', 1)
-    @engine.tl_record_unscoped_metrics('Custom/foo/5/bar/66', 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
-    @engine.tl_record_unscoped_metrics "a", 1
-    assert_metrics_recorded "a" => {:call_count => 1, :total_call_time => 1}
-
-    harvest = @engine.harvest!
-
-    assert_metrics_not_recorded "a"
-
-    @engine.tl_record_unscoped_metrics "a", 2
-    assert_metrics_recorded "a" => {:call_count => 1, :total_call_time => 2}
-
-    # 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.tl_record_unscoped_metrics "foo", 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)
-
-    assert_metrics_recorded ({
-      'foo' => {:call_count => 2},
-      'bar' => {:call_count => 1}
-    })
-  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