newrelic_rpm 3.9.1.236 → 3.9.2.239

data/test/new_relic/agent/method_tracer_test.rb

@@ -23,8 +23,7 @@ class Insider
   def thrower(level)
     if level == 0
       # don't use a real sampler because we can't instantiate one
-      # sampler = NewRelic::Agent::TransactionSampler.new(NewRelic::Agent.instance)
-      sampler = "<none>"
+      # NewRelic::Agent::TransactionSampler.new(NewRelic::Agent.instance)
       begin
         fail "This should not have worked."
       rescue

data/test/new_relic/agent/new_relic_service_test.rb

@@ -16,7 +16,7 @@ class NewRelicServiceKeepAliveTest < Minitest::Test
   end
 
   def stub_net_http_handle(overrides = {})
-    defaults = { :start => true, :finish => true, :address => '10.10.10.10', :port => 30303, :started? => true }
+    defaults = { :address => '10.10.10.10', :port => 30303, :started? => true }
     stub('http_handle', defaults.merge(overrides))
   end
 
@@ -42,6 +42,10 @@ class NewRelicServiceKeepAliveTest < Minitest::Test
     handle2 = stub_net_http_handle
     @service.stubs(:create_http_connection).returns(handle1, handle2)
 
+    handle1.expects(:start).once
+    handle1.expects(:finish).once
+    handle2.expects(:start).never
+
     block_ran = false
     @service.session do
       block_ran = true
@@ -78,6 +82,25 @@ class NewRelicServiceKeepAliveTest < Minitest::Test
     assert(block_ran)
   end
 
+  def test_session_does_not_close_connection_if_aggressive_keepalive_on
+    defaults = { :address => '10.10.10.10', :port => 30303, :started? => true }
+    handle = stub('http_handle', defaults)
+
+    handle.expects(:start).once
+    handle.expects(:finish).never
+
+    @service.stubs(:create_http_connection).returns(handle)
+
+    calls_to_block = 0
+
+    with_config(:aggressive_keepalive => true) do
+      2.times do
+        @service.session { calls_to_block += 1 }
+      end
+    end
+
+    assert_equal(2, calls_to_block)
+  end
 end
 
 class NewRelicServiceTest < Minitest::Test
@@ -210,7 +233,7 @@ class NewRelicServiceTest < Minitest::Test
     @service.metric_data(stats_hash)
     payload = @http_handle.last_request_payload
     _, last_harvest_timestamp, harvest_timestamp, _ = payload
-    assert_equal(t0.to_f, harvest_timestamp)
+    assert_in_delta(t0.to_f, harvest_timestamp, 0.0001)
 
     t1 = advance_time(10)
     stats_hash.harvested_at = t1
@@ -218,8 +241,8 @@ class NewRelicServiceTest < Minitest::Test
     @service.metric_data(stats_hash)
     payload = @http_handle.last_request_payload
     _, last_harvest_timestamp, harvest_timestamp, _ = payload
-    assert_equal(t1.to_f, harvest_timestamp)
-    assert_equal(t0.to_f, last_harvest_timestamp)
+    assert_in_delta(t1.to_f, harvest_timestamp, 0.0001)
+    assert_in_delta(t0.to_f, last_harvest_timestamp, 0.0001)
   end
 
   def test_fill_metric_id_cache_from_collect_response
@@ -265,7 +288,7 @@ class NewRelicServiceTest < Minitest::Test
     @service.metric_data(stats_hash)
 
     timeslice_start = @http_handle.last_request_payload[1]
-    assert timeslice_start >= t0.to_f + 10
+    assert_in_delta(timeslice_start, t0.to_f + 10, 0.0001)
   end
 
   def test_error_data
@@ -401,10 +424,12 @@ class NewRelicServiceTest < Minitest::Test
     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', {})
+      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
     end
 
@@ -420,18 +445,30 @@ class NewRelicServiceTest < Minitest::Test
       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')
+      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_strings_with_incorrect_encoding
-      input_string = (0..255).to_a.pack("C*").force_encoding("UTF-8")
-      roundtripped_string = roundtrip_data(input_string)
+    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)
 
-      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)
+        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
+
+    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
@@ -450,7 +487,7 @@ class NewRelicServiceTest < Minitest::Test
       data = DummyDataClass.new(binary_string, [])
       result = roundtrip_data(data)
 
-      expected_string = binary_string.force_encoding('ISO-8859-1').encode('UTF-8')
+      expected_string = force_to_utf8(binary_string)
       assert_equal(expected_string, result[0])
     end
 
