newrelic_rpm 4.1.0.333 → 4.2.0.334

data/test/new_relic/agent/sampler_collection_test.rb

@@ -1,90 +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 SamplerCollectionTest < Minitest::Test
-
-  class DummySampler < NewRelic::Agent::Sampler
-    named :dummy
-    def poll; end
-  end
-
-  class DummySampler2 < NewRelic::Agent::Sampler
-    named :dummy2
-    def poll; end
-  end
-
-  def setup
-    @events     = NewRelic::Agent::EventListener.new
-    @collection = NewRelic::Agent::SamplerCollection.new(@events)
-  end
-
-  def test_add_sampler_adds_a_sampler_of_requested_class
-    @collection.add_sampler(DummySampler)
-    assert_equal(1, @collection.to_a.size)
-    assert_equal(DummySampler, @collection.to_a.first.class)
-  end
-
-  def test_add_sampler_does_add_non_dups
-    @collection.add_sampler(DummySampler)
-    @collection.add_sampler(DummySampler2)
-    assert_equal(2, @collection.to_a.size)
-    assert_equal([DummySampler, DummySampler2], @collection.map { |s| s.class })
-  end
-
-  def test_add_sampler_does_not_add_dups
-    @collection.add_sampler(DummySampler)
-    @collection.add_sampler(DummySampler)
-    assert_equal(1, @collection.to_a.size)
-  end
-
-  def test_add_sampler_omits_unsupported_samplers
-    DummySampler.stubs(:supported_on_this_platform?).returns(false)
-    @collection.add_sampler(DummySampler)
-    assert_equal(0, @collection.to_a.size)
-  end
-
-  def test_add_sampler_omits_disabled_samplers
-    with_config(:disable_dummy_sampler => true) do
-      @collection.add_sampler(DummySampler)
-      assert_equal(0, @collection.to_a.size)
-    end
-  end
-
-  def test_add_sampler_swallows_exceptions_during_sampler_creation
-    DummySampler.stubs(:new).raises(StandardError)
-    @collection.add_sampler(DummySampler)
-    assert_equal(0, @collection.to_a.size)
-  end
-
-  def test_add_sampler_calls_setup_events_with_event_listener_if_present
-    sampler = DummySampler.new
-    DummySampler.stubs(:new).returns(sampler)
-    sampler.expects(:setup_events).with(@events)
-    @collection.add_sampler(DummySampler)
-  end
-
-  def test_poll_samplers_polls_samplers
-    @collection.add_sampler(DummySampler)
-    @collection.add_sampler(DummySampler2)
-    @collection.each { |s| s.expects(:poll) }
-    @collection.poll_samplers
-  end
-
-  def test_poll_samplers_removes_busted_samplers_and_keeps_happy_ones
-    @collection.add_sampler(DummySampler)
-    @collection.add_sampler(DummySampler2)
-    good_sampler, bad_sampler = @collection.to_a
-    bad_sampler.stubs(:poll).raises('boo')
-    @collection.poll_samplers
-    assert_equal(1, @collection.to_a.size)
-    assert_equal([good_sampler], @collection.to_a)
-  end
-
-  def test_polls_samplers_on_before_harvest_event
-    @collection.expects(:poll_samplers)
-    @events.notify(:before_harvest)
-  end
-end

data/test/new_relic/agent/sampler_test.rb

