newrelic_rpm 4.0.0.332 → 4.4.0.336

data/test/new_relic/agent/transaction_timings_test.rb

@@ -1,91 +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/transaction_timings'
-
-module NewRelic::Agent
-  class TransactionTimingsTest < Minitest::Test
-
-    def setup
-      @start_time = freeze_time
-      @name = "Name"
-    end
-
-    def test_transaction_name
-      t = TransactionTimings.new(nil, nil, @name)
-      assert_equal "Name", t.transaction_name
-    end
-
-    def test_transaction_name_or_unknown
-      t = TransactionTimings.new(nil, nil, @name)
-      assert_equal "Name", t.transaction_name_or_unknown
-    end
-
-    def test_transaction_name_or_unknown_when_nil
-      t = TransactionTimings.new(nil, nil, nil)
-      assert_equal "(unknown)", t.transaction_name_or_unknown
-    end
-
-    def test_queue_time_nil
-      t = TransactionTimings.new(nil, @start_time, @name)
-      assert_equal 0.0, t.queue_time_in_millis
-    end
-
-    def test_queue_time_in_millis
-      t = TransactionTimings.new(1000.1234, @start_time, @name)
-      assert_equal 1_000_123, t.queue_time_in_millis
-    end
-
-    def test_queue_time_in_seconds
-      t = TransactionTimings.new(1000.1234, @start_time, @name)
-      assert_equal 1_000.1234, t.queue_time_in_seconds
-    end
-
-    def test_queue_time_clamps_to_positive_in_millis
-      t = TransactionTimings.new(-1000, @start_time, @name)
-      assert_equal 0, t.queue_time_in_millis
-    end
-
-    def test_queue_time_clamps_to_positive_in_seconds
-      t = TransactionTimings.new(-1000, @start_time, @name)
-      assert_equal 0, t.queue_time_in_seconds
-    end
-
-    def test_screwy_queue_time_defaults_to_zero
-      t = TransactionTimings.new("a duck", @start_time, @name)
-      assert_equal 0.0, t.queue_time_in_seconds
-    end
-
-    def test_app_time_in_millis
-      advance_time(2)
-      t = TransactionTimings.new(nil, @start_time, @name)
-      assert_equal 2_000.0, t.app_time_in_millis
-    end
-
-    def test_app_time_in_seconds
-      advance_time(2)
-      t = TransactionTimings.new(nil, @start_time, @name)
-      assert_equal 2.0, t.app_time_in_seconds
-    end
-
-    def test_locks_time_at_instantiation
-      t = TransactionTimings.new(1000, @start_time, @name)
-      original = t.app_time_in_seconds
-
-      advance_time(3)
-      later = t.app_time_in_seconds
-
-      assert_equal original, later
-    end
-
-    def test_clamp_to_positive
-      t = TransactionTimings.new(nil, nil, nil)
-      assert_equal(0.0, t.clamp_to_positive(-1), "should clamp a negative value to zero")
-      assert_equal(1232, t.clamp_to_positive(1232), "should pass through the value when it is positive")
-      assert_equal(0, t.clamp_to_positive(0), "should not mess with zero when passing it through")
-    end
-
-  end
-end

data/test/new_relic/agent/utilization_data_test.rb