@@ -459,7 +496,7 @@ class NewRelicServiceTest < Minitest::Test
       data = DummyDataClass.new(binary_string, [binary_string])
       result = roundtrip_data(data)
 
-      expected_string = binary_string.force_encoding('ISO-8859-1').encode('UTF-8')
+      expected_string = force_to_utf8(binary_string)
       assert_equal(expected_string, result[0])
 
       base64_encoded_compressed_json_field = result[1]
@@ -612,10 +649,20 @@ class NewRelicServiceTest < Minitest::Test
     hash
   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
+  end
+
   def generate_random_byte_sequence(length=255, encoding=nil)
     bytes = []
     alphabet = (0..255).to_a
-    length.times { bytes << alphabet.sample }
+    meth = alphabet.respond_to?(:sample) ? :sample : :choice
+    length.times { bytes << alphabet.send(meth) }
+
     string = bytes.pack("C*")
     string.force_encoding(encoding) if encoding
     string
@@ -623,19 +670,28 @@ class NewRelicServiceTest < Minitest::Test
 
   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)
+      key_string = generate_random_byte_sequence(255, random_encoding)
+      value_string = generate_random_byte_sequence(255, random_encoding)
       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]
+  def random_encoding
+    if NewRelic::LanguageSupport.supports_string_encodings?
+      Encoding.list.sample
+    else
+      nil
+    end
+  end
+
+  def roundtrip_data(data, normalize = true)
+    with_config(:normalize_json_string_encodings => normalize) do
+      @http_handle.respond_to(:roundtrip, 'roundtrip')
+      @service.send(:invoke_remote, 'roundtrip', data)
+      @http_handle.last_request_payload[0]
+    end
   end
 
   class DummyDataClass

data/test/new_relic/agent/pipe_channel_manager_test.rb

@@ -41,7 +41,7 @@ class NewRelic::Agent::PipeChannelManagerTest < Minitest::Test
       engine = NewRelic::Agent.agent.stats_engine
       engine.get_stats_no_scope(metric).record_data_point(1.0)
 
-      listener = start_listener_with_pipe(666)
+      start_listener_with_pipe(666)
 
       run_child(666) do
         NewRelic::Agent.after_fork
@@ -60,7 +60,7 @@ class NewRelic::Agent::PipeChannelManagerTest < Minitest::Test
       sample = run_sample_trace
       assert_equal(1, sampler.count)
 
-      listener = start_listener_with_pipe(667)
+      start_listener_with_pipe(667)
       run_child(667) do
         NewRelic::Agent.after_fork
         with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
@@ -82,7 +82,7 @@ class NewRelic::Agent::PipeChannelManagerTest < Minitest::Test
 
       assert_equal(1, NewRelic::Agent.agent.error_collector.errors.size)
 
-      listener = start_listener_with_pipe(668)
+      start_listener_with_pipe(668)
 
       run_child(668) do
         NewRelic::Agent.after_fork
@@ -100,7 +100,7 @@ class NewRelic::Agent::PipeChannelManagerTest < Minitest::Test
     def test_listener_merges_analytics_events
       request_sampler = NewRelic::Agent.agent.instance_variable_get(:@request_sampler)
 
-      listener = start_listener_with_pipe(699)
+      start_listener_with_pipe(699)
       NewRelic::Agent.agent.stubs(:connected?).returns(true)
       run_child(699) do
         NewRelic::Agent.after_fork(:report_to_channel => 699)
@@ -110,7 +110,7 @@ class NewRelic::Agent::PipeChannelManagerTest < Minitest::Test
           :duration => 10,
           :type => :controller
         })
-        NewRelic::Agent.agent.send(:transmit_data)
+        NewRelic::Agent.agent.send(:transmit_transaction_event_data)
       end
 
       assert_equal(1, request_sampler.samples.size)
@@ -120,7 +120,7 @@ class NewRelic::Agent::PipeChannelManagerTest < Minitest::Test
       sampler = NewRelic::Agent.agent.sql_sampler
       create_sql_sample(sampler)
 
-      listener = start_listener_with_pipe(667)
+      start_listener_with_pipe(667)
       run_child(667) do
         NewRelic::Agent.after_fork
         create_sql_sample(sampler)

data/test/new_relic/agent/rpm_agent_test.rb

@@ -15,13 +15,6 @@ class NewRelic::Agent::RpmAgentTest < Minitest::Test
     NewRelic::Agent.instance.shutdown
   end
 
