newrelic_rpm 3.7.3.204 → 3.8.0.218

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

@@ -4,63 +4,184 @@
 
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
 
-class NewRelic::Agent::StatsEngine::GCProfilerTest < Minitest::Test
-  def test_init_profiler_for_rails_bench
-    return unless defined?(::GC) && ::GC.respond_to?(:collections)
+class NewRelic::Agent::StatsEngine
+  class GCProfilerTest < Minitest::Test
+    def setup
+      NewRelic::Agent.drop_buffered_data
 
-    ::GC.stubs(:time)
-    ::GC.stubs(:collections)
+      stub_gc_profiling_enabled
+      GCProfiler.reset
+    end
 
-    assert_equal(NewRelic::Agent::StatsEngine::GCProfiler::RailsBenchProfiler,
-                 NewRelic::Agent::StatsEngine::GCProfiler.init.class)
-  end
+    def teardown
+      GCProfiler.reset
+    end
 
-  def test_init_profiler_for_ruby_19_and_greater
-    return unless defined?(::GC::Profiler)
-    return if NewRelic::LanguageSupport.using_engine?('jruby')
+    def test_init_profiler_for_rails_bench
+      return unless defined?(::GC) && ::GC.respond_to?(:collections)
 
-    ::GC::Profiler.stubs(:enabled?).returns(true)
-    ::GC::Profiler.stubs(:total_time).returns(0)
-    ::GC.stubs(:count).returns(0)
+      ::GC.stubs(:time)
+      ::GC.stubs(:collections)
 
-    assert_equal(NewRelic::Agent::StatsEngine::GCProfiler::CoreGCProfiler,
-                 NewRelic::Agent::StatsEngine::GCProfiler.init.class)
-  end
+      assert_equal(GCProfiler::RailsBenchProfiler,
+                   GCProfiler.init.class)
+    end
 
-  def test_init_profiler_for_rbx_uses_stdlib
-    return unless defined?(::Rubinius::GC)
+    def test_init_profiler_for_ruby_19_and_greater
+      return unless defined?(::GC::Profiler)
+      return if NewRelic::LanguageSupport.using_engine?('jruby')
 
-    assert_equal(NewRelic::Agent::StatsEngine::GCProfiler::CoreGCProfiler,
-                 NewRelic::Agent::StatsEngine::GCProfiler.init.class)
-  end
+      ::GC::Profiler.stubs(:enabled?).returns(true)
 
-  def test_collect_gc_data
-    return if NewRelic::LanguageSupport.using_engine?('jruby')
+      assert_equal(GCProfiler::CoreGCProfiler,
+                   GCProfiler.init.class)
+    end
 
-    GC.disable
-    if 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
+    def test_init_profiler_for_rbx_uses_stdlib
+      return unless defined?(::Rubinius::GC)
+
+      assert_equal(GCProfiler::CoreGCProfiler,
+                   GCProfiler.init.class)
     end
 
-    with_config(:'transaction_tracer.enabled' => true) do
-      in_transaction { }
+    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
 
-    engine = NewRelic::Agent.instance.stats_engine
-    tracer = NewRelic::Agent.instance.transaction_sampler
+    using_jruby       = NewRelic::LanguageSupport.jruby?
+    using_ree         = NewRelic::LanguageSupport.ree?
+    using_ruby18      = NewRelic::LanguageSupport.using_version?('1.8')
+    using_ruby19_plus = !using_ruby18
+
+    # Only run these tests in environments where GCProfiler is usable
+    if !using_jruby && (using_ree || using_ruby19_plus)
+      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)
 