@@ -1,258 +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/utilization_data'
-
-module NewRelic::Agent
-  class UtilizationDataTest < Minitest::Test
-
-    # recurses through hashes and arrays and symbolizes keys
-    def self.symbolize_keys_in_object(object)
-      case object
-      when Hash
-        object.inject({}) do |memo, (k, v)|
-          memo[k.to_sym] = symbolize_keys_in_object(v)
-          memo
-        end
-      when Array
-        object.map {|o| symbolize_keys_in_object(o)}
-      else
-        object
-      end
-    end
-
-    def setup
-      stub_aws_info
-    end
-
-    def test_aws_information_is_included_when_available
-      stub_aws_info(
-        :instance_id => "i-e7e85ce1",
-        :instance_type => "m3.medium",
-        :availability_zone => "us-west-2b"
-      )
-
-      utilization_data = UtilizationData.new
-
-      expected = {
-        :id => "i-e7e85ce1",
-        :type => "m3.medium",
-        :zone => "us-west-2b"
-      }
-
-      assert_equal expected, utilization_data.to_collector_hash[:vendors][:aws]
-    end
-
-    def test_aws_information_is_omitted_when_available_but_disabled_by_config
-      stub_aws_info(
-        :instance_id => "i-e7e85ce1",
-        :instance_type => "m3.medium",
-        :availability_zone => "us-west-2b"
-      )
-
-      with_config(:'utilization.detect_aws' => false, :'utilization.detect_docker' => false) do
-        utilization_data = UtilizationData.new
-        assert_nil utilization_data.to_collector_hash[:vendors]
-      end
-    end
-
-    def test_docker_information_is_included_when_available
-      NewRelic::Agent::SystemInfo.stubs(:docker_container_id).returns("47cbd16b77c50cbf71401")
-
-      utilization_data = UtilizationData.new
-
-      expected = {
-        :docker => {
-          :id => "47cbd16b77c50cbf71401"
-        }
-      }
-
-      assert_equal expected, utilization_data.to_collector_hash[:vendors]
-    end
-
-    def test_docker_information_is_omitted_when_available_but_disabled_by_config
-      NewRelic::Agent::SystemInfo.stubs(:docker_container_id).returns("47cbd16b77c50cbf71401")
-      with_config(:'utilization.detect_docker' => false) do
-        utilization_data = UtilizationData.new
-        assert_nil utilization_data.to_collector_hash[:vendors]
-      end
-    end
-
-    def test_logged_when_docker_container_id_is_unrecognized
-      NewRelic::Agent::SystemInfo.stubs(:ruby_os_identifier).returns('linux')
-      NewRelic::Agent::SystemInfo.stubs(:ram_in_mib).returns(128)
-      NewRelic::Agent::SystemInfo.stubs(:proc_try_read).returns('whatever')
-      NewRelic::Agent::SystemInfo.stubs(:parse_cgroup_ids).returns('cpu' => "*****YOLO*******")
-
-      expects_logging(:debug, includes("YOLO"))
-      utilization_data = UtilizationData.new
-      assert_nil utilization_data.to_collector_hash[:vendors]
-    end
-
-    def test_aws_and_docker_information_is_included_when_both_available
-      stub_aws_info(
-        :instance_id => "i-e7e85ce1",
-        :instance_type => "m3.medium",
-        :availability_zone => "us-west-2b"
-      )
-
-      NewRelic::Agent::SystemInfo.stubs(:docker_container_id).returns("47cbd16b77c50cbf71401")
-
-      utilization_data = UtilizationData.new
-
-      expected = {
-        :aws => {
-          :id => "i-e7e85ce1",
-          :type => "m3.medium",
-          :zone => "us-west-2b"
-        },
-        :docker => {
-          :id => "47cbd16b77c50cbf71401"
-        }
-      }
-
-       assert_equal expected, utilization_data.to_collector_hash[:vendors]
-    end
-
-    def test_vendor_information_is_omitted_if_unavailable
-      NewRelic::Agent::SystemInfo.stubs(:docker_container_id).returns(nil)
-
-      utilization_data = UtilizationData.new
-
-      assert_nil utilization_data.to_collector_hash[:vendors]
-    end
-
-    def test_hostname_is_present_in_collector_hash
-      NewRelic::Agent::Hostname.stubs(:get).returns("host")
-
-      utilization_data = UtilizationData.new
-
-      assert_equal "host", utilization_data.to_collector_hash[:hostname]
-    end
-
-    def test_cpu_count_is_present_in_collector_hash
-      NewRelic::Agent::SystemInfo.stubs(:num_logical_processors).returns(5)
-
-      utilization_data = UtilizationData.new
-
-      assert_equal 5, utilization_data.to_collector_hash[:logical_processors]
-    end
-
-    def test_memory_is_present_in_collector_hash
-      NewRelic::Agent::SystemInfo.stubs(:ram_in_mib).returns(128)
-
-      utilization_data = UtilizationData.new
-
-      assert_equal 128, utilization_data.to_collector_hash[:total_ram_mib]
-    end
-
-    def test_memory_is_nil_when_proc_meminfo_is_unreadable
-      NewRelic::Agent::SystemInfo.stubs(:ruby_os_identifier).returns("linux")
-      NewRelic::Agent::SystemInfo.stubs(:proc_try_read).returns(nil)
-
-      utilization_data = UtilizationData.new
-
-      assert_nil utilization_data.to_collector_hash[:total_ram_mib], "Expected total_ram_mib to be nil"
-    end
-
-    def test_metadata_version_is_present_in_collector_hash
-      utilization_data = UtilizationData.new
-
-      assert_equal UtilizationData::METADATA_VERSION, utilization_data.to_collector_hash[:metadata_version]
-    end
-
-    def test_configured_hostname_added_to_config_hash
-      with_config(:'utilization.billing_hostname' => 'BillNye') do
-        utilization_data = UtilizationData.new
-        assert_equal 'BillNye', utilization_data.to_collector_hash[:config][:hostname]
-      end
-    end
-
-    def test_configured_logical_processors_added_to_config_hash
-      with_config(:'utilization.logical_processors' => 42) do
-        utilization_data = UtilizationData.new
-        assert_equal 42, utilization_data.to_collector_hash[:config][:logical_processors]
-      end
-    end
-
-    def test_configured_total_ram_mib_added_to_config_hash
-      with_config(:'utilization.total_ram_mib' => 42) do
-        utilization_data = UtilizationData.new
-        assert_equal 42, utilization_data.to_collector_hash[:config][:total_ram_mib]
-      end
-    end
-
-    load_cross_agent_test("utilization/utilization_json").each do |test_case|
-
-      test_case = NewRelic::Agent::UtilizationDataTest.symbolize_keys_in_object test_case
-      define_method("test_#{test_case[:testname]}".tr(" ", "_")) do
-        setup_cross_agent_test_stubs test_case
-        # This is a little bit ugly, but TravisCI runs these tests in a docker environment,
-        # which means we get an unexpected docker id in the vendors hash. Since none of the
-        # cross agent tests expect docker ids in the vendors hash we can safely turn off
-        # docker detection.
-        options = convert_env_to_config_options(test_case).merge(:'utilization.detect_docker' => false)
-        with_config options do
-          assert_equal test_case[:expected_output_json], UtilizationData.new.to_collector_hash
-        end
-      end
-    end
-
-    def setup_cross_agent_test_stubs test_case
-      stub_utilization_inputs test_case
-      stub_aws_inputs test_case
-    end
-
-    UTILIZATION_INPUTS = {
-      :input_total_ram_mib => :ram_in_mib,
-      :input_logical_processors => :cpu_count,
-      :input_hostname => :hostname
-    }
-
-    def stub_utilization_inputs test_case
-      test_case.keys.each do |key|
-        if meth = UTILIZATION_INPUTS[key]
-          UtilizationData.any_instance.stubs(meth).returns(test_case[key])
-        end
-      end
-    end
-
-    AWS_INPUTS = {
-      :input_aws_id => :instance_id,
-      :input_aws_type => :instance_type,
-      :input_aws_zone => :availability_zone
-    }
-
-    def stub_aws_inputs test_case
-      test_case.keys.each do |key|
-        if meth = AWS_INPUTS[key]
-          AWSInfo.any_instance.stubs(meth).returns(test_case[key])
-        end
-      end
-    end
-
-    ENV_TO_OPTIONS = {
-      :NEW_RELIC_UTILIZATION_LOGICAL_PROCESSORS => :'utilization.logical_processors',
-      :NEW_RELIC_UTILIZATION_TOTAL_RAM_MIB =>  :'utilization.total_ram_mib',
-      :NEW_RELIC_UTILIZATION_BILLING_HOSTNAME => :'utilization.billing_hostname'
-    }
-
-    NUMERIC_ENV_OPTS = [:NEW_RELIC_UTILIZATION_LOGICAL_PROCESSORS, :NEW_RELIC_UTILIZATION_TOTAL_RAM_MIB]
-
-    def convert_env_to_config_options test_case
-      env_inputs = test_case.fetch :input_environment_variables, {}
-      env_inputs.keys.inject({}) do |memo, k|
-        memo[ENV_TO_OPTIONS[k]] = NUMERIC_ENV_OPTS.include?(k) ? env_inputs[k].to_i : env_inputs[k]
-        memo
-      end
-    end
-
-    def stub_aws_info(responses = {})
-      AWSInfo.any_instance.stubs(:remote_fetch).with("instance-id").returns(responses[:instance_id])
-      AWSInfo.any_instance.stubs(:remote_fetch).with("instance-type").returns(responses[:instance_type])
-      AWSInfo.any_instance.stubs(:remote_fetch).with("placement/availability-zone").returns(responses[:availability_zone])
-    end
-  end
-end

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

