newrelic_rpm 3.13.2.302 → 3.14.0.305

data/test/new_relic/agent/audit_logger_test.rb

@@ -125,13 +125,6 @@ class AuditLoggerTest < Minitest::Test
     @logger.log_request(@uri, data, @marshaller)
   end
 
-  def test_logs_inspect_with_pruby_marshaller
-    setup_fake_logger
-    pruby_marshaller = NewRelic::Agent::NewRelicService::PrubyMarshaller.new
-    @logger.log_request(@uri, @dummy_data, pruby_marshaller)
-    assert_log_contains_string(@dummy_data.inspect)
-  end
-
   def test_logs_json_with_json_marshaller
     marshaller_cls = NewRelic::Agent::NewRelicService::JsonMarshaller
     if marshaller_cls.is_supported?

data/test/new_relic/agent/error_collector_test.rb

@@ -28,163 +28,31 @@ class NewRelic::Agent::ErrorCollectorTest < Minitest::Test
     NewRelic::Agent.config.reset_to_defaults
   end
 
-  # Helpers for DataContainerTests
-
-  def create_container
-    NewRelic::Agent::ErrorCollector.new
-  end
-
-  def populate_container(collector, n)
-    n.times do |i|
-      collector.notice_error('yay errors', :metric => 'path')
-    end
-  end
-
-  include NewRelic::DataContainerTests
-
   # Tests
 
   def test_empty
-    @error_collector.harvest!
     @error_collector.notice_error(nil, :metric=> 'path')
-    errors = @error_collector.harvest!
-
+    errors = harvest_error_traces
     assert_equal 0, errors.length
-
-    @error_collector.notice_error('Some error message', :metric=> 'path')
-    errors = @error_collector.harvest!
-
-    err = errors.first
-    assert_equal 'Some error message', err.message
-    assert_equal '', err.request_uri
-    assert_equal 'path', err.path
-    assert_equal 'Error', err.exception_class_name
-  end
-
-  def test_simple
-    @error_collector.notice_error(StandardError.new("message"),
-                                  :uri => '/myurl/',
-                                  :metric => 'path')
-
-    errors = @error_collector.harvest!
-
-    assert_equal errors.length, 1
-
-    err = errors.first
-    assert_equal 'message', err.message
-    assert_equal '/myurl/', err.request_uri
-    assert_equal 'path', err.path
-    assert_equal 'StandardError', err.exception_class_name
-
-    # the collector should now return an empty array since nothing
-    # has been added since its last harvest
-    errors = @error_collector.harvest!
-    assert_empty errors
   end
 
   def test_drops_deprecated_options
     expects_logging(:warn, any_parameters)
