newrelic_rpm 3.14.1.311 → 3.14.2.312

data/test/new_relic/agent/event_aggregator_test.rb

@@ -0,0 +1,178 @@
+# 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 File.expand_path(File.join(File.dirname(__FILE__),'..','data_container_tests'))
+require 'new_relic/agent/event_aggregator'
+
+module NewRelic
+  module Agent
+    class EventAggregatorTest < Minitest::Test
+      class TestAggregator < EventAggregator
+        named :TestAggregator
+        capacity_key :cap_key
+        enabled_key :enabled_key
+
+        attr_reader :buffer
+
+        def append item
+          @buffer.append item
+          notify_if_full
+        end
+      end
+
+      def setup
+        NewRelic::Agent.config.add_config_for_testing(
+          :cap_key => 100,
+          :enabled_key => true
+        )
+
+        @aggregator = TestAggregator.new
+      end
+
+      def create_container
+        @aggregator
+      end
+
+      def populate_container(container, n)
+        n.times { |i| container.append i }
+      end
+
+      include NewRelic::DataContainerTests
+
+      def test_it_has_a_name
+        assert_equal 'TestAggregator', TestAggregator.named
+      end
+
+      def test_enabled_relects_config_value
+        assert @aggregator.enabled?, "Expected enabled? to be true"
+
+        with_config :enabled_key => false do
+          refute @aggregator.enabled?, "Expected enabled? to be false"
+        end
+      end
+
+      def test_after_harvest_invoked_with_report
+        metadata = {:meta => true}
+        @aggregator.buffer.stubs(:metadata).returns(metadata)
+        @aggregator.expects(:after_harvest).with(metadata)
+        @aggregator.harvest!
+      end
+
+      def test_notifies_full
+        expects_logging :debug, includes("TestAggregator capacity of 5 reached")
+        with_config :cap_key => 5 do
+          5.times { |i| @aggregator.append i}
+        end
+      end
+
+      def test_notifies_full_only_once
+        with_config :cap_key => 5 do
+          msg = "TestAggregator capacity of 5 reached"
+          # this will trigger a message to be logged
+          5.times { |i| @aggregator.append i}
+
+          # we expect subsequent appends not to trigger logging
+          expects_logging :debug, Not(includes(msg))
+          3.times {@aggregator.append 'no logs'}
+        end
+      end
+
+      def test_notifies_full_resets_after_harvest
+        msg = "TestAggregator capacity of 5 reached"
+
+        expects_logging :debug, includes(msg)
+        with_config :cap_key => 5 do
+          5.times { |i| @aggregator.append i}
+        end
+
+        @aggregator.harvest!
+
+        expects_logging :debug, includes(msg)
+        with_config :cap_key => 5 do
+          5.times { |i| @aggregator.append i}
+        end
+      end
+
+      def test_notifies_full_resets_after_buffer_reset
+        msg = "TestAggregator capacity of 5 reached"
+
+        expects_logging :debug, includes(msg)
+        with_config :cap_key => 5 do
+          5.times { |i| @aggregator.append i}
+        end
+
+        @aggregator.reset!
+
+        expects_logging :debug, includes(msg)
+        with_config :cap_key => 5 do
+          5.times { |i| @aggregator.append i}
+        end
+      end
+
+      def test_buffer_class_defaults_to_sampled_buffer
+        assert_kind_of NewRelic::Agent::SampledBuffer, @aggregator.buffer
+      end
+
+      def test_buffer_class_is_overridable
+        klass = Class.new(EventAggregator) do
+          named :TestAggregator2
+          capacity_key :cap_key
+          enabled_key :enabled_key
+          buffer_class NewRelic::Agent::SizedBuffer
+          attr_reader :buffer
+        end
+        instance = klass.new
+
+        assert_kind_of NewRelic::Agent::SizedBuffer, instance.buffer
+      end
+
+      def test_buffer_adjusts_count_by_default_on_merge
+        with_config :cap_key => 5 do
+          buffer = @aggregator.buffer
+
+          4.times { |i| @aggregator.append i  }
+          last_harvest = @aggregator.harvest!
+
+          assert_equal 4, buffer.seen_lifetime
+          assert_equal 4, buffer.captured_lifetime
+          assert_equal 4, last_harvest[0][:events_seen]
+
+          4.times { |i| @aggregator.append i }
+          @aggregator.merge! last_harvest
+
+          reservoir_stats, samples = @aggregator.harvest!
+
+          assert_equal 5, samples.size
+          assert_equal 8, reservoir_stats[:events_seen]
+          assert_equal 8, buffer.seen_lifetime
+          assert_equal 5, buffer.captured_lifetime
+        end
+      end
+
+      def test_buffer_adds_to_original_count_on_merge_when_specified
+        with_config :cap_key => 5 do
+          buffer = @aggregator.buffer
+
+          4.times { |i| @aggregator.append i  }
+          last_harvest = @aggregator.harvest!
+
+          assert_equal 4, buffer.seen_lifetime
+          assert_equal 4, buffer.captured_lifetime
+          assert_equal 4, last_harvest[0][:events_seen]
+
+          4.times { |i| @aggregator.append i }
+          @aggregator.merge! last_harvest, false
+
+          reservoir_stats, samples = @aggregator.harvest!
+
+          assert_equal 5, samples.size
+          assert_equal 8, reservoir_stats[:events_seen]
+          assert_equal 12, buffer.seen_lifetime
+          assert_equal 9, buffer.captured_lifetime
+        end
+      end
+    end
+  end
+end