@@ -1,66 +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::SamplerTest < Minitest::Test
-  require 'new_relic/agent/sampler'
-
-  class UnnamedSampler < NewRelic::Agent::Sampler
-    def poll; end
-  end
-
-  class DummySampler < NewRelic::Agent::Sampler
-    named :dummy
-
-    def poll; end
-  end
-
-  def test_inherited_should_append_subclasses_to_sampler_classes
-    test_class = Class.new(NewRelic::Agent::Sampler)
-    sampler_classes = NewRelic::Agent::Sampler.instance_variable_get :@sampler_classes
-    assert(sampler_classes.include?(test_class), "Sampler classes (#{sampler_classes.inspect}) does not include #{test_class.inspect}")
-    # cleanup the sampler created above
-    NewRelic::Agent::Sampler.instance_eval { @sampler_classes.delete(test_class) }
-  end
-
-  def test_sampler_classes_should_be_an_array
-    sampler_classes = NewRelic::Agent::Sampler.instance_variable_get('@sampler_classes')
-    assert(sampler_classes.is_a?(Array), 'Sampler classes should be saved as an array')
-    assert(sampler_classes.include?(NewRelic::Agent::Samplers::CpuSampler), 'Sampler classes should include the CPU sampler')
-  end
-
-  def test_enabled_should_return_true_if_name_unknown
-    assert UnnamedSampler.enabled?
-  end
-
-  def test_initialize_should_accept_id_argument
-    UnnamedSampler.new(:larry)
-  end
-
-  def test_initialize_should_work_without_id_argument
-    UnnamedSampler.new
-  end
-
-  def test_initialize_should_set_id_from_passed_id
-    sampler = DummySampler.new(:larry)
-    assert_equal(:larry, sampler.id)
-  end
-
-  def test_initialize_should_set_id_from_name_if_no_passed_id
-    sampler = DummySampler.new
-    assert_equal(:dummy, sampler.id)
-  end
-
-  def test_enabled_should_return_false_if_disabled_via_config_setting
-    with_config(:disable_dummy_sampler => true) do
-      refute DummySampler.enabled?
-    end
-  end
-
-  def test_enabled_should_return_true_if_enabled_via_config_setting
-    with_config(:disable_dummy_sampler => false) do
-      assert DummySampler.enabled?
-    end
-  end
-end

data/test/new_relic/agent/samplers/cpu_sampler_test.rb

@@ -1,79 +0,0 @@
-# -*- ruby -*-
-# 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::Samplers::CpuSamplerTest < Minitest::Test
-
-  def setup
-    @original_jruby_version = JRUBY_VERSION if defined?(JRuby)
-  end
-
-  def teardown
-    set_jruby_version_constant(@original_jruby_version) if defined?(JRuby)
-  end
-
-  def test_correcly_detecting_jruby_support_for_correct_cpu_sampling
-    if defined?(JRuby)
-      set_jruby_version_constant '1.6.8'
-      refute_supported_on_platform
-
-      set_jruby_version_constant '1.7.0'
-      assert_supported_on_platform
-
-      set_jruby_version_constant '1.7.4'
-      assert_supported_on_platform
-    else
-      assert_supported_on_platform
-    end
-  end
-
-  #
-  # Helpers
-  #
-
-  def assert_supported_on_platform
-    assert_equal NewRelic::Agent::Samplers::CpuSampler.supported_on_this_platform?, true, "should be supported on this platform"
-  end
-
-  def refute_supported_on_platform
-    assert_equal NewRelic::Agent::Samplers::CpuSampler.supported_on_this_platform?, false, "should not be supported on this platform"
-  end
-
-  def set_jruby_version_constant(string)
-    Object.send(:remove_const, 'JRUBY_VERSION') if defined?(JRUBY_VERSION)
-    Object.const_set('JRUBY_VERSION', string)
-  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
-end

data/test/new_relic/agent/samplers/memory_sampler_test.rb