-    @error_collector.notice_error(StandardError.new("message"),
+    error = @error_collector.create_noticed_error(StandardError.new("message"),
                                   :referer => "lalalalala",
                                   :request => stub('request'),
                                   :request_params => {:x => 'y'})
 
-    errors = @error_collector.harvest!
-
-    assert_empty errors.first.attributes_from_notice_error
-  end
-
-  def test_long_message
-    #yes, times 500. it's a 5000 byte string. Assuming strings are
-    #still 1 byte / char.
-    @error_collector.notice_error(StandardError.new("1234567890" * 500), :uri => '/myurl/', :metric => 'path')
-
-    errors = @error_collector.harvest!
-
-    assert_equal errors.length, 1
-
-    err = errors.first
-    assert_equal 4096, err.message.length
-    assert_equal ('1234567890' * 500)[0..4095], err.message
-  end
-
-  def test_collect_failover
-    @error_collector.notice_error(StandardError.new("message"), :metric => 'first')
-
-    errors = @error_collector.harvest!
-
-    @error_collector.notice_error(StandardError.new("message"), :metric => 'second')
-    @error_collector.notice_error(StandardError.new("message"), :metric => 'path')
-    @error_collector.notice_error(StandardError.new("message"), :metric => 'last')
-
-    @error_collector.merge!(errors)
-    errors = @error_collector.harvest!
-
-    assert_equal 4, errors.length
-    assert_equal_unordered(%w(first second path last), errors.map { |e| e.path })
-
-    @error_collector.notice_error(StandardError.new("message"), :metric => 'first')
-    @error_collector.notice_error(StandardError.new("message"), :metric => 'last')
-
-    errors = @error_collector.harvest!
-    assert_equal 2, errors.length
-    assert_equal 'first', errors.first.path
-    assert_equal 'last', errors.last.path
-  end
-
-  def test_queue_overflow
-    max_q_length = NewRelic::Agent::ErrorCollector::MAX_ERROR_QUEUE_LENGTH
-
-    silence_stream(::STDOUT) do
-     (max_q_length + 5).times do |n|
-        @error_collector.notice_error(StandardError.new("exception #{n}"),
-                                      :metric => "path",
-                                      :custom_params => {:x => n})
-      end
-    end
-
-    errors = @error_collector.harvest!
-    assert errors.length == max_q_length
-    errors.each_index do |i|
-      error  = errors.shift
-      actual = error.to_collector_array.last["userAttributes"]["x"]
-      assert_equal i.to_s, actual
-    end
-  end
-
-  # Why would anyone undef these methods?
-  class TestClass
-    undef to_s
-    undef inspect
-  end
-
-
-  def test_supported_param_types
-    types = [[1, '1'],
-    [1.1, '1.1'],
-    ['hi', 'hi'],
-    [:hi, 'hi'],
-    [StandardError.new("test"), "#<StandardError>"],
-    [TestClass.new, "#<NewRelic::Agent::ErrorCollectorTest::TestClass>"]
-    ]
 
-    types.each do |test|
-      @error_collector.notice_error(StandardError.new("message"),
-                                    :metric => 'path',
-                                    :custom_params => {:x => test[0]})
-      error = @error_collector.harvest![0].to_collector_array
-      actual = error.last["userAttributes"]["x"]
-      assert_equal test[1], actual
-    end
+    assert_empty error.attributes_from_notice_error
   end
 
-
   def test_exclude
     @error_collector.ignore(["IOError"])
 
     @error_collector.notice_error(IOError.new("message"), :metric => 'path')
 
-    errors = @error_collector.harvest!
+    errors = harvest_error_traces
 
     assert_equal 0, errors.length
   end
@@ -195,10 +63,9 @@ class NewRelic::Agent::ErrorCollectorTest < Minitest::Test
     NewRelic::Agent.config.add_config_for_testing(:'error_collector.ignore_errors' => "IOError")
     @error_collector.notice_error(IOError.new("message"))
 
-    errors = @error_collector.harvest!
+    errors = harvest_error_traces
 
     assert_equal 1, errors.length
-
   end
 
   def test_exclude_block
@@ -207,7 +74,7 @@ class NewRelic::Agent::ErrorCollectorTest < Minitest::Test
     @error_collector.notice_error(IOError.new("message"), :metric => 'path')
     @error_collector.notice_error(StandardError.new("message"), :metric => 'path')
 
-    errors = @error_collector.harvest!
+    errors = harvest_error_traces
 
     assert_equal 1, errors.length
   end
@@ -219,7 +86,7 @@ class NewRelic::Agent::ErrorCollectorTest < Minitest::Test
 
     @error_collector.notice_error(StandardError.new("message"))
 
-    errors = @error_collector.harvest!
+    errors = harvest_error_traces
 
     assert_equal 1, errors.length
   end
@@ -233,19 +100,7 @@ class NewRelic::Agent::ErrorCollectorTest < Minitest::Test
     new_error_collector = NewRelic::Agent::ErrorCollector.new
     new_error_collector.notice_error(StandardError.new("message"))
 
-    assert_empty new_error_collector.harvest!
-  end
-
-  def test_obfuscates_error_messages_when_high_security_is_set
-    with_config(:high_security => true) do
-      @error_collector.notice_error(StandardError.new("YO SQL BAD: serect * flom test where foo = 'bar'"))
-      @error_collector.notice_error(StandardError.new("YO SQL BAD: serect * flom test where foo in (1,2,3,4,5)"))
-
-      errors = @error_collector.harvest!
-
-      assert_equal(NewRelic::NoticedError::STRIPPED_EXCEPTION_REPLACEMENT_MESSAGE, errors[0].message)
-      assert_equal(NewRelic::NoticedError::STRIPPED_EXCEPTION_REPLACEMENT_MESSAGE, errors[1].message)
-    end
+    assert_empty new_error_collector.error_trace_aggregator.harvest!
   end
 
   def test_increments_count_on_errors
@@ -274,7 +129,7 @@ class NewRelic::Agent::ErrorCollectorTest < Minitest::Test
                              'Errors/OtherTransaction/AnotherFramework/Job/perform'])
   end
 
