newrelic_rpm 4.0.0.332 → 4.8.0.341

data/test/new_relic/noticed_error_test.rb

@@ -1,267 +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/transaction/attributes'
-
-class FooError < StandardError; end
-
-class NewRelic::Agent::NoticedErrorTest < Minitest::Test
-  include NewRelic::TestHelpers::Exceptions
-
-  def setup
-    @path = 'foo/bar/baz'
-
-    freeze_time
-    @time = Time.now
-
-    @attributes = NewRelic::Agent::Transaction::Attributes.new(NewRelic::Agent.instance.attribute_filter)
-    @attributes_from_notice_error = { :user => 'params' }
-  end
-
-  def test_to_collector_array
-    e = TestError.new('test exception')
-
-    error = create_error(e)
-    error.request_uri = "http://com.google"
-    error.attributes_from_notice_error = @attributes_from_notice_error
-
-    expected = [
-      (@time.to_f * 1000).round,
-      @path,
-      'test exception',
-      'NewRelic::TestHelpers::Exceptions::TestError',
-      {
-        :request_uri      => 'http://com.google',
-        'userAttributes'  => { 'user' => 'params' },
-        'agentAttributes' => {},
-        'intrinsics'      => {}
-      }
-    ]
-    assert_equal expected, error.to_collector_array
-  end
-
-  def test_to_collector_array_merges_custom_attributes_and_params
-    e = TestError.new('test exception')
-    @attributes.merge_custom_attributes(:custom => "attribute")
-
-    error = create_error(e)
-    error.attributes_from_notice_error = @attributes_from_notice_error
-
-    actual = extract_attributes(error)
-    expected = {
-      'userAttributes' => {
-        'user'   => 'params',
-        'custom' => 'attribute'
-      },
-      'agentAttributes' => {},
-      'intrinsics'      => {}
-    }
-
-    assert_equal expected, actual
-  end
-
-  def test_to_collector_array_includes_agent_attributes
-    e = TestError.new('test exception')
-    @attributes.add_agent_attribute(:agent, "attribute", NewRelic::Agent::AttributeFilter::DST_ALL)
-    error = create_error(e)
-
-    actual = extract_attributes(error)
-    assert_equal({:agent => "attribute"}, actual["agentAttributes"])
-  end
-
-  def test_to_collector_array_includes_intrinsic_attributes
-    e = TestError.new('test exception')
-    @attributes.add_intrinsic_attribute(:intrinsic, "attribute")
-    error = create_error(e)
-
-    actual = extract_attributes(error)
-    assert_equal({:intrinsic => "attribute"}, actual["intrinsics"])
-  end
-
-  def test_to_collector_array_happy_without_attribute_collections
-    error = NewRelic::NoticedError.new(@path, "BOOM")
-
-    expected = [
-      (@time.to_f * 1000).round,
-      @path,
-      "BOOM",
-      "Error",
-      {
-        'userAttributes'  => {},
-        'agentAttributes' => {},
-        'intrinsics'      => {}
-      }
-    ]
-    assert_equal expected, error.to_collector_array
-  end
-
-  def test_to_collector_array_with_bad_values
-    error = NewRelic::NoticedError.new(@path, nil, Rational(10, 1))
-    expected = [
-      10_000.0,
-      @path,
-      "<no message>",
-      "Error",
-      {
-        'userAttributes'  => {},
-        'agentAttributes' => {},
-        'intrinsics'      => {}
-      }
-    ]
-    assert_equal expected, error.to_collector_array
-  end
-
-  def test_handles_non_string_exception_messages
-    e = Exception.new({ :non => :string })
-    error = NewRelic::NoticedError.new(@path, e, @time)
-    assert_equal(String, error.message.class)
-  end
-
-  def test_strips_message_from_exceptions_in_high_security_mode
-    with_config(:high_security => true) do
-      e = TestError.new('test exception')
-      error = NewRelic::NoticedError.new(@path, e, @time)
-
-      assert_equal NewRelic::NoticedError::STRIPPED_EXCEPTION_REPLACEMENT_MESSAGE, error.message
-    end
-  end
-
-  def test_long_message
-    #yes, times 500. it's a 5000 byte string. Assuming strings are
-    #still 1 byte / char.
-    err = create_error(StandardError.new("1234567890" * 500))
-    assert_equal 4096, err.message.length
-    assert_equal ('1234567890' * 500)[0..4095], err.message
-  end
-
-  def test_permits_messages_from_whitelisted_exceptions_in_high_security_mode
-    with_config(:'strip_exception_messages.whitelist' => 'NewRelic::TestHelpers::Exceptions::TestError') do
-      e = TestError.new('whitelisted test exception')
-      error = NewRelic::NoticedError.new(@path, e, @time)
-
-      assert_equal 'whitelisted test exception', error.message
-    end
-  end
-
-  def test_whitelisted_returns_nil_with_an_empty_whitelist
-    with_config(:'strip_exception_messages.whitelist' => '') do
-      assert_falsy NewRelic::NoticedError.passes_message_whitelist(TestError)
-    end
-  end
-
-  def test_whitelisted_returns_nil_when_error_is_not_in_whitelist
-    with_config(:'strip_exception_messages.whitelist' => 'YourErrorIsInAnotherCastle') do
-      assert_falsy NewRelic::NoticedError.passes_message_whitelist(TestError)
-    end
-  end
-
-  def test_whitelisted_is_true_when_error_is_in_whitelist
-    with_config(:'strip_exception_messages.whitelist' => 'OtherException,NewRelic::TestHelpers::Exceptions::TestError') do
-      assert_truthy NewRelic::NoticedError.passes_message_whitelist(TestError)
-    end
-  end
-
-  def test_whitelisted_ignores_nonexistent_exception_types_in_whitelist
-    with_config(:'strip_exception_messages.whitelist' => 'NonExistent::Exception,NewRelic::TestHelpers::Exceptions::TestError') do
-      assert_truthy NewRelic::NoticedError.passes_message_whitelist(TestError)
-    end
-  end
-
-  def test_whitelisted_is_true_when_an_exceptions_ancestor_is_whitelisted
-    with_config(:'strip_exception_messages.whitelist' => 'NewRelic::TestHelpers::Exceptions::ParentException') do
-      assert_truthy NewRelic::NoticedError.passes_message_whitelist(ChildException)
-    end
-  end
-
-  def test_handles_exception_with_nil_original_exception
-    e = Exception.new('Buffy FOREVER')
-    e.stubs(:original_exception).returns(nil)
-    error = NewRelic::NoticedError.new(@path, e, @time)
-    assert_equal(error.message.to_s, 'Buffy FOREVER')
-  end
-
-  if defined?(Rails) && Rails::VERSION::MAJOR < 5
-    def test_uses_original_exception_class_name
-      orig = FooError.new
-      e = mock('exception', original_exception: orig)
-      error = NewRelic::NoticedError.new(@path, e, @time)
-      assert_equal(error.exception_class_name, 'FooError')
-    end
-  end
-
-  def test_intrinsics_always_get_sent
-    with_config(:'error_collector.attributes.enabled' => false) do
-      attributes = NewRelic::Agent::Transaction::Attributes.new(NewRelic::Agent.instance.attribute_filter)
-      attributes.add_intrinsic_attribute(:intrinsic, "attribute")
-
-      error = NewRelic::NoticedError.new(@path, Exception.new("O_o"))
-      error.attributes = attributes
-
-      serialized_attributes = extract_attributes(error)
-      assert_equal({ :intrinsic => "attribute" }, serialized_attributes["intrinsics"])
-    end
-  end
-
-  def test_custom_attributes_sent_when_enabled
-    with_config :'error_collector.attributes.enabled' => true do
-      attributes = NewRelic::Agent::Transaction::Attributes.new(NewRelic::Agent.instance.attribute_filter)
-      custom_attrs = {"name" => "Ron Burgundy", "channel" => 4}
-      attributes.merge_custom_attributes(custom_attrs)
-
-      error = NewRelic::NoticedError.new(@path, Exception.new("O_o"))
-      error.attributes = attributes
-
-      assert_equal custom_attrs, error.custom_attributes
-    end
-  end
-
-  def test_custom_attributes_not_sent_when_disabled
-    with_config :'error_collector.attributes.enabled' => false do
-      attributes = NewRelic::Agent::Transaction::Attributes.new(NewRelic::Agent.instance.attribute_filter)
-      custom_attrs = {"name" => "Ron Burgundy", "channel" => 4}
-      attributes.merge_custom_attributes(custom_attrs)
-
-      error = NewRelic::NoticedError.new(@path, Exception.new("O_o"))
-      error.attributes = attributes
-
-      assert_equal({}, error.custom_attributes)
-    end
-  end
-
-  def test_agent_attributes_sent_when_enabled
-    with_config :'error_collector.attributes.enabled' => true do
-      attributes = NewRelic::Agent::Transaction::Attributes.new(NewRelic::Agent.instance.attribute_filter)
-      attributes.add_agent_attribute :"request.headers.referer", "http://blog.site/home", NewRelic::Agent::AttributeFilter::DST_ALL
-
-      error = NewRelic::NoticedError.new(@path, Exception.new("O_o"))
-      error.attributes = attributes
-
-      expected = {:"request.headers.referer" => "http://blog.site/home"}
-      assert_equal expected, error.agent_attributes
-    end
-  end
-
-  def test_agent_attributes_not_sent_when_disabled
-    with_config :'error_collector.attributes.enabled' => false do
-      attributes = NewRelic::Agent::Transaction::Attributes.new(NewRelic::Agent.instance.attribute_filter)
-      attributes.add_agent_attribute :"request.headers.referer", "http://blog.site/home", NewRelic::Agent::AttributeFilter::DST_ALL
-
-      error = NewRelic::NoticedError.new(@path, Exception.new("O_o"))
-      error.attributes = attributes
-
-      assert_equal({}, error.agent_attributes)
-    end
-  end
-
-  def create_error(exception = StandardError.new)
-    noticed_error = NewRelic::NoticedError.new(@path, exception, @time)
-    noticed_error.attributes = @attributes
-    noticed_error
-  end
-
-  def extract_attributes(error)
-    error.to_collector_array[4]
-  end
-end