data/test/new_relic/agent/event_buffer_test_cases.rb

@@ -149,4 +149,20 @@ module NewRelic::Agent::EventBufferTestCases
     assert_equal(0.5, buffer.sample_rate)
   end
 
+  def test_metadata
+    buffer = buffer_class.new(5)
+    7.times { buffer << 'x' }
+
+    expected = {
+      :capacity => 5,
+      :seen => 7,
+      :captured => 5
+    }
+
+    metadata = buffer.metadata
+    metadata.delete :captured_lifetime
+    metadata.delete :seen_lifetime
+
+    assert_equal expected, metadata
+  end
 end

data/test/new_relic/agent/instrumentation/sinatra/transaction_namer_test.rb

@@ -28,6 +28,13 @@ module NewRelic
             assert_equal "GET path/:id", result
           end
 
+          def test_transaction_name_for_root_route
+            env = { "newrelic.last_route" => /\A\/\z/}
+            request = stub(:request_method => "GET")
+            result = TransactionNamer.transaction_name_for_route(env, request)
+            assert_equal "GET /", result
+          end
+
           def test_transaction_name_for_route_without_routes
             assert_nil TransactionNamer.transaction_name_for_route({}, nil)
           end

data/test/new_relic/agent/new_relic_service_test.rb

@@ -363,10 +363,16 @@ class NewRelicServiceTest < Minitest::Test
 
   def test_analytic_event_data
     @http_handle.respond_to(:analytic_event_data, 'some analytic events')
-    response = @service.analytic_event_data([])
+    response = @service.analytic_event_data([{}, []])
     assert_equal 'some analytic events', response
   end
 
+  def error_event_data
+    @http_handle.respond_to(:error_event_data, 'some error events')
+    response = @service.error_event_data([{}, []])
+    assert_equal 'some error events', response
+  end
+
   # Although thread profiling is only available in some circumstances, the
   # service communication doesn't care about that at all
   def test_profile_data

data/test/new_relic/agent/pipe_channel_manager_test.rb

@@ -5,6 +5,7 @@
 require 'timeout'
 require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
 require 'new_relic/agent/pipe_channel_manager'
+require 'new_relic/agent/transaction_event_primitive'
 
 class NewRelic::Agent::PipeChannelManagerTest < Minitest::Test
   include TransactionSampleTestHelper
@@ -103,13 +104,14 @@ class NewRelic::Agent::PipeChannelManagerTest < Minitest::Test
     end
 
     def test_listener_merges_analytics_events
