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

newrelic_rpm 4.0.0.332 → 4.8.0.341

Files changed (969) hide show

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

@@ -1,298 +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'))
-module NewRelic
-  module Agent
-    class ErrorTraceAggregatorTest < Minitest::Test
-      def setup
-        @error_trace_aggregator = NewRelic::Agent::ErrorTraceAggregator.new ErrorCollector::MAX_ERROR_QUEUE_LENGTH
-      end
-      def teardown
-        NewRelic::Agent.instance.stats_engine.reset!
-        @error_trace_aggregator.reset!
-      end
-     # Helpers for DataContainerTests
-      def create_container
-        ErrorTraceAggregator.new ErrorCollector::MAX_ERROR_QUEUE_LENGTH
-      end
-      def populate_container(aggregator, n)
-        n.times do |i|
-          error = NewRelic::NoticedError.new 'path', 'yay errors'
-          aggregator.add_to_error_queue error
-        end
-      end
-      include NewRelic::DataContainerTests
-      def test_simple
-        notice_error(StandardError.new("message"),
-                                      :uri => '/myurl/',
-                                      :metric => 'path')
-        errors = error_trace_aggregator.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_trace_aggregator.harvest!
-        assert_empty errors
-      end
-      def test_collect_failover
-        notice_error(StandardError.new("message"), :metric => 'first')
-        errors = error_trace_aggregator.harvest!
-        notice_error(StandardError.new("message"), :metric => 'second')
-        notice_error(StandardError.new("message"), :metric => 'path')
-        notice_error(StandardError.new("message"), :metric => 'last')
-        error_trace_aggregator.merge!(errors)
-        errors = error_trace_aggregator.harvest!
-        assert_equal 4, errors.length
-        assert_equal_unordered(%w(first second path last), errors.map { |e| e.path })
-        notice_error(StandardError.new("message"), :metric => 'first')
-        notice_error(StandardError.new("message"), :metric => 'last')
-        errors = error_trace_aggregator.harvest!
-        assert_equal 2, errors.length
-        assert_equal 'first', errors.first.path
-        assert_equal 'last', errors.last.path
-      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::ErrorTraceAggregatorTest::TestClass>"]
-        ]
-        types.each do |test|
-          notice_error(StandardError.new("message"),
-                                        :metric => 'path',
-                                        :custom_params => {:x => test[0]})
-          error = error_trace_aggregator.harvest![0].to_collector_array
-          actual = error.last["userAttributes"]["x"]
-          assert_equal test[1], actual
-        end
-      end
-      def test_obfuscates_error_messages_when_high_security_is_set
-        with_config(:high_security => true) do
-          notice_error(StandardError.new("YO SQL BAD: serect * flom test where foo = 'bar'"))
-          notice_error(StandardError.new("YO SQL BAD: serect * flom test where foo in (1,2,3,4,5)"))
-          errors = error_trace_aggregator.harvest!
-          assert_equal(NewRelic::NoticedError::STRIPPED_EXCEPTION_REPLACEMENT_MESSAGE, errors[0].message)
-          assert_equal(NewRelic::NoticedError::STRIPPED_EXCEPTION_REPLACEMENT_MESSAGE, errors[1].message)
-        end
-      end
-      def test_over_queue_limit_negative
-        refute error_trace_aggregator.over_queue_limit?(nil)
-      end
-      def test_over_queue_limit_positive
-        expects_logging(:warn, includes('The error reporting queue has reached 20'))
-        21.times do
-          error = stub(:message => "", :is_internal => false)
-          error_trace_aggregator.add_to_error_queue(error)
-        end
-        assert error_trace_aggregator.over_queue_limit?('hooray')
-      end
-      def test_queue_overflow
-        max_q_length = ErrorCollector::MAX_ERROR_QUEUE_LENGTH
-        silence_stream(::STDOUT) do
-         (max_q_length + 5).times do |n|
-            notice_error(StandardError.new("exception #{n}"),
-                                          :metric => "path",
-                                          :custom_params => {:x => n})
-          end
-        end
-        errors = error_trace_aggregator.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
-      class DifficultToDebugAgentError < NewRelic::Agent::InternalAgentError
-      end
-      class AnotherToughAgentError < NewRelic::Agent::InternalAgentError
-      end
-      def test_notices_agent_error
-        error_trace_aggregator.notice_agent_error(DifficultToDebugAgentError.new)
-        errors = error_trace_aggregator.harvest!
-        assert_equal 1, errors.size
-      end
-      def test_only_notices_agent_error_per_type
-        error_trace_aggregator.notice_agent_error(DifficultToDebugAgentError.new)
-        error_trace_aggregator.notice_agent_error(DifficultToDebugAgentError.new)
-        errors = error_trace_aggregator.harvest!
-        assert_equal 1, errors.size
-      end
-      def test_only_notices_agent_error_per_type_allows_other_types
-        error_trace_aggregator.notice_agent_error(DifficultToDebugAgentError.new)
-        error_trace_aggregator.notice_agent_error(DifficultToDebugAgentError.new)
-        error_trace_aggregator.notice_agent_error(AnotherToughAgentError.new)
-        errors = error_trace_aggregator.harvest!
-        assert_equal 2, errors.size
-      end
-      def test_does_not_touch_error_metrics
-        NewRelic::Agent.instance.stats_engine.reset!
-        error_trace_aggregator.notice_agent_error(DifficultToDebugAgentError.new)
-        error_trace_aggregator.notice_agent_error(DifficultToDebugAgentError.new)
-        error_trace_aggregator.notice_agent_error(AnotherToughAgentError.new)
-        assert_metrics_recorded_exclusive([])
-      end
-      def test_notice_agent_error_set_noticed_error_attributes
-        error_trace_aggregator.notice_agent_error(DifficultToDebugAgentError.new)
-        errors = error_trace_aggregator.harvest!
-        err = 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_trace_aggregator.notice_agent_error(exception)
-        errors = error_trace_aggregator.harvest!
-        assert_equal trace, errors.first.stack_trace
-      end
-      def test_notice_agent_error_uses_caller_if_no_exception_backtrace
-        exception = DifficultToDebugAgentError.new
-        exception.set_backtrace(nil)
-        error_trace_aggregator.notice_agent_error(exception)
-        errors = error_trace_aggregator.harvest!
-        trace = 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 { notice_error(StandardError.new("Ouch")) }
-        exception = DifficultToDebugAgentError.new
-        error_trace_aggregator.notice_agent_error(exception)
-        errors = error_trace_aggregator.harvest!
-        assert_equal 21, errors.size
-        assert_equal DifficultToDebugAgentError.name, errors.last.exception_class_name
-      end
-      def test_notice_agent_error_doesnt_clog_up_the_queue_limit
-        exception = DifficultToDebugAgentError.new
-        error_trace_aggregator.notice_agent_error(exception)
-        100.times { notice_error(StandardError.new("Ouch")) }
-        errors = error_trace_aggregator.harvest!
-        assert_equal 21, errors.size
-      end
-      def test_notice_agent_error_adds_support_message
-        exception = DifficultToDebugAgentError.new("BOO")
-        error_trace_aggregator.notice_agent_error(exception)
-        errors = error_trace_aggregator.harvest!
-        err = errors.first
-        assert err.message.include?(exception.message)
-        assert err.message.include?("Ruby agent internal error")
-      end
-      def test_errors_not_noticed_when_disabled
-        with_config :'error_collector.enabled' => false do
-          notice_error StandardError.new "Red hands"
-          errors = error_trace_aggregator.harvest!
-          assert_empty errors
-        end
-      end
-      def test_errors_noticed_when_error_events_disabled
-        config = {
-          :'error_collector.enabled' => true,
-          :'error_collector.capture_events' => false
-        }
-        with_config config do
-          notice_error StandardError.new "Red hands"
-          errors = error_trace_aggregator.harvest!
-          assert_equal 1, errors.size
-        end
-      end
-      def create_noticed_error(exception, options = {})
-        path = options.delete(:metric)
-        noticed_error = NewRelic::NoticedError.new(path, exception)
-        noticed_error.request_uri = options.delete(:uri)
-        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 notice_error(exception, options = {})
-        error = create_noticed_error(exception, options)
-        @error_trace_aggregator.add_to_error_queue error
-      end
-      def error_trace_aggregator
-        @error_trace_aggregator
-      end
-      def silence_stream(*args)
-        super
-      rescue NoMethodError
-        yield
-      end
-    end
-  end
-end

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

