newrelic_rpm 3.18.1.330 → 4.0.0.332

data/test/new_relic/agent/new_relic_service_test.rb

@@ -359,7 +359,7 @@ class NewRelicServiceTest < Minitest::Test
 
   def test_profile_data_does_not_normalize_encodings
     @http_handle.respond_to(:profile_data, nil)
-    NewRelic::JSONWrapper.expects(:normalize).never
+    NewRelic::Agent::EncodingNormalizer.expects(:normalize_object).never
     @service.profile_data([])
   end
 
@@ -441,122 +441,114 @@ class NewRelicServiceTest < Minitest::Test
     end
   end
 
-  if NewRelic::Agent::NewRelicService::JsonMarshaller.is_supported?
-    def test_json_marshaller_handles_responses_from_collector
-      marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
-      assert_equal ['beep', 'boop'], marshaller.load('{"return_value": ["beep","boop"]}')
-    end
+  def test_json_marshaller_handles_responses_from_collector
+    marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
+    assert_equal ['beep', 'boop'], marshaller.load('{"return_value": ["beep","boop"]}')
+  end
 
-    def test_json_marshaller_handles_errors_from_collector
-      marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
-      assert_raises(NewRelic::Agent::NewRelicService::CollectorError,
-                   'JavaCrash: error message') do
-        marshaller.load('{"exception": {"message": "error message", "error_type": "JavaCrash"}}')
-      end
+  def test_json_marshaller_handles_errors_from_collector
+    marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
+    assert_raises(NewRelic::Agent::NewRelicService::CollectorError,
+                 'JavaCrash: error message') do
+      marshaller.load('{"exception": {"message": "error message", "error_type": "JavaCrash"}}')
     end
+  end
 
-    def test_json_marshaller_logs_on_empty_response_from_collector
-      marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
-      expects_logging(:error, any_parameters)
-      assert_nil marshaller.load('')
-    end
+  def test_json_marshaller_logs_on_empty_response_from_collector
+    marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
+    expects_logging(:error, any_parameters)
+    assert_nil marshaller.load('')
+  end
+
+  def test_json_marshaller_logs_on_nil_response_from_collector
+    marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
+    expects_logging(:error, any_parameters)
+    assert_nil marshaller.load(nil)
+  end
 
-    def test_json_marshaller_logs_on_nil_response_from_collector
-      marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
-      expects_logging(:error, any_parameters)
-      assert_nil marshaller.load(nil)
+  def test_raises_serialization_error_if_json_serialization_fails
+    ::JSON.stubs(:dump).raises(RuntimeError.new('blah'))
+    assert_raises(NewRelic::Agent::SerializationError) do
+      @service.send(:invoke_remote, 'wiggle', [{}])
     end
+  end
 
-    def test_raises_serialization_error_if_json_serialization_fails
-      ::NewRelic::JSONWrapper.stubs(:dump).raises(RuntimeError.new('blah'))
+  def test_raises_serialization_error_if_encoding_normalization_fails
+    with_config(:normalize_json_string_encodings => true) do
+      @http_handle.respond_to(:wiggle, 'hi')
+      NewRelic::Agent::EncodingNormalizer.stubs(:normalize_object).raises('blah')
       assert_raises(NewRelic::Agent::SerializationError) do
         @service.send(:invoke_remote, 'wiggle', [{}])
       end
     end
+  end
 
-    def test_raises_serialization_error_if_encoding_normalization_fails
-      with_config(:normalize_json_string_encodings => true) do
-        @http_handle.respond_to(:wiggle, 'hi')
-        NewRelic::JSONWrapper.stubs(:normalize).raises('blah')
-        assert_raises(NewRelic::Agent::SerializationError) do
-          @service.send(:invoke_remote, 'wiggle', [{}])
-        end
-      end
+  def test_skips_normalization_if_configured_to
+    @http_handle.respond_to(:wiggle, 'hello')
+    with_config(:normalize_json_string_encodings => false) do
+      NewRelic::Agent::EncodingNormalizer.expects(:normalize_object).never
+      @service.send(:invoke_remote, 'wiggle', [{ 'foo' => 'bar' }])
     end
+  end
 
-    def test_skips_normalization_if_configured_to
-      @http_handle.respond_to(:wiggle, 'hello')
-      with_config(:normalize_json_string_encodings => false) do
-        NewRelic::JSONWrapper.expects(:normalize).never
-        @service.send(:invoke_remote, 'wiggle', [{ 'foo' => 'bar' }])
-      end
-    end
-
-    def test_json_marshaller_handles_binary_strings
-      input_string = (0..255).to_a.pack("C*")
-      roundtripped_string = roundtrip_data(input_string)
-
-      if NewRelic::LanguageSupport.supports_string_encodings?
-        assert_equal(Encoding.find('ASCII-8BIT'), input_string.encoding)
-      end
-
-      expected = force_to_utf8(input_string.dup)
-      assert_equal(expected, roundtripped_string)
-    end
+  def test_json_marshaller_handles_binary_strings
+    input_string = (0..255).to_a.pack("C*")
+    roundtripped_string = roundtrip_data(input_string)
+    assert_equal(Encoding.find('ASCII-8BIT'), input_string.encoding)
+    expected = force_to_utf8(input_string.dup)
+    assert_equal(expected, roundtripped_string)
+  end
 