@@ -1,42 +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__, "..", "..", "..", "..", "test_helper"))
-require 'new_relic/agent/vm/monotonic_gc_profiler'
-
-class MonotonicGCProfilerTest < Minitest::Test
-  attr_reader :profiler
-
-  def setup
-    @profiler = NewRelic::Agent::VM::MonotonicGCProfiler.new
-    NewRelic::LanguageSupport.stubs(:gc_profiler_enabled?).returns(true)
-  end
-
-  if NewRelic::LanguageSupport.gc_profiler_usable?
-    def test_total_time_isnt_nil
-      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_s
-
-      GC::Profiler.stubs(:total_time).returns(100)
-      assert_equal 100, profiler.total_time_s
-    end
-
-    def test_total_time_resets_underlying_gc_profiler
-      GC::Profiler.expects(:clear).once
-      profiler.total_time_s
-    end
-
-    def test_total_time_does_not_raise_if_called_when_not_enabled
-      NewRelic::LanguageSupport.stubs(:gc_profiler_enabled?).returns(false)
-      GC::Profiler.expects(:total_time).never
-
-      profiler.total_time_s
-    end
-  end
-
-end

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

@@ -1,40 +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/vm/mri_vm'
-
-unless NewRelic::LanguageSupport.jruby?
-  module NewRelic
-    module Agent
-      module VM
-        class MriVMTest < Minitest::Test
-          def setup
-            @snap = Snapshot.new
-            @vm = MriVM.new
-          end
-
-          def test_gather_gc_time_sets_gc_total_time_if_gc_profiler_is_enabled
-            NewRelic::LanguageSupport.stubs(:gc_profiler_enabled?).returns(true)
-            @vm.gather_gc_time(@snap)
-            refute_nil @snap.gc_total_time
-          end
-
-          def test_gather_gc_time_does_not_set_gc_total_time_if_gc_profiler_is_disabled
-            NewRelic::LanguageSupport.stubs(:gc_profiler_enabled?).returns(false)
-            @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
-  end
-end

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