@@ -1,178 +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/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 DELETED Viewed

@@ -1,168 +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 '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
-  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/event_listener_test.rb DELETED Viewed

@@ -1,70 +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'))
-class EventListenerTest < Minitest::Test
-  def setup
-    @events = NewRelic::Agent::EventListener.new
-    @called = false
-    @called_with = nil
-    @check_method = Proc.new do |*args|
-      @called = true
-      @called_with = args
-    end
-  end
-  #
-  # Helpers
-  #
-  def assert_was_called
-    assert @called, "Event wasn't called"
-  end
-  def assert_was_not_called
-    assert !@called, "Event was called"
-  end
-  #
-  # Tests
-  #
-  def test_notifies
-    @events.subscribe(:before_call, &@check_method)
-    @events.notify(:before_call, :env => "env")
-    assert_was_called
-    assert_equal([{:env => "env"}], @called_with)
-  end
-  def test_failure_during_notify_doesnt_block_other_hooks
-    @events.subscribe(:after_call) { raise "Boo!" }
-    @events.subscribe(:after_call, &@check_method)
-    @events.notify(:after_call)
-    assert_was_called
-  end
-  def test_runaway_events
-    @events.runaway_threshold = 0
-    expects_logging(:debug, includes("my_event"))
-    @events.subscribe(:my_event) {}
-  end
-  def test_clear
-    @events.subscribe(:after_call, &@check_method)
-    @events.clear
-    @events.notify(:after_call)
-    assert_was_not_called
-  end
-end