newrelic_rpm 3.9.6.257 → 3.9.7.266

data/test/new_relic/agent/event_buffer_test_cases.rb

@@ -0,0 +1,152 @@
+# 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/event_buffer'
+
+module NewRelic::Agent::EventBufferTestCases
+
+  # NOTE: Classes including this module must define `buffer_class`; for example:
+  #
+  # def buffer_class
+  #   MyVerySpecialBuffer
+  # end
+
+  def test_limits_itself_to_capacity
+    buffer = buffer_class.new(10)
+
+    11.times { |i| buffer.append(i) }
+
+    assert_equal(10, buffer.size       )
+    assert_equal(11, buffer.num_seen   )
+    assert_equal( 1, buffer.num_dropped)
+  end
+
+  def test_should_not_discard_items_if_not_needed_when_capacity_is_reset
+    buffer = buffer_class.new(10)
+    assert_equal(10, buffer.capacity)
+    10.times { |i| buffer << i }
+
+    buffer.capacity = 20
+    assert_equal(10, buffer.size       )
+    assert_equal(20, buffer.capacity   )
+    assert_equal(10, buffer.num_seen   )
+    assert_equal( 0, buffer.num_dropped)
+    assert_equal((0..9).to_a, buffer.to_a)
+  end
+
+  def test_reset_should_reset
+    buffer = buffer_class.new(10)
+    100.times { |i| buffer << i }
+    buffer.reset!
+    assert_equal(0, buffer.size)
+    assert_equal([], buffer.to_a)
+  end
+
+  def test_to_a_returns_copy_of_items_array
+    buffer = buffer_class.new(5)
+
+    5.times { |i| buffer.append(i) }
+
+    items = buffer.to_a
+    items << ['blarg']
+
+    assert_equal([0,1,2,3,4], buffer.to_a)
+  end
+
+  def test_reset_resets_stored_items
+    buffer = buffer_class.new(5)
+
+    5.times { |i| buffer.append(i) }
+    buffer.reset!
+
+    assert_equal([], buffer.to_a)
+  end
+
+  def test_buffer_full_works_properly
+    buffer = buffer_class.new(5)
+
+    4.times do |i|
+      buffer << i
+      assert_equal(false, buffer.full?, "#{buffer_class}#append should return false until buffer is full")
+    end
+
+    4.times do |i|
+      buffer << 'lava'
+      assert_equal(true, buffer.full?, "#{buffer_class}#append should return true once buffer is full")
+    end
+  end
+
+  def test_should_keep_all_samples_up_to_capacity
+    buffer = buffer_class.new(100)
+    all = []
+    100.times do |i|
+      buffer << i
+      all << i
+    end
+
+    assert_equal(100, buffer.size)
+    assert_equal(all, buffer.to_a)
+  end
+
+  def test_should_discard_items_as_needed_when_capacity_is_reset
+    buffer = buffer_class.new(10)
+    10.times { |i| buffer << i }
+
+    buffer.capacity = 5
+    assert_equal(5, buffer.size)
+
+    # We should have 5 unique values that were all in our original set of 0-9
+    assert_equal(5, buffer.to_a.uniq.size)
+    allowed_values = (0..9).to_a
+    buffer.to_a.each do |v|
+      assert_includes(allowed_values, v)
+    end
+    assert_equal(10, buffer.num_seen   )
+    assert_equal( 5, buffer.num_dropped)
+  end
+
+  def test_num_seen_counts_all_seen_samples_since_last_reset
+    buffer = buffer_class.new(10)
+    assert_equal(0, buffer.num_seen)
+
+    20.times { |i| buffer << i }
+    assert_equal(20, buffer.num_seen)
+
+    buffer.reset!
+    assert_equal(0, buffer.num_seen)
+  end
+
+  def test_append_increments_drop_count_when_over_capacity
+    buffer = buffer_class.new(5)
+
+    5.times { |i| buffer.append(i) }
+    assert_equal(0, buffer.num_dropped)
+
+    5.times { |i| buffer.append(i) }
+    assert_equal(5, buffer.num_dropped)
+  end
+
+  def test_reset_resets_drop_count
+    buffer = buffer_class.new(5)
+
+    10.times { |i| buffer.append(i) }
+    assert_equal(5, buffer.num_dropped)
+
+    buffer.reset!
+    assert_equal(0, buffer.num_dropped)
+  end
+
+  def test_sample_rate
+    buffer = buffer_class.new(10)
+    assert_equal(0, buffer.sample_rate)
+
+    10.times { buffer << 'x' }
+    assert_equal(1.0, buffer.sample_rate)
+
+    10.times { buffer << 'x' }
+    assert_equal(0.5, buffer.sample_rate)
+  end
+
+end

