newrelic_rpm 3.9.6.257 → 3.9.7.266

data/test/new_relic/agent/pipe_channel_manager_test.rb

@@ -10,7 +10,7 @@ class NewRelic::Agent::PipeChannelManagerTest < Minitest::Test
   include TransactionSampleTestHelper
 
   def setup
-    @test_config = { :developer_mode => true }
+    @test_config = { :monitor_mode => true }
     NewRelic::Agent.agent.drop_buffered_data
     NewRelic::Agent.config.add_config_for_testing(@test_config)
 
@@ -102,13 +102,13 @@ class NewRelic::Agent::PipeChannelManagerTest < Minitest::Test
     end
 
     def test_listener_merges_analytics_events
-      request_sampler = NewRelic::Agent.agent.instance_variable_get(:@request_sampler)
+      transaction_event_aggregator = NewRelic::Agent.agent.instance_variable_get(:@transaction_event_aggregator)
 
       start_listener_with_pipe(699)
       NewRelic::Agent.agent.stubs(:connected?).returns(true)
       run_child(699) do
         NewRelic::Agent.after_fork(:report_to_channel => 699)
-        request_sampler.on_transaction_finished({
+        transaction_event_aggregator.on_transaction_finished({
           :start_timestamp => Time.now,
           :name => 'whatever',
           :duration => 10,
@@ -117,7 +117,7 @@ class NewRelic::Agent::PipeChannelManagerTest < Minitest::Test
         NewRelic::Agent.agent.send(:transmit_event_data)
       end
 
-      assert_equal(1, request_sampler.samples.size)
+      assert_equal(1, transaction_event_aggregator.samples.size)
     end
 
     def test_listener_merges_sql_traces

data/test/new_relic/agent/sampled_buffer_test.rb

@@ -3,176 +3,104 @@
 # 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'
 
-class NewRelic::Agent::SampledBufferTest < Minitest::Test
-  def test_should_keep_all_samples_up_to_capacity
-    buffer = NewRelic::Agent::SampledBuffer.new(100)
-    all = []
-    100.times do |i|
-      buffer << i
-      all << i
-    end
-
-    assert_equal(100, buffer.size)
-    assert_equal(all, buffer.to_a)
-  end
+module NewRelic::Agent
+  class SampledBufferTest < Minitest::Test
+    include EventBufferTestCases
 
-  def test_replaces_old_entries_when_necessary
-    buffer = NewRelic::Agent::SampledBuffer.new(5)
+    def buffer_class
+      SampledBuffer
+    end
 
-    buffer.expects(:rand).with(6).returns(0)
-    buffer.expects(:rand).with(7).returns(1)
-    buffer.expects(:rand).with(8).returns(2)
-    buffer.expects(:rand).with(9).returns(3)
-    buffer.expects(:rand).with(10).returns(4)
+    def test_replaces_old_entries_when_necessary
+      buffer = buffer_class.new(5)
 
-    10.times { |i| buffer << i }
+      buffer.expects(:rand).with(6).returns(0)
+      buffer.expects(:rand).with(7).returns(1)
+      buffer.expects(:rand).with(8).returns(2)
+      buffer.expects(:rand).with(9).returns(3)
+      buffer.expects(:rand).with(10).returns(4)
 
-    assert_equal([5, 6, 7, 8, 9], buffer.to_a)
-  end
-
-  def test_discards_new_entries_when_necessary
-    buffer = NewRelic::Agent::SampledBuffer.new(5)
+      10.times { |i| buffer << i }
 
-    buffer.expects(:rand).with(6).returns(5)
-    buffer.expects(:rand).with(7).returns(6)
-    buffer.expects(:rand).with(8).returns(7)
-    buffer.expects(:rand).with(9).returns(8)
-    buffer.expects(:rand).with(10).returns(9)
+      assert_equal([5, 6, 7, 8, 9], buffer.to_a)
+    end
 
-    10.times { |i| buffer << i }
+    def test_discards_new_entries_when_necessary
+      buffer = buffer_class.new(5)
 
-    assert_equal([0, 1, 2, 3, 4], buffer.to_a)
-  end
+      buffer.expects(:rand).with(6).returns(5)
+      buffer.expects(:rand).with(7).returns(6)
+      buffer.expects(:rand).with(8).returns(7)
+      buffer.expects(:rand).with(9).returns(8)
+      buffer.expects(:rand).with(10).returns(9)
 
-  # This test is non-deterministic: there is some (low) probability that it will
-  # fail. We repeatedly stream 10 items into a buffer of capacity 5, and verify
-  # that each item is included ~50% of the time.
-  # 
-  # Because of the non-determinism, it is possible that we'll want to disable
-  # this test. That said, I've thus far been unsuccessful in making it fail, so
-  # I'm leaving it here for now.
-  def test_should_sample_evenly
-    buffer = NewRelic::Agent::SampledBuffer.new(5)
-    results = []
-
-    10000.times do
-      buffer.reset
       10.times { |i| buffer << i }
-      results << buffer.to_a
-    end
 
-    (0...10).each do |v|
-      num_results_including_v = results.select { |r| r.include?(v) }.size
-      assert_in_delta(0.5, num_results_including_v.to_f / results.size, 0.05)
+      assert_equal([0, 1, 2, 3, 4], buffer.to_a)
     end
-  end
-
-  def test_to_a_should_dup_the_returned_array
-    buffer = NewRelic::Agent::SampledBuffer.new(10)
 
-    5.times { |i| buffer << i }
+    def test_append_returns_whether_item_was_stored
+      buffer = buffer_class.new(5)
 
-    items = buffer.to_a
-    items << 'noodles'
-
-    assert_equal([0, 1, 2, 3, 4], buffer.to_a)
-  end
+      buffer.expects(:rand).with(6).returns(5)
 
-  def test_append_should_return_true_when_buffer_is_full
-    buffer = NewRelic::Agent::SampledBuffer.new(5)
+      5.times do |i|
+        result = buffer.append(i)
+        assert(result)
+      end
 
-    4.times do |i|
-      assert_equal(false, buffer.append(i), "SampledBuffer#append should return false until buffer is full")
+      result = buffer.append('foo')
+      refute(result)
     end
 
-    4.times do |i|
-      assert_equal(true, buffer.append('lava'), "SampledBuffer#append should return true once buffer is full")
+    # This test is non-deterministic: there is some (low) probability that it will
+    # fail. We repeatedly stream 10 items into a buffer of capacity 5, and verify
+    # that each item is included ~50% of the time.
+    #
+    # Because of the non-determinism, it is possible that we'll want to disable
+    # this test. That said, I've thus far been unsuccessful in making it fail, so
+    # I'm leaving it here for now.
+    def test_should_sample_evenly
+      buffer = buffer_class.new(5)
+      results = []
+
+      10000.times do
+        buffer.reset!
+        10.times { |i| buffer << i }
+        results << buffer.to_a
+      end
+
+      (0...10).each do |v|
+        num_results_including_v = results.select { |r| r.include?(v) }.size
+        assert_in_delta(0.5, num_results_including_v.to_f / results.size, 0.05)
+      end
     end
-  end
 
-  def test_should_discard_items_as_needed_when_capacity_is_reset
-    buffer = NewRelic::Agent::SampledBuffer.new(10)
-    10.times { |i| buffer << i }
+    def test_seen_lifetime_should_persist_across_resets
+      buffer = buffer_class.new(10)
 
-    buffer.capacity = 5
-    assert_equal(5, buffer.size)
+      100.times { |i| buffer << i }
+      buffer.reset!
+      assert_equal(100, buffer.seen_lifetime)
 
-    # 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)
+      100.times { |i| buffer << i }
+      buffer.reset!
+      assert_equal(200, buffer.seen_lifetime)
     end
-  end
-
-  def test_should_not_discard_items_if_not_needed_when_capacity_is_reset
-    buffer = NewRelic::Agent::SampledBuffer.new(10)
-    10.times { |i| buffer << i }
-
-    buffer.capacity = 20
-    assert_equal(10, buffer.size)
-    assert_equal((0..9).to_a, buffer.to_a)
-  end
-
-  def test_should_not_exceed_capacity
-    buffer = NewRelic::Agent::SampledBuffer.new(100)
-    200.times { |i| buffer << i }
-    assert_equal(100, buffer.size)
-  end
-
-  def test_reset_should_reset
-    buffer = NewRelic::Agent::SampledBuffer.new(10)
-    100.times { |i| buffer << i }
-    buffer.reset
-    assert_equal(0, buffer.size)
-    assert_equal([], buffer.to_a)
-  end
-
-  def test_seen_counts_all_seen_samples_since_last_reset
-    buffer = NewRelic::Agent::SampledBuffer.new(10)
-    assert_equal(0, buffer.seen)
-
-    20.times { |i| buffer << i }
-    assert_equal(20, buffer.seen)
-
-    buffer.reset
-    assert_equal(0, buffer.seen)
-  end
 
-  def test_seen_lifetime_should_persist_across_resets
-    buffer = NewRelic::Agent::SampledBuffer.new(10)
+    def test_sample_rate_lifetime
+      buffer = buffer_class.new(10)
+      assert_equal(0, buffer.sample_rate_lifetime)
 
-    100.times { |i| buffer << i }
-    buffer.reset
-    assert_equal(100, buffer.seen_lifetime)
+      10.times { buffer << 'x' }
+      buffer.reset!
+      assert_equal(1.0, buffer.sample_rate_lifetime)
 
-    100.times { |i| buffer << i }
-    buffer.reset
-    assert_equal(200, buffer.seen_lifetime)
-  end
-
-  def test_sample_rate
-    buffer = NewRelic::Agent::SampledBuffer.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
-
-  def test_sample_rate_lifetime
-    buffer = NewRelic::Agent::SampledBuffer.new(10)
-    assert_equal(0, buffer.sample_rate_lifetime)
-
-    10.times { buffer << 'x' }
-    buffer.reset
-    assert_equal(1.0, buffer.sample_rate_lifetime)
-
-    30.times { buffer << 'x' }
-    buffer.reset
-    assert_equal(0.5, buffer.sample_rate_lifetime)
+      30.times { buffer << 'x' }
+      buffer.reset!
+      assert_equal(0.5, buffer.sample_rate_lifetime)
+    end
   end
 end

data/test/new_relic/agent/sized_buffer_test.rb

@@ -0,0 +1,29 @@
+# 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 'test/new_relic/agent/event_buffer_test_cases'
+require 'new_relic/agent/sized_buffer'
+
+module NewRelic::Agent
+  class SizedBufferTest < Minitest::Test
+    include EventBufferTestCases
+
+    def buffer_class
+      SizedBuffer
+    end
+
+    def test_append_returns_whether_item_was_stored
+      buffer = buffer_class.new(5)
+
+      5.times do |i|
+        result = buffer.append(i)
+        assert(result)
+      end
+
+      result = buffer.append('foo')
+      refute(result)
+    end
+  end
+end

data/test/new_relic/agent/synthetics_monitor_test.rb

@@ -0,0 +1,96 @@
+# 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/synthetics_monitor'
+
+module NewRelic::Agent
+  class SyntheticsMonitorTest < Minitest::Test
+    ENCODING_KEY_NOOP         = "\0"
+    TRUSTED_ACCOUNT_IDS       = [42,13]
+
+    VERSION_ID  = 1
+    ACCOUNT_ID  = 42
+    RESOURCE_ID = 100
+    JOB_ID      = 200
+    MONITOR_ID  = 300
+
+    BAD_ACCOUNT_ID = 7
+    BAD_VERSION_ID = 2
+
+    STANDARD_DATA = [ACCOUNT_ID, RESOURCE_ID, JOB_ID, MONITOR_ID]
+
+    def setup
+      @events  = EventListener.new
+      @monitor = SyntheticsMonitor.new(@events)
+
+      NewRelic::Agent.reset_config
+      @config = {
+        :encoding_key        => ENCODING_KEY_NOOP,
+        :trusted_account_ids => TRUSTED_ACCOUNT_IDS
+      }
+      NewRelic::Agent.config.add_config_for_testing(@config)
+
+      @events.notify(:finished_configuring)
+    end
+
+    def test_doesnt_record_synthetics_state_without_header
+      in_transaction do
+        # Make sure we're not just erroring in the event notification handler
+        expects_no_logging(:debug)
+
+        @events.notify(:before_call, {})
+        assert_no_synthetics_payload
+      end
+    end
+
+    def test_doesnt_record_synthetics_if_incoming_request_higher_version
+      synthetics_payload = [BAD_VERSION_ID] + STANDARD_DATA
+      with_synthetics_headers(synthetics_payload) do
+        assert_no_synthetics_payload
+      end
+    end
+
+    def test_doesnt_record_synthetics_if_not_trusted_account
+      synthetics_payload = [VERSION_ID, BAD_ACCOUNT_ID] + STANDARD_DATA[1..-1]
+      with_synthetics_headers(synthetics_payload) do
+        assert_no_synthetics_payload
+      end
+    end
+
+    def test_doesnt_record_synthetics_if_data_too_short
+      synthetics_payload = [VERSION_ID, ACCOUNT_ID]
+      with_synthetics_headers(synthetics_payload) do
+        assert_no_synthetics_payload
+      end
+    end
+
+    def test_records_synthetics_state_from_header
+      key = SyntheticsMonitor::SYNTHETICS_HEADER_KEY
+      synthetics_payload = [VERSION_ID] + STANDARD_DATA
+      with_synthetics_headers(synthetics_payload, key) do
+        state = NewRelic::Agent::TransactionState.tl_get
+        txn = state.current_transaction
+        assert_equal @last_encoded_header, txn.raw_synthetics_header
+        assert_equal synthetics_payload,   txn.synthetics_payload
+      end
+    end
+
+    def synthetics_header(payload, header_key = SyntheticsMonitor::SYNTHETICS_HEADER_KEY)
+      @last_encoded_header = json_dump_and_encode(payload)
+      { header_key => @last_encoded_header }
+    end
+
+    def assert_no_synthetics_payload
+      assert_nil NewRelic::Agent::TransactionState.tl_get.current_transaction.synthetics_payload
+    end
+
+    def with_synthetics_headers(payload, header_key = SyntheticsMonitor::SYNTHETICS_HEADER_KEY)
+      in_transaction do
+        @events.notify(:before_call, synthetics_header(payload, header_key))
+        yield
+      end
+    end
+  end
+end

data/test/new_relic/agent/system_info_test.rb

@@ -11,13 +11,13 @@ class NewRelic::Agent::SystemInfoTest < Minitest::Test
     @sysinfo.clear_processor_info
   end
 
-  test_dir = File.join(cross_agent_tests_dir, 'proc_cpuinfo')
+  cpuinfo_test_dir = File.join(cross_agent_tests_dir, 'proc_cpuinfo')
 
-  Dir.chdir(test_dir) do
+  Dir.chdir(cpuinfo_test_dir) do
     Dir.glob("*.txt") do |file|
       if file =~ /^((\d+|X)pack_(\d+|X)core_(\d+|X)logical).txt$/
         test_name = "test_#{$1}"
-        test_path = File.join(test_dir, file)
+        test_path = File.join(cpuinfo_test_dir, file)
 
         num_physical_packages  = $2.to_i
         num_physical_cores     = $3.to_i
@@ -41,5 +41,21 @@ class NewRelic::Agent::SystemInfoTest < Minitest::Test
     end
   end
 
+  docker_id_test_dir   = File.join(cross_agent_tests_dir, 'docker_container_id')
+  docker_id_test_cases = load_cross_agent_test(File.join('docker_container_id', 'cases'))
+
+  docker_id_test_cases.each do |test_case|
+    filename = test_case['filename']
+    basename = File.basename(filename, '.txt')
+    test_name = "test_docker_container_id_#{basename}"
+
+    define_method(test_name) do
+      input = File.read(File.join(docker_id_test_dir, filename))
+      container_id = @sysinfo.parse_docker_container_id(input)
+
+      message = "Parsed incorrect Docker container ID from #{filename}"
+      assert_equal(test_case['dockerContainerId'], container_id, message)
+    end
+  end
 end
 

data/test/new_relic/agent/transaction/developer_mode_sample_buffer_test.rb

@@ -26,17 +26,21 @@ class NewRelic::Agent::Transaction
     end
 
     def test_stores_up_to_truncate_max
-      sample = stub
-      @buffer.capacity.times { @buffer.store(sample) }
+      with_config(:developer_mode => true) do
+        sample = stub
+        @buffer.capacity.times { @buffer.store(sample) }
 
-      assert_equal(Array.new(@buffer.capacity, sample), @buffer.samples)
+        assert_equal(Array.new(@buffer.capacity, sample), @buffer.samples)
+      end
     end
 
     def test_stores_and_truncates
-      sample = stub
-      (@buffer.capacity * 2).times { @buffer.store(sample) }
+      with_config(:developer_mode => true) do
+        sample = stub
+        (@buffer.capacity * 2).times { @buffer.store(sample) }
 
-      assert_equal(Array.new(@buffer.capacity, sample), @buffer.samples)
+        assert_equal(Array.new(@buffer.capacity, sample), @buffer.samples)
+      end
     end
 
     def test_visit_segment_takes_backtraces_in_dev_mode
@@ -62,8 +66,10 @@ class NewRelic::Agent::Transaction
     end
 
     def test_doesnt_store_previous
-      @buffer.store_previous([stub])
-      assert @buffer.samples.empty?
+      with_config(:developer_mode => true) do
+        @buffer.store_previous([stub])
+        assert @buffer.samples.empty?
+      end
     end
   end
 end