-  def test_agent_setup
-    assert(NewRelic::Agent.instance.class == NewRelic::Agent::Agent)
-    assert_raises(RuntimeError) do
-      NewRelic::Control.instance.init_plugin(:agent_enabled => false)
-    end
-  end
-
   def test_public_apis
     assert_raises(RuntimeError) do
       NewRelic::Agent.set_sql_obfuscator(:unknown) { |sql| puts sql }
@@ -102,7 +95,7 @@ class NewRelic::Agent::RpmAgentTest < Minitest::Test
   end
 
   def test_agent_version_string
-    assert_match /\d\.\d+\.\d+/, NewRelic::VERSION::STRING
+    assert_match(/\d\.\d+\.\d+/, NewRelic::VERSION::STRING)
   end
 
   def test_record_transaction

data/test/new_relic/agent/sql_sampler_test.rb

@@ -231,8 +231,8 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
                 "Database/test/select", {}, 1.2),
         "tx_name", "uri")
 
-    assert -2147483648 <= sql_trace.sql_id, "sql_id too small"
-    assert 2147483647 >= sql_trace.sql_id, "sql_id too large"
+    assert(-2147483648 <= sql_trace.sql_id, "sql_id too small")
+    assert( 2147483647 >= sql_trace.sql_id, "sql_id too large")
   end
 
   def test_sends_obfuscated_queries_when_configured
@@ -298,17 +298,18 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
       @sampler.harvest_slow_sql(data)
       sql_traces = @sampler.harvest!
 
-      params = RUBY_VERSION >= '1.9.2' ? "eJyrrgUAAXUA+Q==\n" : {}
-      expected = [ 'WebTransaction/Controller/c/a', '/c/a', 526336943,
-                   'select * from test', 'Database/test/select',
-                   1, 1500, 1500, 1500, params ]
-
       if NewRelic::Agent::NewRelicService::JsonMarshaller.is_supported?
         marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
+        params = "eJyrrgUAAXUA+Q==\n"
       else
         marshaller = NewRelic::Agent::NewRelicService::PrubyMarshaller.new
+        params = {}
       end
 
+      expected = [ 'WebTransaction/Controller/c/a', '/c/a', 526336943,
+                   'select * from test', 'Database/test/select',
+                   1, 1500, 1500, 1500, params ]
+
       assert_equal expected, sql_traces[0].to_collector_array(marshaller.default_encoder)
     end
   end
@@ -321,11 +322,12 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
 
     if NewRelic::Agent::NewRelicService::JsonMarshaller.is_supported?
       marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
+      params = "eJyrrgUAAXUA+Q==\n"
     else
       marshaller = NewRelic::Agent::NewRelicService::PrubyMarshaller.new
+      params = {}
     end
 
-    params = RUBY_VERSION >= '1.9.2' ? "eJyrrgUAAXUA+Q==\n" : {}
     expected = [ "path", "uri", 1234, "query", "transaction",
                  10, 12000, 12000, 12000, params]
 

data/test/new_relic/agent/threading/backtrace_service_test.rb

@@ -61,7 +61,7 @@ if NewRelic::Agent::Threading::BacktraceService.is_supported?
       def test_stop_clears_buffered_backtraces
         fake_worker_loop(@service)
 
-        thread = fake_thread(:request)
+        fake_thread(:request)
 
         @service.subscribe('foo')
         @service.poll

data/test/new_relic/agent/traced_method_stack_test.rb

@@ -10,7 +10,7 @@ class NewRelic::Agent::TracedMethodStackTest < Minitest::Test
     @frame_stack = NewRelic::Agent::TracedMethodStack.new
   end
 
-  def test_scope__overlap
+  def test_scope_overlap
     freeze_time
 
     in_transaction('orlando') do
@@ -36,21 +36,10 @@ class NewRelic::Agent::TracedMethodStackTest < Minitest::Test
       })
   end
 
-
-  def test_scope_failure
-    state = NewRelic::Agent::TransactionState.tl_get
-
-    scope1 = @frame_stack.push_frame(state, :scope1)
-    scope2 = @frame_stack.push_frame(state, :scope2)
-    assert_raises(RuntimeError) do
-      @frame_stack.pop_frame(state, scope1, "name 1", Time.now.to_f)
-    end
-  end
-
   def test_children_time
     state = NewRelic::Agent::TransactionState.tl_get
 