-      transaction_event_aggregator = NewRelic::Agent.agent.instance_variable_get(:@transaction_event_aggregator)
+      transaction_event_aggregator = NewRelic::Agent.agent.transaction_event_aggregator
+      reset_lifetime_counts! 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)
-        transaction_event_aggregator.on_transaction_finished({
+        transaction_event_aggregator.append NewRelic::Agent::TransactionEventPrimitive.create({
           :start_timestamp => Time.now,
           :name => 'whatever',
           :duration => 10,
@@ -118,7 +120,35 @@ class NewRelic::Agent::PipeChannelManagerTest < Minitest::Test
         NewRelic::Agent.agent.send(:transmit_event_data)
       end
 
-      assert_equal(1, transaction_event_aggregator.samples.size)
+      _, samples = transaction_event_aggregator.harvest!
+
+      assert_equal(1, samples.size)
+      assert_lifetime_counts(transaction_event_aggregator, 1)
+    end
+
+    def test_listener_merges_error_events
+      error_event_aggregator = NewRelic::Agent.agent.error_collector.error_event_aggregator
+      reset_lifetime_counts! error_event_aggregator
+
+      sampler = NewRelic::Agent.agent.error_collector
+      sampler.notice_error(Exception.new("message"), :uri => '/myurl/',
+                           :metric => 'path', :referer => 'test_referer',
+                           :request_params => {:x => 'y'})
+
+      start_listener_with_pipe(668)
+
+      run_child(668) 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'})
+        service = NewRelic::Agent::PipeService.new(668)
+        service.error_event_data(new_sampler.error_event_aggregator.harvest!)
+      end
+      _, errors = error_event_aggregator.harvest!
+      assert_equal(2, errors.size)
+      assert_lifetime_counts(error_event_aggregator, 2)
     end
 
     def test_listener_merges_sql_traces
@@ -276,4 +306,16 @@ class NewRelic::Agent::PipeChannelManagerTest < Minitest::Test
       sleep 0.01
     end
   end
+
+  def assert_lifetime_counts container, value
+    buffer = container.instance_variable_get :@buffer
+    assert_equal value, buffer.captured_lifetime
+    assert_equal value, buffer.seen_lifetime
+  end
+
+  def reset_lifetime_counts! container
+    buffer = container.instance_variable_get :@buffer
+    buffer.instance_variable_set :@captured_lifetime, 0
+    buffer.instance_variable_set :@seen_lifetime, 0
+  end
 end

data/test/new_relic/agent/rpm_agent_test.rb

@@ -13,6 +13,7 @@ class NewRelic::Agent::RpmAgentTest < Minitest::Test
 
   def teardown
     NewRelic::Agent.instance.shutdown
+    NewRelic::Agent.drop_buffered_data
   end
 
   def test_public_apis

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

@@ -136,14 +136,14 @@ class NewRelic::Agent::StatsHashTest < Minitest::Test
     txn_metrics = NewRelic::Agent::TransactionMetrics.new
     txn_metrics.record_unscoped(specs[0].name, 1)
     txn_metrics.record_unscoped(specs[1].name, 2)
-    txn_metrics.record_scoped(specs[3].name, 3)
+    txn_metrics.record_scoped_and_unscoped(specs[3].name, 3)
 
     hash.merge_transaction_metrics!(txn_metrics, 'a_scope')
 
     assert_equal(4, hash.to_h.keys.size)
     assert_equal(2, hash[specs[0]].call_count)
     assert_equal(2, hash[specs[1]].call_count)
-    assert_equal(1, hash[specs[2]].call_count)
+    assert_equal(2, hash[specs[2]].call_count)
     assert_equal(1, hash[specs[3]].call_count)
   end
 

data/test/new_relic/agent/synthetics_event_aggregator_test.rb

@@ -0,0 +1,179 @@
+# 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 File.expand_path(File.join(File.dirname(__FILE__),'..','data_container_tests'))
+require 'new_relic/agent/synthetics_event_aggregator'
+require 'new_relic/agent/transaction_event_primitive'
+
+module NewRelic
+  module Agent
+    class SyntheticsEventAggregatorTest < Minitest::Test
+      def setup
+        freeze_time
+        @synthetics_event_aggregator = SyntheticsEventAggregator.new
+      end
+
+      def teardown
+        @synthetics_event_aggregator.reset!
+      end
+
+      def create_container
+        @synthetics_event_aggregator
+      end
+
+      def populate_container(sampler, n)
+        n.times do |i|
+          generate_request
+        end
+      end
+
+      include NewRelic::DataContainerTests
+
+      def test_synthetics_aggregation_limits
+        with_config :'synthetics.events_limit' => 10 do
+          20.times do
+            generate_request
+          end
+
+          assert_equal 10, last_synthetics_events.size
+        end
+      end
+
+      def test_synthetics_events_kept_by_timestamp
+        with_config :'synthetics.events_limit' => 10 do
+          11.times do |i|
+            _, rejected = generate_request('whatever', :timestamp => i)
+            if i < 10
+              assert_nil rejected, "Expected event to be accepted"
+            else
+              refute_nil rejected, "Expected event to be rejected"
+              assert_equal 10.0, rejected.first["timestamp"]
+            end
+          end
+        end
+      end
+
+      def test_sythetics_events_rejected_when_buffer_is_full_of_newer_events
+        with_config :'synthetics.events_limit' => 10 do
+          11.times do |i|
+            generate_request 'whatever', :timestamp => i + 10.0
+          end
+
+          generate_request 'whatever', :timestamp => 1
+          samples = last_synthetics_events
+          assert_equal 10, samples.size
+          timestamps = samples.map do |(main, _)|
+            main["timestamp"]
+          end.sort
+
+          assert_equal ([1] + (10..18).to_a), timestamps
+        end
+      end
+
+      def test_does_not_drop_samples_when_used_from_multiple_threads
+        with_config :'synthetics.events_limit' => 100 * 100 do
+          threads = []
+          25.times do
+            threads << Thread.new do
+              100.times{ generate_request }
+            end
+          end
+          threads.each { |t| t.join }
+
+          assert_equal(25 * 100, last_synthetics_events.size)
+        end
+      end
+
+      def test_events_not_recorded_when_disabled
+        with_config :'analytics_events.enabled' => false do
+          generate_request
+          errors = last_synthetics_events
+          assert_empty errors
+        end
+      end
+
+      def test_includes_custom_attributes
+        attrs = {"user" => "Wes Mantooth", "channel" => 9}
+
+        attributes.merge_custom_attributes attrs
+
+        generate_request
+
+        _, custom_attrs, _ = last_synthetics_event
+
+        assert_equal attrs, custom_attrs
+      end
+
+      def test_does_not_record_supportability_metric_when_no_events_dropped
+        with_config :'synthetics.events_limit' => 20 do
+          20.times do
+            generate_request
+          end
+
+          @synthetics_event_aggregator.harvest!
+
+          metric = 'Supportability/TransactionEventAggregator/synthetics_events_dropped'
+          assert_metrics_not_recorded(metric)
+        end
+      end
+
+      def test_synthetics_event_dropped_records_supportability_metrics
+        with_config :'synthetics.events_limit' => 10 do
+          20.times do
+            generate_request
+          end
+
+          @synthetics_event_aggregator.harvest!
+
+          metric = 'Supportability/SyntheticsEventAggregator/synthetics_events_dropped'
+          assert_metrics_recorded(metric => { :call_count => 10 })
+        end
+      end
+
+      def test_includes_agent_attributes
+        attributes.add_agent_attribute :'request.headers.referer', "http://blog.site/home", AttributeFilter::DST_TRANSACTION_EVENTS
+        attributes.add_agent_attribute :httpResponseCode, "200", AttributeFilter::DST_TRANSACTION_EVENTS
+
+        generate_request
+
+        _, _, agent_attrs = last_synthetics_event
+
+        expected = {:"request.headers.referer" => "http://blog.site/home", :httpResponseCode => "200"}
+        assert_equal expected, agent_attrs
+      end
+
+      def last_synthetics_events
+        @synthetics_event_aggregator.harvest![1]
+      end
+
+      def last_synthetics_event
+        last_synthetics_events.first
+      end
+
+      def generate_request name='whatever', options={}
+        payload = {
+          :name => "Controller/blogs/index",
+          :type => :controller,
+          :start_timestamp => options[:timestamp] || Time.now.to_f,
+          :duration => 0.1,
+          :synthetics_resource_id => 100,
+          :attributes => attributes,
+          :error => false
+        }.merge(options)
+
+        @synthetics_event_aggregator.append_or_reject TransactionEventPrimitive.create(payload)
+      end
+
+      def attributes
+        if @attributes.nil?
+          filter = NewRelic::Agent::AttributeFilter.new(NewRelic::Agent.config)
+          @attributes = NewRelic::Agent::Transaction::Attributes.new(filter)
+        end
+
+        @attributes
+      end
+    end
+  end
+end