data/test/new_relic/agent/harvester_test.rb

@@ -20,19 +20,9 @@ module NewRelic
         assert_nil harvester.starting_pid
       end
 
-      def test_marks_started_in_process
-        pretend_started_in_another_process
-
-        with_config(:restart_thread_in_children => true) do
-          harvester.on_transaction
-        end
-
-        assert_false harvester.needs_restart?
-      end
-
       def test_skips_out_early_if_already_started
         harvester.mark_started
-        ::Mutex.any_instance.expects(:synchronize).never
+        @after_forker.expects(:after_fork).never
 
         with_config(:restart_thread_in_children => true) do
           harvester.on_transaction
@@ -73,22 +63,12 @@ module NewRelic
         end
       end
 
-      def test_calls_to_restart_only_once
+      def test_calls_restart_every_time_until_marked_started
         pretend_started_in_another_process
-        @after_forker.expects(:after_fork).once
+        @after_forker.expects(:after_fork).times(2)
 
-        with_config(:restart_thread_in_children => true) do
-          threads = []
-          100.times do
-            threads << Thread.new do
-              harvester.on_transaction
-            end
-          end
-
-          threads.each do |thread|
-            thread.join
-          end
-        end
+        harvester.on_transaction
+        harvester.on_transaction
       end
 
       def pretend_started_in_another_process

data/test/new_relic/agent/hostname_test.rb

@@ -75,7 +75,7 @@ module NewRelic
       def test_shortens_to_prefixes_with_unsupported_object
         with_dyno_name('Imladris.1', :'heroku.use_dyno_names' => true,
                                      :'heroku.dyno_name_prefixes_to_shorten' => Object.new) do
-          expects_logging(:warn, includes('Object'))
+          expects_logging(:error, includes('heroku.dyno_name_prefixes_to_shorten'), instance_of(ArgumentError))
           assert_equal 'Imladris.1', NewRelic::Agent::Hostname.get
         end
       end

data/test/new_relic/agent/inbound_request_monitor_test.rb

@@ -0,0 +1,49 @@
+# 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/inbound_request_monitor'
+
+module NewRelic::Agent
+  class InboundRequestMonitorTest < Minitest::Test
+
+    ENCODING_KEY_NOOP         = "\0"
+
+    def setup
+      @events  = NewRelic::Agent::EventListener.new
+      @monitor = NewRelic::Agent::InboundRequestMonitor.new(@events)
+
+      @config = { :encoding_key => ENCODING_KEY_NOOP }
+      NewRelic::Agent.config.add_config_for_testing(@config)
+
+      class << @monitor
+        define_method(:on_finished_configuring) do |*_|
+        end
+      end
+
+      @events.notify(:finished_configuring)
+    end
+
+    def teardown
+      NewRelic::Agent.config.remove_config(@config)
+    end
+
+    def test_deserialize
+      payload = @monitor.obfuscator.obfuscate("[1,2,3]")
+      assert_equal [1, 2, 3], @monitor.deserialize_header(payload, "the_key")
+    end
+
+    def test_deserialize_nonsense
+      expects_logging(:debug, includes("the_key"))
+      assert_nil @monitor.deserialize_header("asdf", "the_key")
+    end
+
+    def test_deserialize_with_invalid_json
+      payload = @monitor.obfuscator.obfuscate("[1,2,3")
+
+      expects_logging(:debug, includes("the_key"))
+      assert_nil @monitor.deserialize_header(payload, "the_key")
+    end
+  end
+end

data/test/new_relic/agent/instrumentation/controller_instrumentation_test.rb