@@ -1,66 +0,0 @@
-# -*- ruby -*-
-# 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/memory_sampler'
-
-class NewRelic::Agent::Samplers::MemorySamplerTest < Minitest::Test
-  def setup
-    @stats_engine = NewRelic::Agent::StatsEngine.new
-    NewRelic::Agent.instance.stubs(:stats_engine).returns(@stats_engine)
-  end
-
-  def test_memory__default
-    stub_sampler_get_memory
-    s = NewRelic::Agent::Samplers::MemorySampler.new
-    s.poll
-    s.poll
-    s.poll
-    assert_metrics_recorded "Memory/Physical" => {:call_count => 3, :total_call_time => 999}
-  end
-
-  def test_memory__linux
-    return if RUBY_PLATFORM =~ /darwin/
-    NewRelic::Agent::Samplers::MemorySampler.any_instance.stubs(:platform).returns 'linux'
-    stub_sampler_get_memory
-    s = NewRelic::Agent::Samplers::MemorySampler.new
-    s.poll
-    s.poll
-    s.poll
-
-    assert_metrics_recorded "Memory/Physical" => {:call_count => 3, :total_call_time => 999}
-  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
-    assert_metrics_recorded "Memory/Physical" => {:call_count => 1, :total_call_time => 999}
-  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
-
-  def stub_sampler_get_memory
-    if defined? JRuby
-      NewRelic::Agent::Samplers::MemorySampler::JavaHeapSampler.any_instance.stubs(:get_memory).returns 333
-    else
-      NewRelic::Agent::Samplers::MemorySampler::ShellPS.any_instance.stubs(:get_memory).returns 333
-      NewRelic::Agent::Samplers::MemorySampler::ProcStatus.any_instance.stubs(:get_memory).returns 333
-    end
-  end
-end

data/test/new_relic/agent/samplers/vm_sampler_test.rb