-    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])
+        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, tracer.last_sample.params[:custom_params][: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_hash_test.rb

@@ -117,7 +117,7 @@ class NewRelic::Agent::StatsHashTest < Minitest::Test
     hash1 = NewRelic::Agent::StatsHash.new(t1)
 
     hash1.merge!(hash0)
-    assert_equal(t0, hash1.started_at)
+    assert_equal(t0.to_f, hash1.started_at)
   end
 
   def test_marshal_dump

data/test/new_relic/agent/transaction_test.rb

@@ -438,6 +438,20 @@ class NewRelic::Agent::TransactionTest < Minitest::Test
     assert_equal 1, NewRelic::Agent.instance.error_collector.errors.count
   end
 
+  def test_records_gc_time
+    gc_start = mock('gc start')
+    gc_end   = mock('gc end')
+    NewRelic::Agent::StatsEngine::GCProfiler.stubs(:take_snapshot).returns(gc_start, gc_end)
+
+    txn = in_transaction do
+      NewRelic::Agent::StatsEngine::GCProfiler.expects(:record_delta).with(gc_start, gc_end).returns(42)
+      NewRelic::Agent::Transaction.current
+    end
+
+    trace = txn.transaction_trace
+    assert_equal(42, trace.params[:custom_params][:gc_time])
+  end
+
   def assert_has_custom_parameter(key, value = key)
     assert_equal(value, NewRelic::Agent::Transaction.current.custom_parameters[key])
   end

data/test/new_relic/agent/vm/monotonic_gc_profiler_test.rb

@@ -15,20 +15,20 @@ class MonotonicGCProfilerTest < Minitest::Test
 
   if NewRelic::LanguageSupport.gc_profiler_usable?
     def test_total_time_isnt_nil
-      refute_nil profiler.total_time
+      refute_nil profiler.total_time_s
     end
 
     def test_total_time_reads_from_gc_profiler
       GC::Profiler.stubs(:total_time).returns(0)
-      assert_equal 0, profiler.total_time
+      assert_equal 0, profiler.total_time_s
 
       GC::Profiler.stubs(:total_time).returns(100)
-      assert_equal 100, profiler.total_time
+      assert_equal 100, profiler.total_time_s
     end
 
     def test_total_time_resets_underlying_gc_profiler
       GC::Profiler.expects(:clear).once
-      profiler.total_time
+      profiler.total_time_s
     end
   end
 
@@ -36,7 +36,7 @@ class MonotonicGCProfilerTest < Minitest::Test
     NewRelic::LanguageSupport.stubs(:gc_profiler_enabled?).returns(false)
 
     assert_raises(NewRelic::Agent::VM::MonotonicGCProfiler::ProfilerNotEnabledError) do
-      profiler.total_time
+      profiler.total_time_s
     end
   end
 end

data/test/new_relic/agent/vm/mri_vm_test.rb

@@ -28,6 +28,13 @@ unless NewRelic::LanguageSupport.jruby? || NewRelic::LanguageSupport.rubinius?
             @vm.gather_gc_time(@snap)
             assert_nil @snap.gc_total_time
           end
+
+          def test_gather_stats_records_gc_time_if_available
+            NewRelic::Agent.instance.monotonic_gc_profiler.stubs(:total_time_s).returns(999)
+            NewRelic::LanguageSupport.stubs(:gc_profiler_enabled?).returns(true)
+            @vm.gather_stats(@snap)
+            assert_equal(999, @snap.gc_total_time)
+          end
         end
       end
     end

data/test/new_relic/agent/vm/snapshot_test.rb

@@ -5,4 +5,9 @@
 require 'new_relic/agent/vm/snapshot'
 
 class NewRelic::Agent::VM::SnapshotTestCase < Minitest::Test
+  def test_records_taken_at_on_initialization
+    t = freeze_time
+    snap = NewRelic::Agent::VM::Snapshot.new
+    assert_equal(t.to_f, snap.taken_at)
+  end
 end

data/test/new_relic/agent_test.rb

@@ -28,14 +28,14 @@ module NewRelic
     end
 
     def test_shutdown_removes_manual_startup_config
-      NewRelic::Agent.manual_start(:some_absurd_setting => true)
+      NewRelic::Agent.manual_start(:monitor_mode => true, :license_key => "a" * 40, :some_absurd_setting => true)
       assert NewRelic::Agent.config[:some_absurd_setting]
       NewRelic::Agent.shutdown
       assert !NewRelic::Agent.config[:some_absurd_setting]
     end
 
     def test_shutdown_removes_server_config
-      NewRelic::Agent.manual_start
+      NewRelic::Agent.manual_start(:monitor_mode => true, :license_key => "a" * 40)
       NewRelic::Agent.instance.service = default_service
       NewRelic::Agent.instance.finish_setup('agent_config' =>
                                             { :some_absurd_setting => true })

data/test/new_relic/control/instance_methods_test.rb

@@ -0,0 +1,30 @@
+# 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/control/instance_methods'
+require 'new_relic/agent/configuration/yaml_source'
+
+class TestClass
+  include NewRelic::Control::InstanceMethods
+end
+
+class NewRelic::Control::InstanceMethodsTest < Minitest::Test
+  def setup
+    NewRelic::Agent.config.reset_to_defaults
+    @test = ::TestClass.new(nil)
+  end
+
+  def test_configure_agent_adds_the_yaml_config
+    refute NewRelic::Agent.config.config_stack_index_for NewRelic::Agent::Configuration::YamlSource
+    @test.configure_agent('test', {})
+    assert NewRelic::Agent.config.config_stack_index_for NewRelic::Agent::Configuration::YamlSource
+  end
+
+  def test_configure_agent_adds_the_manual_config
+    refute NewRelic::Agent.config.config_stack_index_for NewRelic::Agent::Configuration::ManualSource
+    @test.configure_agent('test', {})
+    assert NewRelic::Agent.config.config_stack_index_for NewRelic::Agent::Configuration::ManualSource
+  end
+end

data/test/new_relic/control_test.rb

@@ -16,24 +16,6 @@ class NewRelic::ControlTest < Minitest::Test
     NewRelic::Agent.shutdown
   end
 
-
-  def test_test_config
-    if defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 4
-      assert_equal :rails4, control.app
-    elsif defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 3
-      assert_equal :rails3, control.app
-    elsif defined?(::Rails)
-      assert_equal :rails, control.app
-    else
-      assert_equal :test, control.app
-    end
-    assert_equal :test, control.framework
-    assert("" == NewRelic::Agent.config[:dispatcher].to_s,
-           "Expected dispatcher to be empty, but was #{NewRelic::Agent.config[:dispatcher].to_s}")
-    assert !NewRelic::Agent.config[:monitor_mode]
-    control.local_env
-  end
-
   def test_settings_accessor
     refute_nil control.settings
   end
@@ -180,7 +162,10 @@ class NewRelic::ControlTest < Minitest::Test
 
   def test_init_plugin_loads_samplers_enabled
     reset_agent
-    with_config(:disable_samplers => false, :agent_enabled => true) do
+    with_config(:disable_samplers => false,
+                :agent_enabled    => true,
+                :monitor_mode     => true,
+                :license_key      => 'a'*40) do
       NewRelic::Control.instance.init_plugin
       assert NewRelic::Agent.instance.harvest_samplers.any?
     end
@@ -188,14 +173,51 @@ class NewRelic::ControlTest < Minitest::Test
 
   def test_init_plugin_loads_samplers_disabled
     reset_agent
-    with_config(:disable_samplers => true, :agent_enabled => true) do
+    with_config(:disable_samplers => true,
+                :agent_enabled    => true,
+                :monitor_mode     => true,
+                :license_key      => 'a'*40) do
       NewRelic::Control.instance.init_plugin
-      assert !NewRelic::Agent.instance.harvest_samplers.any?
+      refute NewRelic::Agent.instance.harvest_samplers.any?
+    end
+  end
+
+  def test_agent_not_starting_does_not_load_samplers
+    reset_agent
+
+    NewRelic::Agent.instance.stubs(:defer_for_delayed_job?).returns(true)
+
+    with_config(:disable_samplers => false,
+                :agent_enabled    => true,
+                :monitor_mode     => true,
+                :license_key      => 'a'*40) do
+      NewRelic::Control.instance.init_plugin
+      refute NewRelic::Agent.instance.already_started?
+      refute NewRelic::Agent.instance.harvest_samplers.any?
+    end
+  end
+
+  def test_agent_starting_after_fork_does_load_samplers
+    reset_agent
+
+    NewRelic::Agent.instance.stubs(:defer_for_delayed_job?).returns(true)
+
+    with_config(:disable_samplers => false,
+                :agent_enabled    => true,
+                :monitor_mode     => true,
+                :license_key      => 'a'*40) do
+      NewRelic::Control.instance.init_plugin
+      NewRelic::Agent.instance.stubs(:defer_for_delayed_job?).returns(false)
+      NewRelic::Agent.after_fork
+      assert NewRelic::Agent.instance.already_started?
+      assert NewRelic::Agent.instance.harvest_samplers.any?
     end
   end
 
   def reset_agent
     NewRelic::Agent.shutdown
     NewRelic::Agent.instance.harvest_samplers.clear
+    NewRelic::Agent.instance.instance_variable_set(:@connect_state, :pending)
+    NewRelic::Agent.instance.instance_variable_set(:@worker_thread, nil)
   end
 end