-    if NewRelic::LanguageSupport.supports_string_encodings?
-      def test_json_marshaller_handles_strings_with_incorrect_encoding
-        input_string = (0..255).to_a.pack("C*").force_encoding("UTF-8")
-        roundtripped_string = roundtrip_data(input_string)
+  def test_json_marshaller_handles_strings_with_incorrect_encoding
+    input_string = (0..255).to_a.pack("C*").force_encoding("UTF-8")
+    roundtripped_string = roundtrip_data(input_string)
 
-        assert_equal(Encoding.find('UTF-8'), input_string.encoding)
-        expected = input_string.dup.force_encoding('ISO-8859-1').encode('UTF-8')
-        assert_equal(expected, roundtripped_string)
-      end
-    end
+    assert_equal(Encoding.find('UTF-8'), input_string.encoding)
+    expected = input_string.dup.force_encoding('ISO-8859-1').encode('UTF-8')
+    assert_equal(expected, roundtripped_string)
+  end
 
-    def test_json_marshaller_failure_when_not_normalizing
-      input_string = (0..255).to_a.pack("C*")
-      assert_raises(NewRelic::Agent::SerializationError) do
-        roundtrip_data(input_string, false)
-      end
+  def test_json_marshaller_failure_when_not_normalizing
+    input_string = (0..255).to_a.pack("C*")
+    assert_raises(NewRelic::Agent::SerializationError) do
+      roundtrip_data(input_string, false)
     end
+  end
 
-    def test_json_marshaller_should_handle_crazy_strings
-      root = generate_object_graph_with_crazy_strings
-      result = roundtrip_data(root)
+  def test_json_marshaller_should_handle_crazy_strings
+    root = generate_object_graph_with_crazy_strings
+    result = roundtrip_data(root)
 
-      # Note that there's technically a possibility of collision here:
-      # if two of the randomly-generated key strings happen to normalize to the
-      # same value, we might see <100 results, but the chances of this seem
-      # vanishingly small.
-      assert_equal(100, result.length)
-    end
+    # Note that there's technically a possibility of collision here:
+    # if two of the randomly-generated key strings happen to normalize to the
+    # same value, we might see <100 results, but the chances of this seem
+    # vanishingly small.
+    assert_equal(100, result.length)
+  end
 
-    def test_normalization_should_account_for_to_collector_array
-      binary_string = generate_random_byte_sequence
-      data = DummyDataClass.new(binary_string, [])
-      result = roundtrip_data(data)
+  def test_normalization_should_account_for_to_collector_array
+    binary_string = generate_random_byte_sequence
+    data = DummyDataClass.new(binary_string, [])
+    result = roundtrip_data(data)
 
-      expected_string = force_to_utf8(binary_string)
-      assert_equal(expected_string, result[0])
-    end
+    expected_string = force_to_utf8(binary_string)
+    assert_equal(expected_string, result[0])
+  end
 
-    def test_normalization_should_account_for_to_collector_array_with_nested_encodings
-      binary_string = generate_random_byte_sequence
-      data = DummyDataClass.new(binary_string, [binary_string])
-      result = roundtrip_data(data)
+  def test_normalization_should_account_for_to_collector_array_with_nested_encodings
+    binary_string = generate_random_byte_sequence
+    data = DummyDataClass.new(binary_string, [binary_string])
+    result = roundtrip_data(data)
 
-      expected_string = force_to_utf8(binary_string)
-      assert_equal(expected_string, result[0])
+    expected_string = force_to_utf8(binary_string)
+    assert_equal(expected_string, result[0])
 
-      base64_encoded_compressed_json_field = result[1]
-      compressed_json_field = Base64.decode64(base64_encoded_compressed_json_field)
-      json_field = Zlib::Inflate.inflate(compressed_json_field)
-      field = JSON.parse(json_field)
+    base64_encoded_compressed_json_field = result[1]
+    compressed_json_field = Base64.decode64(base64_encoded_compressed_json_field)
+    json_field = Zlib::Inflate.inflate(compressed_json_field)
+    field = JSON.parse(json_field)
 
-      assert_equal([expected_string], field)
-    end
+    assert_equal([expected_string], field)
   end
 
   def test_compress_request_if_needed_compresses_large_payloads
@@ -782,11 +774,7 @@ class NewRelicServiceTest < Minitest::Test
   end
 
   def force_to_utf8(string)
-    if NewRelic::LanguageSupport.supports_string_encodings?
-      string.force_encoding('ISO-8859-1').encode('UTF-8')
-    else
-      Iconv.iconv('utf-8', 'iso-8859-1', string).join
-    end
+    string.force_encoding('ISO-8859-1').encode('UTF-8')
   end
 
   def generate_random_byte_sequence(length=255, encoding=nil)