data/test/new_relic/rack/agent_hooks_test.rb

@@ -1,44 +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/rack/agent_hooks'
-
-class AgentHooksTest < Minitest::Test
-
-  def setup
-    @app = stub_everything
-    @hooks = NewRelic::Rack::AgentHooks.new(@app)
-    @env = {:env => "env"}
-  end
-
-  def test_before_call
-    NewRelic::Agent.instance.events.expects(:notify).with(:start_transaction)
-    NewRelic::Agent.instance.events.expects(:notify).with(:before_call, @env)
-    NewRelic::Agent.instance.events.stubs(:notify).with(:after_call, anything, anything)
-    NewRelic::Agent.instance.events.expects(:notify).with(:transaction_finished, anything)
-
-    @hooks.call(@env)
-  end
-
-  def test_after_call
-    result = [stub, {}, stub]
-    @app.stubs(:call).returns(result)
-
-    NewRelic::Agent.instance.events.expects(:notify).with(:start_transaction)
-    NewRelic::Agent.instance.events.stubs(:notify).with(:before_call, anything)
-    NewRelic::Agent.instance.events.expects(:notify).with(:after_call, @env, result)
-    NewRelic::Agent.instance.events.expects(:notify).with(:transaction_finished, anything)
-
-    @hooks.call(@env)
-  end
-
-  def test_nested_agent_hooks_still_fire_only_once
-    nested = NewRelic::Rack::AgentHooks.new(@hooks)
-
-    NewRelic::Agent.instance.events.expects(:notify).times(4)
-    nested.call(@env)
-  end
-
-end