@@ -145,37 +145,37 @@ module NewRelic::Agent::Instrumentation
 
     def test_transaction_name_calls_newrelic_metric_path
       @object.stubs(:newrelic_metric_path).returns('some/wacky/path')
-      assert_equal('Controller/some/wacky/path', @txn_namer.name(nil, @object, :controller))
+      assert_equal('Controller/some/wacky/path', @txn_namer.name_for(nil, @object, :controller))
     end
 
     def test_transaction_name_applies_category_and_path
       assert_equal('Controller/metric/path',
-                   @txn_namer.name(nil,
+                   @txn_namer.name_for(nil,
                                    @object,
                                    :controller,
                                    :path => 'metric/path'))
       assert_equal('OtherTransaction/Background/metric/path',
-                   @txn_namer.name(nil,
+                   @txn_namer.name_for(nil,
                                    @object,
                                    :task,
                                    :path => 'metric/path'))
       assert_equal('Controller/Rack/metric/path',
-                   @txn_namer.name(nil,
+                   @txn_namer.name_for(nil,
                                    @object,
                                    :rack,
                                    :path => 'metric/path'))
       assert_equal('Controller/metric/path',
-                   @txn_namer.name(nil,
+                   @txn_namer.name_for(nil,
                                    @object,
                                    :uri,
                                    :path => 'metric/path'))
       assert_equal('Controller/Sinatra/metric/path',
-                   @txn_namer.name(nil,
+                   @txn_namer.name_for(nil,
                                    @object,
                                    :sinatra,
                                    :path => 'metric/path'))
       assert_equal('Blarg/metric/path',
-                   @txn_namer.name(nil,
+                   @txn_namer.name_for(nil,
                                    @object,
                                    'Blarg',
                                    :path => 'metric/path'))
@@ -183,12 +183,12 @@ module NewRelic::Agent::Instrumentation
 
     def test_transaction_name_uses_class_name_if_path_not_specified
       assert_equal('Controller/NewRelic::Agent::Instrumentation::ControllerInstrumentationTest::TestObject',
-                   @txn_namer.name(nil, @object, :controller))
+                   @txn_namer.name_for(nil, @object, :controller))
     end
 
     def test_transaction_name_applies_action_name_if_specified_and_not_path
       assert_equal('Controller/NewRelic::Agent::Instrumentation::ControllerInstrumentationTest::TestObject/action',
-                     @txn_namer.name(nil,
+                     @txn_namer.name_for(nil,
                                      @object,
                                      :controller,
                                      :name => 'action'))

data/test/new_relic/agent/instrumentation/queue_time_test.rb

@@ -73,25 +73,6 @@ class NewRelic::Agent::Instrumentation::QueueTimeTest < Minitest::Test
     assert_in_delta(now, QueueTime.parse_frontend_timestamp(header, now), 0.001)
   end
 
-  def test_recording_queue_time_metric
-    QueueTime.record_frontend_metrics(Time.at(Time.now.to_f - 60))
-    assert_metrics_recorded(
-      'WebFrontend/QueueTime' => {
-        :call_count      => 1,
-        :total_call_time => 60
-      }
-    )
-  end
-
-  def test_doesnt_record_scoped_queue_time_metric
-    in_transaction('boo') do
-      QueueTime.record_frontend_metrics(Time.at(Time.now.to_f - 60))
-    end
-    assert_metrics_not_recorded(
-      [['WebFrontend/QueueTime', 'boo']]
-    )
-  end
-
   def test_parsing_malformed_header
     header = { 'HTTP_X_REQUEST_START' => 'gobledy gook' }
 

data/test/new_relic/agent/javascript_instrumentor_test.rb

@@ -160,7 +160,6 @@ class NewRelic::Agent::JavascriptInstrumentorTest < Minitest::Test
         txn.stubs(:guid).returns('ABC')
 
         state = NewRelic::Agent::TransactionState.tl_get
-        state.request_token = '0123456789ABCDEF'
 
         data = instrumentor.data_for_js_agent(state)
         expected = {
@@ -171,8 +170,6 @@ class NewRelic::Agent::JavascriptInstrumentorTest < Minitest::Test
           "transactionName" => pack("most recent transaction"),
           "queueTime"       => 0,
           "applicationTime" => 10000,
-          "ttGuid"          => "ABC",
-          "agentToken"      => "0123456789ABCDEF",
           "agent"           => "",
           "userAttributes"  => pack('{"user":"user"}')
         }
@@ -274,48 +271,6 @@ class NewRelic::Agent::JavascriptInstrumentorTest < Minitest::Test
     assert_equal(string, instrumentor.html_safe_if_needed(string))
   end
 
-  def test_request_guid_to_include
-    state = NewRelic::Agent::TransactionState.tl_get
-    with_config(:apdex_t => 2.0) do
-      freeze_time
-      in_transaction do |txn|
-        state.request_token = "token"
-        advance_time(4.0)
-
-        data = instrumentor.data_for_js_agent(state)
-        assert_equal(state.current_transaction.guid, data['ttGuid'])
-      end
-    end
-  end
-
-  def test_request_guid_excluded_if_request_fast_enough
-    state = NewRelic::Agent::TransactionState.tl_get
-    with_config(:apdex_t => 2.0) do
-      freeze_time
-
-      state.request_token = "token"
-      in_transaction do |txn|
-        advance_time(1.0)
-        data = instrumentor.data_for_js_agent(state)
-        assert_nil(data['ttGuid'])
-      end
-    end
-  end
-
-  def test_request_guid_excluded_if_no_token
-    state = NewRelic::Agent::TransactionState.tl_get
-    with_config(:apdex_t => 2.0) do
-      freeze_time
-
-      state.request_token = nil
-      in_transaction do |txn|
-        advance_time(4.0)
-        data = instrumentor.data_for_js_agent(state)
-        assert_nil(data['ttGuid'])
-      end
-    end
-  end
-
   # Helpers
 
   BEGINNING_OF_FOOTER = '<script type="text/javascript">window.NREUM||(NREUM={});NREUM.info='

data/test/new_relic/agent/new_relic_service_test.rb

@@ -37,7 +37,7 @@ class NewRelicServiceKeepAliveTest < Minitest::Test
     assert(!block_ran, "Expected block passed to #session to have not run")
   end
 
-  def test_session_block_reuses_http_handle
+  def test_session_block_reuses_http_handle_with_aggressive_keepalive_off
     handle1 = stub_net_http_handle
     handle2 = stub_net_http_handle
     @service.stubs(:create_http_connection).returns(handle1, handle2)
@@ -47,13 +47,15 @@ class NewRelicServiceKeepAliveTest < Minitest::Test
     handle2.expects(:start).never
 
     block_ran = false
-    @service.session do
-      block_ran = true
-      assert(@service.http_connection)
+    with_config(:aggressive_keepalive => false) do
+      @service.session do
+        block_ran = true
+        assert(@service.http_connection)
 
-      # check we get the same object back each time we call http_connection in the block
-      assert_equal(@service.http_connection.object_id, handle1.object_id)
-      assert_equal(@service.http_connection.object_id, handle1.object_id)
+        # check we get the same object back each time we call http_connection in the block
+        assert_equal(@service.http_connection.object_id, handle1.object_id)
+        assert_equal(@service.http_connection.object_id, handle1.object_id)
+      end
     end
     assert(block_ran)
   end
@@ -67,17 +69,20 @@ class NewRelicServiceKeepAliveTest < Minitest::Test
   end
 
 
-  def test_session_starts_and_finishes_http_session
+  def test_session_starts_and_finishes_http_session_with_aggressive_keepalive_off
     handle1 = stub_net_http_handle
     handle1.expects(:start).once
     handle1.expects(:finish).once
     @service.stubs(:create_http_connection).returns(handle1)
 
     block_ran = false
-    @service.session do
-      block_ran = true
-      # mocks expect #start and #finish to be called.  This is how Net::HTTP
-      # implements keep alive
+
+    with_config(:aggressive_keepalive => false) do
+      @service.session do
+        block_ran = true
+        # mocks expect #start and #finish to be called.  This is how Net::HTTP
+        # implements keep alive
+      end
     end
     assert(block_ran)
   end