newrelic_rpm 3.7.1.188 → 3.7.2.190.beta

data/test/new_relic/agent/method_visibility_test.rb

@@ -2,7 +2,7 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
-class MethodVisibilityTest < Test::Unit::TestCase
+class MethodVisibilityTest < MiniTest::Unit::TestCase
 
   class InstrumentedClass
     include NewRelic::Agent::MethodTracer

data/test/new_relic/agent/new_relic_service_test.rb

@@ -8,7 +8,7 @@ require 'new_relic/agent/commands/thread_profiler_session'
 
 # Tests of HTTP Keep Alive implementation that require a different setup and
 # set of mocks.
-class NewRelicServiceKeepAliveTest < Test::Unit::TestCase
+class NewRelicServiceKeepAliveTest < MiniTest::Unit::TestCase
   def setup
     @server = NewRelic::Control::Server.new('somewhere.example.com',
                                             30303, '10.10.10.10')
@@ -80,7 +80,7 @@ class NewRelicServiceKeepAliveTest < Test::Unit::TestCase
 
 end
 
-class NewRelicServiceTest < Test::Unit::TestCase
+class NewRelicServiceTest < MiniTest::Unit::TestCase
   def initialize(*_)
     [ :HTTPSuccess,
       :HTTPUnauthorized,
@@ -330,7 +330,7 @@ class NewRelicServiceTest < Test::Unit::TestCase
   end
 
   def test_should_throw_received_errors
-    assert_raise NewRelic::Agent::ServerConnectionException do
+    assert_raises NewRelic::Agent::ServerConnectionException do
       @service.send(:invoke_remote, :bogus_method)
     end
   end
@@ -356,7 +356,7 @@ class NewRelicServiceTest < Test::Unit::TestCase
   def test_should_raise_exception_on_401
     @http_handle.reset
     @http_handle.respond_to(:get_redirect_host, 'bad license', :code => 401)
-    assert_raise NewRelic::Agent::LicenseException do
+    assert_raises NewRelic::Agent::LicenseException do
       @service.get_redirect_host
     end
   end
@@ -364,7 +364,7 @@ class NewRelicServiceTest < Test::Unit::TestCase
   # protocol 9
   def test_should_raise_exception_on_413
     @http_handle.respond_to(:metric_data, 'too big', :code => 413)
-    assert_raise NewRelic::Agent::UnrecoverableServerException do
+    assert_raises NewRelic::Agent::UnrecoverableServerException do
       stats_hash = NewRelic::Agent::StatsHash.new
       @service.metric_data(stats_hash)
     end
@@ -373,13 +373,13 @@ class NewRelicServiceTest < Test::Unit::TestCase
   # protocol 9
   def test_should_raise_exception_on_415
     @http_handle.respond_to(:metric_data, 'too big', :code => 415)
-    assert_raise NewRelic::Agent::UnrecoverableServerException do
+    assert_raises NewRelic::Agent::UnrecoverableServerException do
       stats_hash = NewRelic::Agent::StatsHash.new
       @service.metric_data(stats_hash)
     end
   end
 
-  if NewRelic::LanguageSupport.using_version?('1.9')
+  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"]}')
@@ -387,28 +387,93 @@ class NewRelicServiceTest < Test::Unit::TestCase
 
     def test_json_marshaller_handles_errors_from_collector
       marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
-      assert_raise(NewRelic::Agent::NewRelicService::CollectorError,
+      assert_raises(NewRelic::Agent::NewRelicService::CollectorError,
                    'JavaCrash: error message') do
         marshaller.load('{"exception": {"message": "error message", "error_type": "JavaCrash"}}')
       end
     end
 
-    def test_use_pruby_marshaller_if_error_using_json
-      json_marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
-      @service.instance_variable_set(:@marshaller, json_marshaller)
-      JSON.stubs(:dump).raises(RuntimeError.new('blah'))
-      @http_handle.respond_to(:transaction_sample_data, 'ok', :format => :pruby)
+    def test_raises_serialization_error_if_json_serialization_fails
+      ::NewRelic::JSONWrapper.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_encoding_normalization_fails
+      @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::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)
+
+      assert_equal(Encoding.find('ASCII-8BIT'), 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_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
+
+    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
+
+    def test_normalization_should_account_for_to_collector_array
+      binary_string = generate_random_byte_sequence
+      data = DummyDataClass.new(binary_string, [])
+      result = roundtrip_data(data)
 
-      @service.transaction_sample_data([])
+      expected_string = binary_string.force_encoding('ISO-8859-1').encode('UTF-8')
+      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)
+
+      expected_string = binary_string.force_encoding('ISO-8859-1').encode('UTF-8')
+      assert_equal(expected_string, result[0])
 
-      assert_equal('NewRelic::Agent::NewRelicService::PrubyMarshaller',
-                   @service.marshaller.class.name)
+      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
   end
 
   def test_pruby_marshaller_handles_errors_from_collector
     marshaller = NewRelic::Agent::NewRelicService::PrubyMarshaller.new
-    assert_raise(NewRelic::Agent::NewRelicService::CollectorError, 'error message') do
+    assert_raises(NewRelic::Agent::NewRelicService::CollectorError, 'error message') do
       marshaller.load(Marshal.dump({"exception" => {"message" => "error message",
                                        "error_type" => "JavaCrash"}}))
     end
@@ -533,6 +598,46 @@ class NewRelicServiceTest < Test::Unit::TestCase
     hash
   end
 
+  def generate_random_byte_sequence(length=255, encoding=nil)
+    bytes = []
+    alphabet = (0..255).to_a
+    length.times { bytes << alphabet.sample }
+    string = bytes.pack("C*")
+    string.force_encoding(encoding) if encoding
+    string
+  end
+
+  def generate_object_graph_with_crazy_strings
+    strings = {}
+    encodings = Encoding.list
+    100.times do
+      key_string = generate_random_byte_sequence(255, encodings.sample)
+      value_string = generate_random_byte_sequence(255, encodings.sample)
+      strings[key_string] = value_string
+    end
+    strings
+  end
+
+  def roundtrip_data(data)
+    @http_handle.respond_to(:roundtrip, 'roundtrip')
+    @service.send(:invoke_remote, 'roundtrip', data)
+    @http_handle.last_request_payload[0]
+  end
+
+  class DummyDataClass
+    def initialize(string, object_graph)
+      @string = string
+      @object_graph = object_graph
+    end
+
+    def to_collector_array(encoder)
+      [
+        @string,
+        encoder.encode(@object_graph)
+      ]
+    end
+  end
+
   class HTTPHandle
     attr_accessor :read_timeout, :route_table
 
@@ -600,13 +705,18 @@ class NewRelicServiceTest < Test::Unit::TestCase
 
     def last_request_payload
       return nil unless @last_request && @last_request.body
+
+      body = @last_request.body
+      content_encoding = @last_request['Content-Encoding']
+      body = Zlib::Inflate.inflate(body) if content_encoding == 'deflate'
+
       uri = URI.parse(@last_request.path)
       params = CGI.parse(uri.query)
       format = params['marshal_format'].first
       if format == 'json'
-        JSON.load(@last_request.body)
+        JSON.load(body)
       else
-        Marshal.load(@last_request.body)
+        Marshal.load(body)
       end
     end
   end

data/test/new_relic/agent/obfuscator_test.rb

@@ -5,7 +5,7 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
 require "new_relic/agent/obfuscator"
 
-class NewRelic::Agent::ObfuscatorTest < Test::Unit::TestCase
+class NewRelic::Agent::ObfuscatorTest < MiniTest::Unit::TestCase
 
   OBFUSCATION_KEY = (1..40).to_a.pack('c*')
   RUM_KEY_LENGTH  = 13

data/test/new_relic/agent/pipe_channel_manager_test.rb

@@ -6,148 +6,146 @@ require 'timeout'
 require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
 require 'new_relic/agent/pipe_channel_manager'
 
-class NewRelic::Agent::PipeChannelManagerTest < Test::Unit::TestCase
-  include TransactionSampleTestHelper
-
-  def setup
-    @test_config = { :developer_mode => true }
-    NewRelic::Agent.agent.drop_buffered_data
-    NewRelic::Agent.config.apply_config(@test_config)
-    NewRelic::Agent::PipeChannelManager.listener.close_all_pipes
-    NewRelic::Agent.manual_start
-    NewRelic::Agent::TransactionState.clear
-  end
-
-  def teardown
-    NewRelic::Agent::PipeChannelManager.listener.stop
-    NewRelic::Agent.shutdown
-    NewRelic::Agent.config.remove_config(@test_config)
-  end
-
-  def test_registering_a_pipe
-    NewRelic::Agent::PipeChannelManager.listener.wake.in.expects(:<<).with('.')
-    NewRelic::Agent::PipeChannelManager.register_report_channel(1)
-    pipe = NewRelic::Agent::PipeChannelManager.channels[1]
-
-    assert pipe.out.kind_of?(IO)
-    assert pipe.in.kind_of?(IO)
-
-    NewRelic::Agent::PipeChannelManager.listener.close_all_pipes
-  end
-
-  if NewRelic::LanguageSupport.can_fork? && !NewRelic::LanguageSupport.using_version?('1.9.1')
-    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)
-
-      listener = start_listener_with_pipe(666)
-
-      pid = Process.fork do
-        NewRelic::Agent.after_fork
-        new_engine = NewRelic::Agent::StatsEngine.new
-        new_engine.get_stats_no_scope(metric).record_data_point(2.0)
-        listener.pipes[666].write(:stats => new_engine.harvest!)
-      end
-      Process.wait(pid)
-      listener.stop
-
-      assert_equal(3.0, engine.lookup_stats(metric).total_call_time)
-      engine.reset!
-    end
-
-    def test_listener_merges_transaction_traces
-      sampler = NewRelic::Agent.agent.transaction_sampler
-      sample = run_sample_trace_on(sampler)
-      assert_equal(1, sampler.count)
-
-      listener = start_listener_with_pipe(667)
-      pid = Process.fork do
-        NewRelic::Agent.after_fork
-        with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
-          sample = run_sample_trace_on(sampler)
-          listener.pipes[667].write(:transaction_traces => sampler.harvest!)
-        end
-      end
-      Process.wait(pid)
-      listener.stop
-
-      assert_equal(2, sampler.count)
-    end
-
-    def test_listener_merges_error_traces
-      sampler = NewRelic::Agent.agent.error_collector
-      sampler.errors.clear
-      sampler.notice_error(Exception.new("message"), :uri => '/myurl/',
-                           :metric => 'path', :referer => 'test_referer',
-                           :request_params => {:x => 'y'})
-      NewRelic::Agent.agent.merge_data_from([nil, nil, sampler.errors])
-
-      assert_equal(1, NewRelic::Agent.agent.error_collector.errors.size)
-
-      listener = start_listener_with_pipe(668)
-
-      pid = Process.fork do
-        NewRelic::Agent.after_fork
-        new_sampler = NewRelic::Agent::ErrorCollector.new
-        new_sampler.notice_error(Exception.new("new message"), :uri => '/myurl/',
-                                 :metric => 'path', :referer => 'test_referer',
-                                 :request_params => {:x => 'y'})
-        listener.pipes[668].write(:error_traces => new_sampler.harvest!)
-      end
-      Process.wait(pid)
-      listener.stop
-
-      assert_equal(2, NewRelic::Agent.agent.error_collector.errors.size)
-    end
-
-    def pipe_finished?(id)
-      (!NewRelic::Agent::PipeChannelManager.channels[id] ||
-        NewRelic::Agent::PipeChannelManager.channels[id].closed?)
-    end
-
-    def assert_pipe_finished(id)
-      assert(pipe_finished?(id),
-        "Expected pipe with ID #{id} to be nil or closed")
-    end
-
-    def test_close_pipe_on_child_explicit_close
-      listener = start_listener_with_pipe(669)
-      pid = Process.fork do
-        NewRelic::Agent::PipeService.new(669)
-      end
-      Process.wait(pid)
-      listener.stop_listener_thread
-      assert_pipe_finished(669)
-    end
-
-    def test_close_pipe_on_child_exit
-      listener = start_listener_with_pipe(669)
-      pid = Process.fork do
-        NewRelic::Agent::PipeService.new(669)
-        exit!
-      end
-      Process.wait(pid)
-      listener.stop_listener_thread
-      assert_pipe_finished(669)
-    end
-
-    def test_manager_does_not_crash_when_given_bad_data
-      listener = start_listener_with_pipe(670)
-      assert_nothing_raised do
-        pid = Process.fork do
-          listener.pipes[670].in << 'some unloadable garbage'
-        end
-        Process.wait(pid)
-        listener.stop
-      end
-    end
-  end
-
-  def start_listener_with_pipe(pipe_id)
-    listener = NewRelic::Agent::PipeChannelManager.listener
-    listener.start
-    listener.register_pipe(pipe_id)
-    listener
-  end
-end
+#class NewRelic::Agent::PipeChannelManagerTest < MiniTest::Unit::TestCase
+#  include TransactionSampleTestHelper
+#
+#  def setup
+#    @test_config = { :developer_mode => true }
+#    NewRelic::Agent.agent.drop_buffered_data
+#    NewRelic::Agent.config.apply_config(@test_config)
+#    NewRelic::Agent::PipeChannelManager.listener.close_all_pipes
+#    NewRelic::Agent.manual_start
+#    NewRelic::Agent::TransactionState.clear
+#  end
+#
+#  def teardown
+#    NewRelic::Agent::PipeChannelManager.listener.stop
+#    NewRelic::Agent.shutdown
+#    NewRelic::Agent.config.remove_config(@test_config)
+#  end
+#
+#  def test_registering_a_pipe
+#    NewRelic::Agent::PipeChannelManager.listener.wake.in.expects(:<<).with('.')
+#    NewRelic::Agent::PipeChannelManager.register_report_channel(1)
+#    pipe = NewRelic::Agent::PipeChannelManager.channels[1]
+#
+#    assert pipe.out.kind_of?(IO)
+#    assert pipe.in.kind_of?(IO)
+#
+#    NewRelic::Agent::PipeChannelManager.listener.close_all_pipes
+#  end
+#
+#  if NewRelic::LanguageSupport.can_fork? && !NewRelic::LanguageSupport.using_version?('1.9.1')
+#    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)
+#
+#      listener = start_listener_with_pipe(666)
+#
+#      pid = Process.fork do
+#        NewRelic::Agent.after_fork
+#        new_engine = NewRelic::Agent::StatsEngine.new
+#        new_engine.get_stats_no_scope(metric).record_data_point(2.0)
+#        listener.pipes[666].write(:stats => new_engine.harvest!)
+#      end
+#      Process.wait(pid)
+#      listener.stop
+#
+#      assert_equal(3.0, engine.lookup_stats(metric).total_call_time)
+#      engine.reset!
+#    end
+#
+#    def test_listener_merges_transaction_traces
+#      sampler = NewRelic::Agent.agent.transaction_sampler
+#      sample = run_sample_trace_on(sampler)
+#      assert_equal(1, sampler.count)
+#
+#      listener = start_listener_with_pipe(667)
+#      pid = Process.fork do
+#        NewRelic::Agent.after_fork
+#        with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
+#          sample = run_sample_trace_on(sampler)
+#          listener.pipes[667].write(:transaction_traces => sampler.harvest!)
+#        end
+#      end
+#      Process.wait(pid)
+#      listener.stop
+#
+#      assert_equal(2, sampler.count)
+#    end
+#
+#    def test_listener_merges_error_traces
+#      sampler = NewRelic::Agent.agent.error_collector
+#      sampler.errors.clear
+#      sampler.notice_error(Exception.new("message"), :uri => '/myurl/',
+#                           :metric => 'path', :referer => 'test_referer',
+#                           :request_params => {:x => 'y'})
+#      NewRelic::Agent.agent.merge_data_from([nil, nil, sampler.errors])
+#
+#      assert_equal(1, NewRelic::Agent.agent.error_collector.errors.size)
+#
+#      listener = start_listener_with_pipe(668)
+#
+#      pid = Process.fork do
+#        NewRelic::Agent.after_fork
+#        new_sampler = NewRelic::Agent::ErrorCollector.new
+#        new_sampler.notice_error(Exception.new("new message"), :uri => '/myurl/',
+#                                 :metric => 'path', :referer => 'test_referer',
+#                                 :request_params => {:x => 'y'})
+#        listener.pipes[668].write(:error_traces => new_sampler.harvest!)
+#      end
+#      Process.wait(pid)
+#      listener.stop
+#
+#      assert_equal(2, NewRelic::Agent.agent.error_collector.errors.size)
+#    end
+#
+#    def pipe_finished?(id)
+#      (!NewRelic::Agent::PipeChannelManager.channels[id] ||
+#        NewRelic::Agent::PipeChannelManager.channels[id].closed?)
+#    end
+#
+#    def assert_pipe_finished(id)
+#      assert(pipe_finished?(id),
+#        "Expected pipe with ID #{id} to be nil or closed")
+#    end
+#
+#    def test_close_pipe_on_child_explicit_close
+#      listener = start_listener_with_pipe(669)
+#      pid = Process.fork do
+#        NewRelic::Agent::PipeService.new(669)
+#      end
+#      Process.wait(pid)
+#      listener.stop_listener_thread
+#      assert_pipe_finished(669)
+#    end
+#
+#    def test_close_pipe_on_child_exit
+#      listener = start_listener_with_pipe(669)
+#      pid = Process.fork do
+#        NewRelic::Agent::PipeService.new(669)
+#        exit!
+#      end
+#      Process.wait(pid)
+#      listener.stop_listener_thread
+#      assert_pipe_finished(669)
+#    end
+#
+#    def test_manager_does_not_crash_when_given_bad_data
+#      listener = start_listener_with_pipe(670)
+#      pid = Process.fork do
+#        listener.pipes[670].in << 'some unloadable garbage'
+#      end
+#      Process.wait(pid)
+#      listener.stop
+#    end
+#  end
+#
+#  def start_listener_with_pipe(pipe_id)
+#    listener = NewRelic::Agent::PipeChannelManager.listener
+#    listener.start
+#    listener.register_pipe(pipe_id)
+#    listener
+#  end
+#end