data/test/new_relic/rack/agent_middleware_test.rb

@@ -1,32 +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/rack/agent_middleware'
-require 'new_relic/agent/transaction_state'
-
-module NewRelic
-  module Rack
-    class AgentMiddlewareTest < Minitest::Test
-      class ExampleMiddleware < AgentMiddleware
-        def traced_call(env)
-          @app.call(env)
-        end
-      end
-
-      attr_reader :middleware, :env
-
-      def setup
-        @app = lambda { |env| [200, {}, ['yeah!']]}
-        @middleware = ExampleMiddleware.new(@app)
-        @env = {}
-      end
-
-      def test_with_tracing_creates_a_transaction
-        middleware.call(env)
-        assert_metrics_recorded('Controller/Middleware/Rack/NewRelic::Rack::AgentMiddlewareTest::ExampleMiddleware/call')
-      end
-    end
-  end
-end

data/test/new_relic/rack/browser_monitoring_test.rb

@@ -1,195 +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 'rack/test'
-require 'new_relic/rack/browser_monitoring'
-
-ENV['RACK_ENV'] = 'test'
-
-class BrowserMonitoringTest < Minitest::Test
-  include Rack::Test::Methods
-
-  class TestApp
-    @@doc = nil
-    @@next_response = nil
-
-    def self.doc=(other)
-      @@doc = other
-    end
-
-    def self.next_response=(next_response)
-      @@next_response = next_response
-    end
-
-    def self.next_response
-      @@next_response
-    end
-
-    def call(env)
-      advance_time(0.1)
-      @@doc ||= <<-EOL
-<html>
-  <head>
-    <title>im a title</title>
-    <meta some-crap="1"/>
-    <script>
-      junk
-    </script>
-  </head>
-  <body>im some body text</body>
-</html>
-EOL
-      response = @@next_response || Rack::Response.new(@@doc)
-      @@next_response = nil
-
-      [200, {'Content-Type' => 'text/html'}, response]
-    end
-  end
-
-  def app
-    NewRelic::Rack::BrowserMonitoring.new(TestApp.new)
-  end
-
-  def setup
-    super
-    freeze_time
-
-    @config = {
-      :application_id => 5,
-      :beacon => 'beacon',
-      :browser_key => 'some browser key',
-      :'rum.enabled' => true,
-      :license_key => 'a' * 40,
-      :js_agent_loader => 'loader',
-      :disable_harvest_thread => true
-    }
-    NewRelic::Agent.config.add_config_for_testing(@config)
-  end
-
-  def teardown
-    super
-    TestApp.doc = nil
-    NewRelic::Agent.config.remove_config(@config)
-    NewRelic::Agent.agent.transaction_sampler.reset!
-  end
-
-  def test_make_sure_header_is_set
-    in_transaction do
-      assert NewRelic::Agent.browser_timing_header.size > 0
-    end
-  end
-
-  def test_should_only_instrument_successful_html_requests
-    assert app.should_instrument?({}, 200, {'Content-Type' => 'text/html'}), "Expected to instrument 200 requests."
-    assert !app.should_instrument?({}, 500, {'Content-Type' => 'text/html'}), "Expected not to instrument 500 requests."
-    assert !app.should_instrument?({}, 200, {'Content-Type' => 'text/xhtml'}), "Expected not to instrument requests with content type other than text/html."
-  end
-
-  def test_should_not_instrument_when_content_disposition
-    assert !app.should_instrument?({}, 200, {'Content-Type' => 'text/html', 'Content-Disposition' => 'attachment; filename=test.html'})
-  end
-
-  def test_should_not_instrument_when_already_did
-    assert !app.should_instrument?({NewRelic::Rack::BrowserMonitoring::ALREADY_INSTRUMENTED_KEY => true}, 200, {'Content-Type' => 'text/html'})
-  end
-
-  def test_should_not_instrument_when_disabled_by_config
-    with_config(:'browser_monitoring.auto_instrument' => false) do
-      refute app.should_instrument?({}, 200, {'Content-Type' => 'text/html'})
-    end
-  end
-
-  def test_insert_header_should_mark_environment
-    get '/'
-    assert last_request.env.key?(NewRelic::Rack::BrowserMonitoring::ALREADY_INSTRUMENTED_KEY)
-  end
-
-  # RUM header auto-insertion testing
-  # We read *.html files from the rum_loader_insertion_location directory in
-  # cross_agent_tests, strip out the placeholder tokens representing the RUM
-  # header manually, and then re-insert, verifying that it ends up in the right
-  # place.
-
-  source_files = Dir[File.join(cross_agent_tests_dir, 'rum_loader_insertion_location', "*.html")]
-
-  RUM_PLACEHOLDER = "EXPECTED_RUM_LOADER_LOCATION"
-
-  source_files.each do |source_file|
-    source_filename = File.basename(source_file).gsub(".", "_")
-    instrumented_html = File.read(source_file)
-    uninstrumented_html = instrumented_html.gsub(RUM_PLACEHOLDER, '')
-
-    define_method("test_#{source_filename}") do
-      TestApp.doc = uninstrumented_html
-      NewRelic::Agent.stubs(:browser_timing_header).returns(RUM_PLACEHOLDER)
-
-      get '/'
-
-      assert_equal(instrumented_html, last_response.body)
-    end
-
-    define_method("test_dont_touch_#{source_filename}") do
-      TestApp.doc = uninstrumented_html
-      NewRelic::Rack::BrowserMonitoring.any_instance.stubs(:should_instrument?).returns(false)
-
-      get '/'
-
-      assert_equal(uninstrumented_html, last_response.body)
-    end
-  end
-
-  def test_should_close_response
-    TestApp.next_response = Rack::Response.new("<html/>")
-    TestApp.next_response.expects(:close)
-
-    get '/'
-
-    assert last_response.ok?
-  end
-
-  def test_with_invalid_us_ascii_encoding
-    response = "<html><body>Jürgen</body></html>"
-    response.force_encoding(Encoding.find("US-ASCII"))
-    TestApp.next_response = Rack::Response.new(response)
-
-    get '/'
-
-    assert last_response.ok?
-  end
-
-  def test_should_not_close_if_not_responded_to
-    TestApp.next_response = Rack::Response.new("<html/>")
-    TestApp.next_response.stubs(:respond_to?).with(:close).returns(false)
-    TestApp.next_response.expects(:close).never
-
-    get '/'
-
-    assert last_response.ok?
-  end
-
-  def test_should_not_throw_exception_on_empty_reponse
-    TestApp.doc = ''
-    get '/'
-
-    assert last_response.ok?
-  end
-
-  def test_content_length_set_when_we_modify_source
-    original_headers = {
-      "Content-Length" => 0,
-      "Content-Type"   => "text/html"
-    }
-    headers = headers_from_request(original_headers, "<html><body></body></html>")
-    assert_equal "390", headers["Content-Length"]
-  end
-
-  def headers_from_request(headers, content)
-    app = mock('app', :call => [200, headers, [content]])
-    browser_monitoring = NewRelic::Rack::BrowserMonitoring.new(app)
-    _, headers, _ = browser_monitoring.call({})
-    headers
-  end
-end