@@ -1,13 +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 '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/vm_test.rb

@@ -1,48 +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/vm'
-
-class NewRelic::Agent::VMTestCase < Minitest::Test
-  attr_reader :vm, :snapshot
-
-  def setup
-    @vm = NewRelic::Agent::VM.vm
-    @snapshot = NewRelic::Agent::VM.snapshot
-  end
-
-  def test_gets_snapshot
-    refute_nil snapshot
-  end
-
-  EXPECTED_SNAPSHOT_VALUES = [
-    :gc_runs,
-    :total_allocated_object,
-    :major_gc_count,
-    :minor_gc_count,
-    :heap_live,
-    :heap_free,
-    :method_cache_invalidations,
-    :constant_cache_invalidations,
-    :thread_count
-  ]
-
-  EXPECTED_SNAPSHOT_VALUES.each do |val|
-    define_method("test_snapshot_has_#{val}") do
-      assert_correct_value_for(val)
-    end
-  end
-
-  # A VM snapshot will either support a value and have something non-nil,
-  # or it will not support it in which case the method exists but must be nil!
-  def assert_correct_value_for(meth)
-    if vm.supports?(meth)
-      refute_nil snapshot.send(meth)
-    else
-      assert_nil snapshot.send(meth)
-    end
-  end
-end
-