@@ -811,11 +799,7 @@ class NewRelicServiceTest < Minitest::Test
   end
 
   def random_encoding
-    if NewRelic::LanguageSupport.supports_string_encodings?
-      Encoding.list.sample
-    else
-      nil
-    end
+    Encoding.list.sample
   end
 
   def roundtrip_data(data, normalize = true)

data/test/new_relic/agent/pipe_channel_manager_test.rb

@@ -40,24 +40,23 @@ class NewRelic::Agent::PipeChannelManagerTest < Minitest::Test
     NewRelic::Agent::PipeChannelManager.listener.close_all_pipes
   end
 
-  if NewRelic::LanguageSupport.can_fork? && !NewRelic::LanguageSupport.using_version?('1.9.1')
+  if NewRelic::LanguageSupport.can_fork?
     def test_listener_merges_timeslice_metrics
       metric = 'Custom/test/method'
-      engine = NewRelic::Agent.agent.stats_engine
-      engine.get_stats_no_scope(metric).record_data_point(1.0)
+
+      NewRelic::Agent.record_metric(metric, 1.0)
 
       start_listener_with_pipe(666)
 
       run_child(666) do
         NewRelic::Agent.after_fork
         new_engine = NewRelic::Agent::StatsEngine.new
-        new_engine.get_stats_no_scope(metric).record_data_point(2.0)
+        new_engine.tl_record_unscoped_metrics(metric, 2.0)
         service = NewRelic::Agent::PipeService.new(666)
         service.metric_data(new_engine.harvest!)
       end
 
       assert_metrics_recorded(metric => { :total_call_time => 3.0 })
-      engine.reset!
     end
 
     def test_listener_merges_transaction_traces
@@ -259,10 +258,6 @@ class NewRelic::Agent::PipeChannelManagerTest < Minitest::Test
   end
 
   def test_listener_pipes_race_condition
-    # 1.8.7 doesn't have easy singleton_class access, but also doesn't have
-    # races thanks to green threads and the GIL, so pitch it!
-    return if RUBY_VERSION < "1.9.2"
-
     begin
       listener = NewRelic::Agent::PipeChannelManager.listener
       listener.instance_variable_set(:@select_timeout, 0.00001)

data/test/new_relic/agent/pipe_service_test.rb

@@ -36,8 +36,7 @@ class PipeServiceTest < Minitest::Test
     service.metric_data({})
   end
 
-  if NewRelic::LanguageSupport.can_fork? &&
-      !NewRelic::LanguageSupport.using_version?('1.9.1')
+  if NewRelic::LanguageSupport.can_fork?
 
     def test_metric_data
       received_data = data_from_forked_process do
@@ -128,7 +127,7 @@ class PipeServiceTest < Minitest::Test
 
   def generate_metric_data(metric_name, data=1.0)
     engine = NewRelic::Agent::StatsEngine.new
-    engine.get_stats_no_scope(metric_name).record_data_point(data)
+    engine.tl_record_unscoped_metrics(metric_name, data)
     engine.harvest!
   end
 

data/test/new_relic/agent/rpm_agent_test.rb

@@ -88,8 +88,4 @@ class NewRelic::Agent::RpmAgentTest < Minitest::Test
   def test_agent_version_string
     assert_match(/\d\.\d+\.\d+/, NewRelic::VERSION::STRING)
   end
-
-  def test_record_transaction
-    NewRelic::Agent.record_transaction 0.5, 'uri' => "/users/create?foo=bar"
-  end
 end

data/test/new_relic/agent/sampled_buffer_test.rb

@@ -2,8 +2,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 'test/new_relic/agent/event_buffer_test_cases'
+require File.expand_path '../../../test_helper', __FILE__
+require 'new_relic/agent/event_buffer_test_cases'
 
 module NewRelic::Agent
   class SampledBufferTest < Minitest::Test

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

@@ -48,4 +48,32 @@ class NewRelic::Agent::Samplers::CpuSamplerTest < Minitest::Test
     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

@@ -0,0 +1,66 @@
+# -*- 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/sized_buffer_test.rb

@@ -3,7 +3,7 @@
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
-require 'test/new_relic/agent/event_buffer_test_cases'
+require 'new_relic/agent/event_buffer_test_cases'
 require 'new_relic/agent/sized_buffer'
 
 module NewRelic::Agent

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

@@ -30,7 +30,7 @@ class NewRelic::Agent::StatsEngine
 
     def test_init_profiler_for_ruby_19_and_greater
       return unless defined?(::GC::Profiler)
-      return if NewRelic::LanguageSupport.using_engine?('jruby')
+      return if NewRelic::LanguageSupport.jruby?
 
       ::GC::Profiler.stubs(:enabled?).returns(true)
 
@@ -38,26 +38,14 @@ class NewRelic::Agent::StatsEngine
                    GCProfiler.init.class)
     end
 
-    def test_init_profiler_for_rbx_uses_stdlib
-      return unless defined?(::Rubinius::GC)
-
-      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
 
-    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)
+    if !NewRelic::LanguageSupport.jruby?
       def test_record_delta_returns_delta_in_seconds
         GCProfiler.init