data/test/new_relic/rack/developer_mode/segment_summary_test.rb

@@ -1,96 +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/rack/developer_mode'
-require 'new_relic/rack/developer_mode/segment_summary'
-
-class SegmentSummaryTest < Minitest::Test
-  def setup
-    @sample = mock('sample')
-    @ss = NewRelic::Rack::DeveloperMode::SegmentSummary.new('Controller/foo', @sample)
-  end
-
-  # these are mostly stub tests just making sure that the API doesn't
-  # change if anyone ever needs to modify it.
-
-  def test_insert
-    segment = mock('segment')
-    segment.expects(:metric_name).returns('Controller/foo')
-    segment.expects(:duration).returns(0.1)
-    segment.expects(:exclusive_duration).returns(0.1)
-    @ss << segment
-    assert_equal 0.1, @ss.total_time
-    assert_equal 0.1, @ss.exclusive_time
-    assert_equal 1, @ss.call_count
-  end
-
-  def test_insert_error
-    segment = mock('segment')
-    segment.expects(:metric_name).returns('Controller/bar').twice
-    assert_raises(ArgumentError) do
-      @ss << segment
-    end
-  end
-
-  def test_average_time
-    @ss.total_time = 0.1
-    @ss.call_count = 2
-    assert_equal 0.05, @ss.average_time
-  end
-
-  def test_average_exclusive_time
-    @ss.exclusive_time = 0.1
-    @ss.call_count = 2
-    assert_equal 0.05, @ss.average_exclusive_time
-  end
-
-  def test_exclusive_time_percentage_nil
-    @ss.exclusive_time = nil
-    assert_equal 0, @ss.exclusive_time_percentage
-  end
-
-  def test_exclusive_time_percentage
-    @ss.exclusive_time = 0.05
-    @sample.expects(:duration).returns(0.1).times(3)
-    assert_equal 0.5, @ss.exclusive_time_percentage
-  end
-
-  def test_total_time_percentage_nil
-    @ss.total_time = nil
-    assert_equal 0, @ss.total_time_percentage
-  end
-
-  def test_total_time_percentage
-    @ss.total_time = 0.05
-    @sample.expects(:duration).returns(0.1).times(3)
-    assert_equal 0.5, @ss.total_time_percentage
-  end
-
-  def test_nesting_total_time
-    segment = mock('segment')
-    segment.expects(:metric_name).twice.returns('Controller/foo')
-    segment.expects(:duration).returns(0.1)
-    segment.expects(:exclusive_duration).returns(0)
-    @ss << segment
-    segment.expects(:exclusive_duration).returns(0.1)
-    @ss.current_nest_count += 1
-    @ss << segment
-    assert_equal 0.1, @ss.total_time
-    assert_equal 0.1, @ss.exclusive_time
-    assert_equal 2, @ss.call_count
-  end
-
-  def test_ui_name_default
-    @ss.metric_name = 'Remainder'
-    assert_equal 'Remainder', @ss.ui_name
-  end
-
-  def test_ui_name_lookup
-    mocked_object = mock('metric parser obj')
-    mocked_object.expects(:developer_name).returns('Developer Name')
-    NewRelic::MetricParser::MetricParser.expects(:parse).with('Controller/foo').returns(mocked_object)
-    assert_equal 'Developer Name', @ss.ui_name
-  end
-end