data/test/new_relic/agent/worker_loop_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'))
-
-class NewRelic::Agent::WorkerLoopTest < Minitest::Test
-  def setup
-    @worker_loop = NewRelic::Agent::WorkerLoop.new
-  end
-
-  def test_add_task
-    @x = false
-    @worker_loop.run(0) do
-      @worker_loop.stop
-      @x = true
-    end
-    assert @x
-  end
-
-  def test_with_duration
-    freeze_time
-
-    period = 5.0
-    worker_loop = NewRelic::Agent::WorkerLoop.new(:duration => 16.0)
-
-    def worker_loop.sleep(duration)
-      advance_time(duration)
-    end
-
-    count = 0
-    worker_loop.run(period) { count += 1 }
-    assert_equal 3, count
-  end
-
-  def test_duration_clock_starts_with_run
-    # This test is a little on the nose, but any timing based test WILL fail in CI
-    worker_loop = NewRelic::Agent::WorkerLoop.new(:duration => 0.01)
-    assert_nil worker_loop.instance_variable_get(:@deadline)
-
-    worker_loop.run(0.001) {}
-    assert !worker_loop.instance_variable_get(:@deadline).nil?
-  end
-
-  def test_loop_limit
-    worker_loop = NewRelic::Agent::WorkerLoop.new(:limit => 2)
-    iterations = 0
-    worker_loop.run(0) { iterations += 1 }
-    assert_equal 2, iterations
-  end
-
-  def test_task_error__standard
-    expects_logging(:error, any_parameters)
-    # This loop task will run twice
-    done = false
-    @worker_loop.run(0) do
-      @worker_loop.stop
-      done = true
-      raise "Standard Error Test"
-    end
-    assert done
-  end
-
-  def test_task_error__exception
-    expects_logging(:error, any_parameters)
-    @worker_loop.run(0) do
-      @worker_loop.stop
-      raise NewRelic::TestHelper::Exception::TestError, "oops"
-    end
-  end
-
-  def test_worker_loop_propagates_errors_given_the_option
-    @worker_loop = NewRelic::Agent::WorkerLoop.new(
-      :limit => 2,
-      :propagate_errors => true
-    )
-
-    assert_raises NewRelic::TestHelpers::Exceptions::TestError do
-      @worker_loop.run(0) do
-        raise NewRelic::TestHelpers::Exceptions::TestError
-      end
-    end
-  end
-
-  def test_dynamically_adjusts_the_period_once_the_loop_has_been_started
-    freeze_time
-
-    worker_loop = NewRelic::Agent::WorkerLoop.new(:limit => 2)
-
-    worker_loop.expects(:sleep).with(5.0)
-    worker_loop.expects(:sleep).with(7.0)
-    worker_loop.run(5.0) { advance_time(5.0); worker_loop.period = 7.0 }
-  end
-
-  def ticks(start, finish, step)
-    (start..finish).step(step).map{|i| Time.at(i)}
-  end
-end