-  def test_icrement_error_count_summary_outside_transaction
+  def test_increment_error_count_summary_outside_transaction
     @error_collector.increment_error_count!(NewRelic::Agent::TransactionState.tl_get, StandardError.new('Boo'))
 
     assert_metrics_recorded(['Errors/all'])
@@ -289,95 +144,6 @@ class NewRelic::Agent::ErrorCollectorTest < Minitest::Test
     assert_metrics_not_recorded(['Errors/(unknown)'])
   end
 
-
-  class DifficultToDebugAgentError < NewRelic::Agent::InternalAgentError
-  end
-
-  class AnotherToughAgentError < NewRelic::Agent::InternalAgentError
-  end
-
-  def test_notices_agent_error
-    @error_collector.notice_agent_error(DifficultToDebugAgentError.new)
-    assert_equal 1, @error_collector.errors.size
-  end
-
-  def test_only_notices_agent_error_per_type
-    @error_collector.notice_agent_error(DifficultToDebugAgentError.new)
-    @error_collector.notice_agent_error(DifficultToDebugAgentError.new)
-
-    assert_equal 1, @error_collector.errors.size
-  end
-
-  def test_only_notices_agent_error_per_type_allows_other_types
-    @error_collector.notice_agent_error(DifficultToDebugAgentError.new)
-    @error_collector.notice_agent_error(DifficultToDebugAgentError.new)
-    @error_collector.notice_agent_error(AnotherToughAgentError.new)
-
-    assert_equal 2, @error_collector.errors.size
-  end
-
-  def test_does_not_touch_error_metrics
-    @error_collector.notice_agent_error(DifficultToDebugAgentError.new)
-    @error_collector.notice_agent_error(DifficultToDebugAgentError.new)
-    @error_collector.notice_agent_error(AnotherToughAgentError.new)
-
-    assert_metrics_recorded_exclusive([])
-  end
-
-  def test_notice_agent_error_set_noticed_error_attributes
-    @error_collector.notice_agent_error(DifficultToDebugAgentError.new)
-
-    err = @error_collector.errors.first
-    assert_equal "NewRelic/AgentError", err.path
-    refute_nil err.stack_trace
-  end
-
-  def test_notice_agent_error_uses_exception_backtrace_if_present
-    trace = ["boo", "yeah", "error"]
-    exception = DifficultToDebugAgentError.new
-    exception.set_backtrace(trace)
-    @error_collector.notice_agent_error(exception)
-
-    assert_equal trace, @error_collector.errors.first.stack_trace
-  end
-
-  def test_notice_agent_error_uses_caller_if_no_exception_backtrace
-    exception = DifficultToDebugAgentError.new
-    exception.set_backtrace(nil)
-    @error_collector.notice_agent_error(exception)
-
-    trace = @error_collector.errors.first.stack_trace
-    assert trace.any? {|line| line.include?(__FILE__)}
-  end
-
-  def test_notice_agent_error_allows_an_error_past_queue_limit
-    100.times { @error_collector.notice_error(StandardError.new("Ouch")) }
-
-    exception = DifficultToDebugAgentError.new
-    @error_collector.notice_agent_error(exception)
-
-    assert_equal 21, @error_collector.errors.size
-    assert_equal DifficultToDebugAgentError.name, @error_collector.errors.last.exception_class_name
-  end
-
-  def test_notice_agent_error_doesnt_clog_up_the_queue_limit
-    exception = DifficultToDebugAgentError.new
-    @error_collector.notice_agent_error(exception)
-
-    100.times { @error_collector.notice_error(StandardError.new("Ouch")) }
-
-    assert_equal 21, @error_collector.errors.size
-  end
-
-  def test_notice_agent_error_adds_support_message
-    exception = DifficultToDebugAgentError.new("BOO")
-    @error_collector.notice_agent_error(exception)
-
-    err = @error_collector.errors.first
-    assert err.message.include?(exception.message)
-    assert err.message.include?("Ruby agent internal error")
-  end
-
   def test_blamed_metric_from_options_outside_txn
     @error_collector.notice_error(StandardError.new('wut'), :metric => 'boo')
     assert_metrics_recorded(
@@ -420,8 +186,10 @@ class NewRelic::Agent::ErrorCollectorTest < Minitest::Test
       @error_collector.notice_error(error)
     end
 
+    errors = @error_collector.error_trace_aggregator.harvest!
+
     assert_metrics_recorded('Errors/all' => { :call_count => 1 })
-    assert_equal 1, @error_collector.errors.length
+    assert_equal 1, errors.length
   end
 
   def test_doesnt_count_seen_exceptions
@@ -431,8 +199,10 @@ class NewRelic::Agent::ErrorCollectorTest < Minitest::Test
       @error_collector.notice_error(error)
     end
 
+    errors = @error_collector.error_trace_aggregator.harvest!
+
     assert_metrics_not_recorded(['Errors/all'])
-    assert_empty @error_collector.errors
+    assert_empty errors
   end
 
   def test_captures_attributes_on_notice_error
@@ -440,7 +210,9 @@ class NewRelic::Agent::ErrorCollectorTest < Minitest::Test
     attributes = Object.new
     @error_collector.notice_error(error, :attributes => attributes)
 
-    noticed = @error_collector.errors.first
+    errors = @error_collector.error_trace_aggregator.harvest!
+    noticed = errors.first
+
     assert_equal attributes, noticed.attributes
   end
 
@@ -597,9 +369,7 @@ class NewRelic::Agent::ErrorCollectorTest < Minitest::Test
     end
   end
 
-  def silence_stream(*args)
-    super
-  rescue NoMethodError
-    yield
+  def harvest_error_traces
+    @error_collector.error_trace_aggregator.harvest!
   end
 end

data/test/new_relic/agent/error_event_aggregator_test.rb

@@ -0,0 +1,294 @@
+# 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/error_event_aggregator'
+
+module NewRelic
+  module Agent
+    class ErrorEventAggregatorTest < Minitest::Test
+      def setup
+        freeze_time
+        @error_event_aggregator = ErrorEventAggregator.new
+      end
+
+      def teardown
+        error_event_aggregator.reset!
+        reset_error_event_buffer_state
+      end
+
+      def create_container
+        @error_event_aggregator
+      end
+
+      def populate_container(sampler, n)
+        n.times do
+          error = NewRelic::NoticedError.new "Controller/blogs/index", RuntimeError.new("Big Controller")
+          payload = in_transaction{}.payload
+          @error_event_aggregator.append_event error, payload
+        end
+      end
+
+      include NewRelic::DataContainerTests
+
+      def test_generates_event_from_error
+        generate_error
+
+        intrinsics, *_ = last_error_event
+
+        assert_equal "TransactionError", intrinsics[:type]
+        assert_equal Time.now.to_f, intrinsics[:timestamp]
+        assert_equal "RuntimeError", intrinsics[:'error.class']
+        assert_equal "Big Controller!", intrinsics[:'error.message']
+        assert_equal "Controller/blogs/index", intrinsics[:transactionName]
+        assert_equal 0.1, intrinsics[:duration]
+        assert_equal 80, intrinsics[:port]
+      end
+
+      def test_event_includes_synthetics
+        generate_error :payload_options => {
+          :synthetics_resource_id=>3,
+          :synthetics_job_id=>4,
+          :synthetics_monitor_id=>5
+        }
+
+        intrinsics, *_ = last_error_event
+
+        assert_equal 3, intrinsics[:'nr.syntheticsResourceId']
+        assert_equal 4, intrinsics[:'nr.syntheticsJobId']
+        assert_equal 5, intrinsics[:'nr.syntheticsMonitorId']
+      end
+
+      def test_includes_mapped_metrics
+        metrics = NewRelic::Agent::TransactionMetrics.new
+        metrics.record_unscoped 'Datastore/all', 10
+        metrics.record_unscoped 'GC/Transaction/all', 11
+        metrics.record_unscoped 'WebFrontend/QueueTime', 12
+        metrics.record_unscoped 'External/allWeb', 13
+
+        generate_error :payload_options => {:metrics => metrics}
+
+        intrinsics, *_ = last_error_event
+
+        assert_equal 10.0, intrinsics["databaseDuration"]
+        assert_equal 1, intrinsics["databaseCallCount"]
+        assert_equal 11.0, intrinsics["gcCumulative"]
+        assert_equal 12.0, intrinsics["queueDuration"]
+        assert_equal 13.0, intrinsics["externalDuration"]
+        assert_equal 1, intrinsics["externalCallCount"]
+      end
+
+      def test_includes_cat_attributes
+        generate_error :payload_options => {:guid => "GUID", :referring_transaction_guid=>"REFERRING_GUID"}
+
+        intrinsics, *_ = last_error_event
+
+        assert_equal "GUID", intrinsics[:"nr.transactionGuid"]
+        assert_equal "REFERRING_GUID", intrinsics[:"nr.referringTransactionGuid"]
+      end
+
+      def test_includes_custom_attributes
+        attrs = {"user" => "Wes Mantooth", "channel" => 9}
+
+        attributes = Transaction::Attributes.new(NewRelic::Agent.instance.attribute_filter)
+        attributes.merge_custom_attributes attrs
+
+        generate_error :error_options => {:attributes => attributes}
+
+        _, custom_attrs, _ = last_error_event
+
+        assert_equal attrs, custom_attrs
+      end
+
+      def test_includes_agent_attributes
+        attributes = Transaction::Attributes.new(NewRelic::Agent.instance.attribute_filter)
+        attributes.add_agent_attribute :'request.headers.referer', "http://blog.site/home", AttributeFilter::DST_ERROR_COLLECTOR
+        attributes.add_agent_attribute :httpResponseCode, "200", AttributeFilter::DST_ERROR_COLLECTOR
+
+        generate_error :error_options => {:attributes => attributes}
+
+        _, _, agent_attrs = last_error_event
+
+        expected = {:"request.headers.referer" => "http://blog.site/home", :httpResponseCode => "200"}
+        assert_equal expected, agent_attrs
+      end
+
+      def test_respects_max_samples_stored
+        with_config :'error_collector.max_event_samples_stored' => 5 do
+          10.times { generate_error }
+        end
+
+        assert_equal 5, last_error_events.size
+      end
+
+      def test_reservoir_stats_reset_after_harvest
+        5.times { generate_error }
+
+        reservoir_stats, samples = error_event_aggregator.harvest!
+        assert_equal 5, reservoir_stats[:events_seen]
+
+        reservoir_stats, samples = error_event_aggregator.harvest!
+        assert_equal 0, reservoir_stats[:events_seen]
+      end
+
+      def test_merge_merges_samples_back_into_buffer
+        5.times { generate_error }
+
+        last_harvest = error_event_aggregator.harvest!
+
+        5.times { generate_error }
+
+        error_event_aggregator.merge!(last_harvest)
+        events = last_error_events
+
+        assert_equal(10, events.size)
+      end
+
+      def test_merge_abides_by_max_samples_limit
+        with_config :'error_collector.max_event_samples_stored' => 5 do
+          4.times { generate_error }
+          last_harvest = error_event_aggregator.harvest!
+
+          4.times { generate_error }
+          error_event_aggregator.merge!(last_harvest)
+
+          assert_equal(5, last_error_events.size)
+        end
+      end
+
+      def test_sample_counts_are_correct_after_merge
+        with_config :'error_collector.max_event_samples_stored' => 5 do
+          buffer = error_event_aggregator.instance_variable_get :@error_event_buffer
+
+          4.times { generate_error }
+          last_harvest = error_event_aggregator.harvest!
+
+          assert_equal 4, buffer.seen_lifetime
+          assert_equal 4, buffer.captured_lifetime
+          assert_equal 4, last_harvest[0][:events_seen]
+
+          4.times { generate_error }
+          error_event_aggregator.merge! last_harvest
+
+          reservoir_stats, samples = error_event_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_limits_total_number_of_samples_to_max_samples_stored
+        with_config :'error_collector.max_event_samples_stored' => 100 do
+          150.times { generate_error }
+          assert_equal 100, last_error_events.size
+        end
+      end
+
+      def test_resets_limits_on_harvest
+        with_config :'error_collector.max_event_samples_stored' => 100 do
+          50.times { generate_error }
+          events_before = last_error_events
+          assert_equal 50, events_before.size
+
+          150.times { generate_error }
+          events_after = last_error_events
+          assert_equal 100, events_after.size
+        end
+      end
+
+      def test_does_not_drop_samples_when_used_from_multiple_threads
+        with_config :'error_collector.max_event_samples_stored' => 100 * 100 do
+          threads = []
+          25.times do
+            threads << Thread.new do
+              100.times{ generate_error }
+            end
+          end
+          threads.each { |t| t.join }
+
+          assert_equal(25 * 100, last_error_events.size)
+        end
+      end
+
+      def test_errors_not_noticed_when_disabled
+        with_config :'error_collector.capture_events' => false do
+          generate_error
+          errors = last_error_events
+          assert_empty errors
+        end
+      end
+
+      def test_errors_noticed_when_error_traces_disabled
+        config = {
+          :'error_collector.enabled' => false,
+          :'error_collector.capture_events' => true
+        }
+        with_config config do
+          generate_error
+          errors = last_error_events
+          assert_equal 1, errors.size
+        end
+      end
+
+      def error_event_aggregator
+        @error_event_aggregator
+      end
+
+      def last_error_events
+        error_event_aggregator.harvest![1]
+      end
+
+      def last_error_event
+        last_error_events.first
+      end
+
+      def reset_error_event_buffer_state
+        # this is not ideal, but we need to reset these counts to clear out state
+        # between tests
+        buffer = error_event_aggregator.instance_variable_get :@error_event_buffer
+        buffer.instance_variable_set :@seen_lifetime, 0
+        buffer.instance_variable_set :@captured_lifetime, 0
+      end
+
+      def create_noticed_error options = {}
+        exception = options.delete(:exception) || RuntimeError.new("Big Controller!")
+        txn_name = "Controller/blogs/index"
+        noticed_error = NewRelic::NoticedError.new(txn_name, exception)
+        noticed_error.request_uri = "http://site.com/blogs"
+        noticed_error.request_port = 80
+        noticed_error.attributes  = options.delete(:attributes)
+        noticed_error.attributes_from_notice_error = options.delete(:custom_params) || {}
+        noticed_error.attributes_from_notice_error.merge!(options)
+
+        noticed_error
+      end
+
+      def create_transaction_payload options = {}
+        {
+          :name => "Controller/blogs/index",
+          :type => :controller,
+          :start_timestamp => Time.now.to_f,
+          :duration => 0.1
+        }.update(options)
+      end
+
+      def generate_error options = {}
+        error = create_noticed_error options[:error_options] || {}
+        payload = create_transaction_payload options[:payload_options] || {}
+        @error_event_aggregator.append_event error, payload
+      end
+
+      def generate_errors num_errors
+        txn_name = "Controller/blogs/index"
+
+        in_transaction :transaction_name => txn_name do |t|
+          num_errors.times {t.notice_error RuntimeError.new}
+        end
+      end
+    end
+  end
+end