@@ -1,349 +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/vm_sampler'
-require 'new_relic/agent/vm/snapshot'
-
-module NewRelic
-  module Agent
-    module Samplers
-      class VMSamplerTest < Minitest::Test
-        def setup
-          stub_snapshot(
-            :taken_at                     => 0,
-            :gc_runs                      => 0,
-            :gc_total_time                => 0,
-            :total_allocated_object       => 0,
-            :major_gc_count               => 0,
-            :minor_gc_count               => 0,
-            :heap_live                    => 0,
-            :heap_free                    => 0,
-            :method_cache_invalidations   => 0,
-            :constant_cache_invalidations => 0
-          )
-          @sampler = VMSampler.new
-          @sampler.setup_events(NewRelic::Agent.instance.events)
-          NewRelic::Agent.drop_buffered_data
-        end
-
-        def test_supported_on_this_platform?
-          assert VMSampler.supported_on_this_platform?
-        end
-
-        def test_enabled_should_return_false_if_disabled_via_config_setting
-          with_config(:disable_vm_sampler => true) do
-            refute VMSampler.enabled?
-          end
-        end
-
-        def test_records_transaction_count
-          generate_transactions(10)
-          assert_equal(10, @sampler.transaction_count)
-        end
-
-        def test_reset_transaction_count
-          generate_transactions(10)
-
-          old_count = @sampler.reset_transaction_count
-          assert_equal(10, old_count)
-          assert_equal(0, @sampler.transaction_count)
-        end
-
-        def test_poll_records_thread_count
-          stub_snapshot(:thread_count => 2)
-
-          @sampler.poll
-          assert_metrics_recorded(
-            'RubyVM/Threads/all' => {
-              :call_count => 2,
-              :sum_of_squares => 1
-            }
-          )
-        end
-
-        def test_poll_records_gc_runs_metric
-          stub_snapshot(:gc_runs => 10, :gc_total_time => 100, :taken_at => 200)
-          generate_transactions(50)
-          @sampler.poll
-
-          assert_metrics_recorded(
-            'RubyVM/GC/runs' => {
-              :call_count           => 50,  # number of transactions
-              :total_call_time      => 10,  # number of GC runs
-              :total_exclusive_time => 100, # total GC time
-              :sum_of_squares       => 200  # total wall clock time
-            }
-          )
-        end
-
-        def test_poll_records_total_allocated_object
-          stub_snapshot(:total_allocated_object => 25)
-          generate_transactions(50)
-          @sampler.poll
-
-          assert_metrics_recorded(
-            'RubyVM/GC/total_allocated_object' => {
-              :call_count      => 50, # number of transactions
-              :total_call_time => 25  # number of allocated objects
-            }
-          )
-        end
-
-        def test_poll_records_major_minor_gc_counts
-          stub_snapshot(:major_gc_count => 10, :minor_gc_count => 20)
-          generate_transactions(50)
-          @sampler.poll
-
-          assert_metrics_recorded(
-            'RubyVM/GC/major_gc_count' => {
-              :call_count      => 50, # number of transactions
-              :total_call_time => 10  # number of major GC runs
-            },
-            'RubyVM/GC/minor_gc_count' => {
-              :call_count      => 50, # number of transactions
-              :total_call_time => 20  # number of minor GC runs
-            }
-          )
-        end
-
-        def test_poll_records_heap_usage_metrics
-          stub_snapshot(:heap_live => 100, :heap_free => 25)
-          @sampler.poll
-
-          assert_metrics_recorded(
-            'RubyVM/GC/heap_live' => {
-              :call_count     => 100,
-              :sum_of_squares => 1
-            },
-            'RubyVM/GC/heap_free' => {
-              :call_count      => 25,
-              :sum_of_squares  => 1
-            }
-          )
-        end
-
-        def test_poll_records_vm_cache_invalidations
-          stub_snapshot(
-            :method_cache_invalidations   => 100,
-            :constant_cache_invalidations => 200
-          )
-          generate_transactions(50)
-          @sampler.poll
-
-          assert_metrics_recorded(
-            'RubyVM/CacheInvalidations/method' => {
-              :call_count      => 50, # number of transactions
-              :total_call_time => 100 # number of method cache invalidations
-            },
-            'RubyVM/CacheInvalidations/constant' => {
-              :call_count      => 50, # number of transactions
-              :total_call_time => 200 # number of constant cache invalidations
-            }
-          )
-        end
-
-        def test_poll_gracefully_handles_missing_fields
-          stub_snapshot({}) # snapshot will be empty
-          @sampler.poll
-
-          assert_metrics_not_recorded([
-            'RubyVM/GC/runs',
-            'RubyVM/GC/total_allocated_object',
-            'RubyVM/GC/major_gc_count',
-            'RubyVM/GC/minor_gc_count',
-            'RubyVM/GC/heap_live',
-            'RubyVM/GC/heap_free',
-            'RubyVM/CacheInvalidations/method',
-            'RubyVM/CacheInvalidations/constant'
-          ])
-        end
-
-        def test_poll_handles_missing_gc_time_but_present_gc_count
-          # We were able to determine the number of GC runs, but not the total
-          # GC time. This will be the case if GC::Profiler is not available.
-          stub_snapshot(:gc_runs => 10, :taken_at => 60)
-          generate_transactions(50)
-          @sampler.poll
-
-          assert_metrics_recorded(
-            'RubyVM/GC/runs' => {
-              :call_count           => 50, # number of transactions
-              :total_call_time      => 10, # number of GC runs
-              :total_exclusive_time => 0,  # total GC time
-              :sum_of_squares       => 60  # total wall clock time
-            }
-          )
-        end
-
-        def test_poll_records_deltas_not_cumulative_values
-          stub_snapshot(
-            :gc_runs                      => 10,
-            :gc_total_time                => 10,
-            :total_allocated_object       => 10,
-            :major_gc_count               => 10,
-            :minor_gc_count               => 10,
-            :method_cache_invalidations   => 10,
-            :constant_cache_invalidations => 10
-          )
-          @sampler.poll
-
-          expected = {
-            'RubyVM/GC/runs' => {
-              :total_call_time      => 10,
-              :total_exclusive_time => 10
-            },
-            'RubyVM/GC/total_allocated_object' => {
-              :total_call_time => 10
-            },
-            'RubyVM/GC/major_gc_count' => {
-              :total_call_time => 10
-            },
-            'RubyVM/GC/minor_gc_count' => {
-              :total_call_time => 10
-            },
-            'RubyVM/CacheInvalidations/method' => {
-              :total_call_time => 10
-            },
-            'RubyVM/CacheInvalidations/constant' => {
-              :total_call_time => 10
-            }
-          }
-
-          assert_metrics_recorded(expected)
-
-          NewRelic::Agent.drop_buffered_data
-
-          stub_snapshot(
-            :gc_runs                      => 20,
-            :gc_total_time                => 20,
-            :total_allocated_object       => 20,
-            :major_gc_count               => 20,
-            :minor_gc_count               => 20,
-            :method_cache_invalidations   => 20,
-            :constant_cache_invalidations => 20
-          )
-          @sampler.poll
-
-          assert_metrics_recorded(expected)
-        end
-
-        # This test simulates multiple poll cycles without a metric reset
-        # between them. This can happen, for example, when the agent fails to
-        # post metric data to the collector.
-        def test_poll_aggregates_multiple_polls
-          stub_snapshot(
-            :gc_runs                      => 10,
-            :gc_total_time                => 10,
-            :total_allocated_object       => 10,
-            :major_gc_count               => 10,
-            :minor_gc_count               => 10,
-            :method_cache_invalidations   => 10,
-            :constant_cache_invalidations => 10,
-            :taken_at                     => 10
-          )
-          generate_transactions(10)
-          @sampler.poll
-
-          stub_snapshot(
-            :gc_runs                      => 20,
-            :gc_total_time                => 20,
-            :total_allocated_object       => 20,
-            :major_gc_count               => 20,
-            :minor_gc_count               => 20,
-            :method_cache_invalidations   => 20,
-            :constant_cache_invalidations => 20,
-            :taken_at                     => 20
-          )
-          generate_transactions(10)
-          @sampler.poll
-
-          assert_metrics_recorded(
-            'RubyVM/GC/runs' => {
-              :call_count           => 20,
-              :total_call_time      => 20,
-              :total_exclusive_time => 20,
-              :sum_of_squares       => 20
-            },
-            'RubyVM/GC/total_allocated_object' => {
-              :call_count      => 20,
-              :total_call_time => 20
-            },
-            'RubyVM/GC/major_gc_count' => {
-              :call_count      => 20,
-              :total_call_time => 20
-            },
-            'RubyVM/GC/minor_gc_count' => {
-              :call_count      => 20,
-              :total_call_time => 20
-            },
-            'RubyVM/CacheInvalidations/method' => {
-              :call_count      => 20,
-              :total_call_time => 20
-            },
-            'RubyVM/CacheInvalidations/constant' => {
-              :call_count      => 20,
-              :total_call_time => 20
-            }
-          )
-        end
-
-        def test_poll_records_wall_clock_time_for_gc_runs_metric
-          stub_snapshot(:gc_runs => 10, :gc_total_time => 10, :taken_at => 60)
-          @sampler.poll
-
-          assert_metrics_recorded(
-            'RubyVM/GC/runs' => {
-              :total_exclusive_time => 10, # total GC time
-              :sum_of_squares       => 60  # total wall clock time
-            }
-          )
-
-          stub_snapshot(:gc_runs => 10, :gc_total_time => 15, :taken_at => 120)
-          @sampler.poll
-
-          assert_metrics_recorded(
-            'RubyVM/GC/runs' => {
-              :total_exclusive_time => 15, # total GC time
-              :sum_of_squares       => 120 # total wall clock time
-            }
-          )
-        end
-
-        def test_poll_records_one_in_gc_runs_max_if_gc_time_available
-          stub_snapshot(:gc_runs => 10, :gc_total_time => 10)
-          @sampler.poll
-
-          assert_metrics_recorded(
-            'RubyVM/GC/runs' => { :max_call_time => 1 }
-          )
-        end
-
-        def test_poll_records_zero_in_gc_runs_max_if_gc_time_not_available
-          stub_snapshot(:gc_runs => 10)
-          @sampler.poll
-
-          assert_metrics_recorded(
-            'RubyVM/GC/runs' => { :max_call_time => 0 }
-          )
-        end
-
-        def generate_transactions(n)
-          n.times do
-            in_transaction('txn') { }
-          end
-        end
-
-        def stub_snapshot(values)
-          fakeshot = NewRelic::Agent::VM::Snapshot.new
-          values.each do |key, value|
-            fakeshot.send("#{key}=", value)
-          end
-          NewRelic::Agent::VM.stubs(:snapshot).returns(fakeshot)
-          fakeshot
-        end
-      end
-    end
-  end
-end