RubyGems - newrelic_rpm - Versions diffs - 4.0.0.332 → 4.4.0.336 - Mend

newrelic_rpm 4.0.0.332 → 4.4.0.336

Files changed (917) hide show

data/test/new_relic/agent/error_collector_test.rb DELETED Viewed

@@ -1,407 +0,0 @@
-# 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/internal_agent_error'
-class NewRelic::Agent::ErrorCollectorTest < Minitest::Test
-  def setup
-    @test_config = {
-      :capture_params => true,
-      :disable_harvest_thread => true
-    }
-    NewRelic::Agent.config.add_config_for_testing(@test_config)
-    @error_collector = NewRelic::Agent::ErrorCollector.new
-    @error_collector.stubs(:enabled).returns(true)
-    NewRelic::Agent::TransactionState.tl_clear_for_testing
-    NewRelic::Agent.instance.stats_engine.reset!
-  end
-  def teardown
-    super
-    NewRelic::Agent::ErrorCollector.ignore_error_filter = nil
-    NewRelic::Agent::TransactionState.tl_clear_for_testing
-    NewRelic::Agent.config.reset_to_defaults
-  end
-  # Tests
-  def test_empty
-    @error_collector.notice_error(nil, :metric=> 'path')
-    traces = harvest_error_traces
-    events = harvest_error_events
-    assert_equal 0, traces.length
-    assert_equal 0, events.length
-  end
-  def test_records_error_outside_of_transaction
-    @error_collector.notice_error StandardError.new
-    traces = harvest_error_traces
-    events = harvest_error_events
-    assert_equal 1, traces.length
-    assert_equal 1, events.length
-  end
-  def test_exclude
-    @error_collector.ignore(["IOError"])
-    @error_collector.notice_error(IOError.new("message"), :metric => 'path')
-    traces = harvest_error_traces
-    events = harvest_error_events
-    assert_equal 0, traces.length
-    assert_equal 0, events.length
-  end
-  def test_exclude_later_config_changes
-    @error_collector.notice_error(IOError.new("message"))
-    NewRelic::Agent.config.add_config_for_testing(:'error_collector.ignore_errors' => "IOError")
-    @error_collector.notice_error(IOError.new("message"))
-    traces = harvest_error_traces
-    events = harvest_error_events
-    assert_equal 1, traces.length
-    assert_equal 1, events.length
-  end
-  def test_exclude_block
-    @error_collector.class.ignore_error_filter = wrapped_filter_proc
-    @error_collector.notice_error(IOError.new("message"), :metric => 'path')
-    @error_collector.notice_error(StandardError.new("message"), :metric => 'path')
-    traces = harvest_error_traces
-    events = harvest_error_events
-    assert_equal 1, traces.length
-    assert_equal 1, events.length
-  end
-  def test_failure_in_exclude_block
-    @error_collector.class.ignore_error_filter = Proc.new do
-      raise "HAHAHAHAH, error in the filter for ignoring errors!"
-    end
-    @error_collector.notice_error(StandardError.new("message"))
-    traces = harvest_error_traces
-    events = harvest_error_events
-    assert_equal 1, traces.length
-    assert_equal 1, events.length
-  end
-  def test_failure_block_assigned_with_different_instance
-    @error_collector.class.ignore_error_filter = Proc.new do |*_|
-      # meh, ignore 'em all!
-      nil
-    end
-    new_error_collector = NewRelic::Agent::ErrorCollector.new
-    new_error_collector.notice_error(StandardError.new("message"))
-    assert_empty new_error_collector.error_trace_aggregator.harvest!
-  end
-  def test_increments_count_on_errors
-    @error_collector.notice_error(StandardError.new("Boo"))
-    assert_metrics_recorded(
-      'Errors/all' => { :call_count => 1}
-    )
-    @error_collector.notice_error(StandardError.new("Boo"))
-    assert_metrics_recorded(
-      'Errors/all' => { :call_count => 2}
-    )
-  end
-  def test_increment_error_count_record_summary_and_web_txn_metric
-    in_web_transaction('Controller/class/method') do
-      @error_collector.increment_error_count!(NewRelic::Agent::TransactionState.tl_get, StandardError.new('Boo'))
-    end
-    assert_metrics_recorded(['Errors/all',
-                             'Errors/allWeb',
-                             'Errors/Controller/class/method'])
-  end
-  def test_increment_error_count_record_summary_and_other_txn_metric
-    in_background_transaction('OtherTransaction/AnotherFramework/Job/perform') do
-      @error_collector.increment_error_count!(NewRelic::Agent::TransactionState.tl_get, StandardError.new('Boo'))
-    end
-    assert_metrics_recorded(['Errors/all',
-                             'Errors/allOther',
-                             'Errors/OtherTransaction/AnotherFramework/Job/perform'])
-  end
-  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'])
-    assert_metrics_not_recorded(['Errors/allWeb', 'Errors/allOther'])
-  end
-  def test_doesnt_increment_error_count_on_transaction_if_nameless
-    @error_collector.increment_error_count!(NewRelic::Agent::TransactionState.tl_get,
-                                            StandardError.new('Boo'),
-                                            :metric => '(unknown)')
-    assert_metrics_not_recorded(['Errors/(unknown)'])
-  end
-  def test_blamed_metric_from_options_outside_txn
-    @error_collector.notice_error(StandardError.new('wut'), :metric => 'boo')
-    assert_metrics_recorded(
-      'Errors/boo' => { :call_count => 1}
-    )
-  end
-  def test_blamed_metric_from_options_inside_txn
-    in_transaction('Not/What/Youre/Looking/For') do
-      @error_collector.notice_error(StandardError.new('wut'), :metric => 'boo')
-    end
-    assert_metrics_recorded_exclusive(
-      {
-        'Errors/all'      => { :call_count => 1 },
-        'Errors/boo'      => { :call_count => 1 },
-        'Errors/allOther' => { :call_count => 1 }
-      },
-      :filter => /^Errors\//
-    )
-  end
-  def test_blamed_metric_from_transaction
-    in_transaction('Controller/foo/bar') do
-      @error_collector.notice_error(StandardError.new('wut'))
-    end
-    assert_metrics_recorded(
-      'Errors/Controller/foo/bar' => { :call_count => 1 }
-    )
-  end
-  def test_blamed_metric_with_no_transaction_and_no_options
-    @error_collector.notice_error(StandardError.new('wut'))
-    assert_metrics_recorded_exclusive(['Errors/all'])
-  end
-  def test_doesnt_double_count_same_exception
-    in_transaction do
-      error = StandardError.new('wat')
-      @error_collector.notice_error(error)
-      @error_collector.notice_error(error)
-    end
-    errors = @error_collector.error_trace_aggregator.harvest!
-    assert_metrics_recorded('Errors/all' => { :call_count => 1 })
-    assert_equal 1, errors.length
-  end
-  def test_doesnt_count_seen_exceptions
-    in_transaction do
-      error = StandardError.new('wat')
-      @error_collector.tag_exception(error)
-      @error_collector.notice_error(error)
-    end
-    errors = @error_collector.error_trace_aggregator.harvest!
-    assert_metrics_not_recorded(['Errors/all'])
-    assert_empty errors
-  end
-  def test_captures_attributes_on_notice_error
-    error = StandardError.new('wat')
-    attributes = Object.new
-    @error_collector.notice_error(error, :attributes => attributes)
-    errors = @error_collector.error_trace_aggregator.harvest!
-    noticed = errors.first
-    assert_equal attributes, noticed.attributes
-  end
-  module Winner
-    def winner
-      'yay'
-    end
-  end
-  def test_sense_method
-    object = Object.new
-    object.extend(Winner)
-    assert_equal nil,   @error_collector.sense_method(object, 'blab')
-    assert_equal 'yay', @error_collector.sense_method(object, 'winner')
-  end
-  def test_extract_stack_trace
-    assert_equal('<no stack trace>', @error_collector.extract_stack_trace(Exception.new))
-  end
-  if defined?(Rails) && Rails::VERSION::MAJOR < 5
-    def test_extract_stack_trace_from_original_exception
-      orig = mock('original', :backtrace => "STACK STACK STACK")
-      exception = mock('exception', :original_exception => orig)
-      assert_equal('STACK STACK STACK', @error_collector.extract_stack_trace(exception))
-    end
-  end
-  def test_skip_notice_error_is_true_if_the_error_collector_is_disabled
-    error = StandardError.new
-    with_config(:'error_collector.enabled' => false, :'error_collector.capture_events' => false) do
-      assert @error_collector.skip_notice_error?(error)
-    end
-  end
-  def test_skip_notice_error_is_true_if_the_error_is_nil
-    error = nil
-    with_config(:'error_collector.enabled' => true) do
-      @error_collector.expects(:error_is_ignored?).with(error).returns(false)
-      assert @error_collector.skip_notice_error?(error)
-    end
-  end
-  def test_skip_notice_error_is_true_if_the_error_is_ignored
-    error = StandardError.new
-    with_config(:'error_collector.enabled' => true) do
-      @error_collector.expects(:error_is_ignored?).with(error).returns(true)
-      assert @error_collector.skip_notice_error?(error)
-    end
-  end
-  def test_skip_notice_error_returns_false_for_non_nil_unignored_errors_with_an_enabled_error_collector
-    error = StandardError.new
-    with_config(:'error_collector.enabled' => true) do
-      @error_collector.expects(:error_is_ignored?).with(error).returns(false)
-      refute @error_collector.skip_notice_error?(error)
-    end
-  end
-  class ::AnError
-  end
-  def test_filtered_error_positive
-    with_config(:'error_collector.ignore_errors' => 'AnError') do
-      error = AnError.new
-      assert @error_collector.filtered_error?(error)
-    end
-  end
-  def test_filtered_error_negative
-    error = AnError.new
-    refute @error_collector.filtered_error?(error)
-  end
-  def test_filtered_by_error_filter_empty
-    # should return right away when there's no filter
-    refute @error_collector.filtered_by_error_filter?(nil)
-  end
-  def test_filtered_by_error_filter_positive
-    saw_error = nil
-    NewRelic::Agent::ErrorCollector.ignore_error_filter = Proc.new do |e|
-      saw_error = e
-      false
-    end
-    error = StandardError.new
-    assert @error_collector.filtered_by_error_filter?(error)
-    assert_equal error, saw_error
-  end
-  def test_filtered_by_error_filter_negative
-    saw_error = nil
-    NewRelic::Agent::ErrorCollector.ignore_error_filter = Proc.new do |e|
-      saw_error = e
-      true
-    end
-    error = StandardError.new
-    refute @error_collector.filtered_by_error_filter?(error)
-    assert_equal error, saw_error
-  end
-  def test_error_is_ignored_no_error
-    refute @error_collector.error_is_ignored?(nil)
-  end
-  def test_does_not_tag_frozen_errors
-    e = StandardError.new
-    e.freeze
-    @error_collector.notice_error(e)
-    refute @error_collector.exception_tagged?(e)
-  end
-  def test_handles_failures_during_error_tagging
-    e = StandardError.new
-    e.stubs(:instance_variable_set).raises(RuntimeError)
-    expects_logging(:warn, any_parameters)
-    @error_collector.notice_error(e)
-  end
-  if NewRelic::LanguageSupport.jruby?
-    def test_does_not_tag_java_objects
-      e = java.lang.String.new
-      @error_collector.notice_error(e)
-      refute @error_collector.exception_tagged?(e)
-    end
-  end
-  def test_trace_only_does_not_increment_metrics
-    @error_collector.notice_error(StandardError.new, :trace_only => true)
-    traces = harvest_error_traces
-    events = harvest_error_events
-    assert_equal 1, traces.length
-    assert_equal 1, events.length
-    assert_metrics_not_recorded ['Errors/all']
-  end
-  def test_trace_only_not_recorded_as_custom_attribute
-    @error_collector.notice_error(StandardError.new, :trace_only => true)
-    traces = harvest_error_traces
-    events = harvest_error_events
-    assert_equal 1, traces.length
-    assert_equal 1, events.length
-    event_attrs = events[0][1]
-    refute event_attrs.key?("trace_only"), "Unexpected attribute trace_only found in custom attributes"
-    trace_attrs = traces[0].attributes_from_notice_error
-    refute trace_attrs.key?(:trace_only), "Unexpected attribute trace_only found in custom attributes"
-  end
-  private
-  def wrapped_filter_proc
-    Proc.new do |e|
-      if e.is_a? IOError
-        return nil
-      else
-        return e
-      end
-    end
-  end
-  def harvest_error_traces
-    @error_collector.error_trace_aggregator.harvest!
-  end
-  def harvest_error_events
-    @error_collector.error_event_aggregator.harvest![1]
-  end
-end

data/test/new_relic/agent/error_event_aggregator_test.rb DELETED Viewed

@@ -1,237 +0,0 @@
-# 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_without_payload
-        error_event_aggregator.append_event create_noticed_error, nil
-        intrinsics, *_ = last_error_event
-        assert_equal 'TransactionError', intrinsics['type']
-        assert_in_delta Time.now.to_f, intrinsics['timestamp'], 0.001
-        assert_equal "RuntimeError", intrinsics['error.class']
-        assert_equal "Big Controller!", intrinsics['error.message']
-      end
-      def test_generates_event_from_error
-        generate_error
-        intrinsics, *_ = last_error_event
-        assert_equal 'TransactionError', intrinsics['type']
-        assert_in_delta Time.now.to_f, intrinsics['timestamp'], 0.001
-        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_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 :@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 :@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