-    t1 = freeze_time
+    freeze_time
     expected1 = @frame_stack.push_frame(state, :a)
     advance_time(0.001)
     t2 = Time.now
@@ -145,6 +134,49 @@ class NewRelic::Agent::TracedMethodStackTest < Minitest::Test
     assert_sampler_enabled_with(false, :'transaction_tracer.enabled' => false, :developer_mode => false)
   end
 
+  def test_fetch_matching_frame_fetches_the_next_matching_frame
+    state = NewRelic::Agent::TransactionState.tl_get
+    frame = @frame_stack.push_frame(state, :a,  0)
+
+    result = @frame_stack.fetch_matching_frame(frame)
+
+    assert_equal :a, result.tag
+    assert_equal frame, result
+  end
+
+  def test_fetch_matching_frame_discards_mismatched_frames
+    state = NewRelic::Agent::TransactionState.tl_get
+    frame = @frame_stack.push_frame(state, :a,  0)
+    @frame_stack.push_frame(state, :b,  0)
+
+    result = @frame_stack.fetch_matching_frame(frame)
+
+    assert_equal :a, result.tag
+    assert_equal frame, result
+  end
+
+  def test_fetch_matching_frame_raises_an_error_if_no_match
+    state = NewRelic::Agent::TransactionState.tl_get
+    frame = @frame_stack.push_frame(state, :a,  0)
+    @frame_stack.fetch_matching_frame(frame)
+
+    error = assert_raises(RuntimeError) do
+      @frame_stack.fetch_matching_frame(frame)
+    end
+
+    assert_match(/not found/, error.message)
+  end
+
+  def test_fetch_matching_frame_logs_any_unexpected_frame_tags
+    state = NewRelic::Agent::TransactionState.tl_get
+    frame = @frame_stack.push_frame(state, :a,  0)
+    @frame_stack.push_frame(state, :unexpected,  0)
+
+    expects_logging(:info, includes("unexpected"))
+
+    @frame_stack.fetch_matching_frame(frame)
+  end
+
   def assert_sampler_enabled_with(expected, opts={})
     with_config(opts) do
       assert_equal expected, @frame_stack.sampler_enabled?

data/test/new_relic/agent/transaction_sample_builder_test.rb

@@ -178,7 +178,7 @@ class NewRelic::Agent::TransationSampleBuilderTest < Minitest::Test
     config = { :'transaction_tracer.transaction_threshold' => 4.0 }
 
     in_transaction do
-      with_config(config, :do_not_cast => true) do
+      with_config(config) do
         NewRelic::Agent::TransactionState.tl_get.current_transaction.stubs(:apdex_t).returns(1.5)
         assert_equal 4.0, @builder.transaction_trace_threshold
       end
@@ -210,7 +210,6 @@ class NewRelic::Agent::TransationSampleBuilderTest < Minitest::Test
       end
       assert(child.entry_timestamp >= parent.entry_timestamp,
              "#{child.entry_timestamp} !>= #{parent.entry_timestamp}")
-      last_metric = child
 
       validate_segment(child, check_names)
     end

data/test/new_relic/agent/transaction_test.rb

@@ -116,7 +116,7 @@ class NewRelic::Agent::TransactionTest < Minitest::Test
       :apdex_t => 2.0
     }
 
-    with_config(config, :do_not_cast => true) do
+    with_config(config) do
       in_transaction('Controller/foo/bar') do |txn|
         assert_equal 1.5, txn.apdex_t
       end
@@ -137,7 +137,7 @@ class NewRelic::Agent::TransactionTest < Minitest::Test
   def test_update_apdex_records_correct_apdex_for_key_transaction
     t0 = freeze_time
 
-    with_config(KEY_TRANSACTION_CONFIG, :do_not_cast => true) do
+    with_config(KEY_TRANSACTION_CONFIG) do
       in_web_transaction('Controller/slow/txn') do
         state = NewRelic::Agent::TransactionState.tl_get
         txn = state.current_transaction
@@ -157,7 +157,7 @@ class NewRelic::Agent::TransactionTest < Minitest::Test
   def test_update_apdex_records_correct_apdex_for_non_key_transaction
     t0 = freeze_time
 
-    with_config(KEY_TRANSACTION_CONFIG, :do_not_cast => true) do
+    with_config(KEY_TRANSACTION_CONFIG) do
       in_web_transaction('Controller/other/txn') do
         state = NewRelic::Agent::TransactionState.tl_get
         txn = state.current_transaction