newrelic_rpm 3.11.2.286 → 3.12.0.288

data/test/new_relic/noticed_error_test.rb

@@ -3,43 +3,124 @@
 # 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 NewRelic::Agent::NoticedErrorTest < Minitest::Test
   include NewRelic::TestHelpers::Exceptions
 
   def setup
     @path = 'foo/bar/baz'
-    @params = { 'key' => 'val' }
+
+    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 = NewRelic::NoticedError.new(@path, @params, e, @time)
+
+    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', @params
+      (@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, @params, nil, Rational(10, 1))
+    error = NewRelic::NoticedError.new(@path, nil, Rational(10, 1))
     expected = [
-      10_000.0, @path, "<no message>", "Error", @params
+      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, @params, e, @time)
+    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, @params, e, @time)
+      error = NewRelic::NoticedError.new(@path, e, @time)
 
       assert_equal NewRelic::NoticedError::STRIPPED_EXCEPTION_REPLACEMENT_MESSAGE, error.message
     end
@@ -48,7 +129,7 @@ class NewRelic::Agent::NoticedErrorTest < Minitest::Test
   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, @params, e, @time)
+      error = NewRelic::NoticedError.new(@path, e, @time)
 
       assert_equal 'whitelisted test exception', error.message
     end
@@ -87,8 +168,30 @@ class NewRelic::Agent::NoticedErrorTest < Minitest::Test
   def test_handles_exception_with_nil_original_exception
     e = Exception.new('Buffy FOREVER')
     e.stubs(:original_exception).returns(nil)
-    error = NewRelic::NoticedError.new(@path, @params, e, @time)
+    error = NewRelic::NoticedError.new(@path, e, @time)
     assert_equal(error.message.to_s, 'Buffy FOREVER')
   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 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/browser_monitoring_test.rb

@@ -179,14 +179,19 @@ EOL
     assert last_response.ok?
   end
 
-  def test_calculate_content_length_accounts_for_multibyte_characters_for_186
-    String.stubs(:respond_to?).with(:bytesize).returns(false)
-    browser_monitoring = NewRelic::Rack::BrowserMonitoring.new(mock('app'))
-    assert_equal 24, browser_monitoring.calculate_content_length("猿も木から落ちる")
+  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 test_calculate_content_length_accounts_for_multibyte_characters_for_modern_ruby
-    browser_monitoring = NewRelic::Rack::BrowserMonitoring.new(mock('app'))
-    assert_equal 18, browser_monitoring.calculate_content_length("七転び八起き")
+  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/{transaction_analysis → rack/developer_mode}/segment_summary_test.rb

@@ -2,13 +2,14 @@
 # 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/transaction_analysis/segment_summary'
-class NewRelic::TransactionAnalysis::SegmentSummaryTest < Minitest::Test
+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::TransactionAnalysis::SegmentSummary.new('Controller/foo', @sample)
+    @ss = NewRelic::Rack::DeveloperMode::SegmentSummary.new('Controller/foo', @sample)
   end
 
   # these are mostly stub tests just making sure that the API doesn't

data/test/new_relic/rack/developer_mode_test.rb

@@ -53,11 +53,11 @@ class DeveloperModeTest < Minitest::Test
 
   def test_explain_sql_displays_query_plan
     sample = @sampler.dev_mode_sample_buffer.samples[0]
-    sql_segment = sample.sql_segments[0]
+    sql_segment = app.send(:sql_segments, sample)[0]
     explain_results = NewRelic::Agent::Database.process_resultset(dummy_mysql_explain_result, 'mysql')
 
-    NewRelic::TransactionSample::Segment.any_instance.expects(:explain_sql).returns(explain_results)
-    get "/newrelic/explain_sql?id=#{sample.sample_id}&segment=#{sql_segment.segment_id}"
+    NewRelic::Agent::Transaction::TraceNode.any_instance.expects(:explain_sql).returns(explain_results)
+    get "/newrelic/explain_sql?id=#{sample.sample_id}&segment=#{sql_segment.object_id}"
 
     assert last_response.ok?
     assert last_response.body.include?('PRIMARY')
@@ -72,6 +72,20 @@ class DeveloperModeTest < Minitest::Test
 
     assert_empty NewRelic::Agent.instance.transaction_sampler.dev_mode_sample_buffer.samples
   end
+
+  def test_request_attributes
+    attributes = NewRelic::Agent::Transaction::Attributes.new(NewRelic::Agent.instance.attribute_filter)
+    attributes.add_agent_attribute("request.parameters.foo", "bar", NewRelic::Agent::AttributeFilter::DST_ALL)
+    attributes.add_agent_attribute(:"request.headers.referer", "/somewhere", NewRelic::Agent::AttributeFilter::DST_ALL)
+    sample = stub(:attributes => attributes)
+
+    expected = {
+      "request.parameters.foo" => "bar"
+    }
+
+    result = app.send(:request_attributes_for, sample)
+    assert_equal expected, result
+  end
 end
 
 else

data/test/new_relic/rack/error_collector_test.rb

@@ -66,7 +66,7 @@ module NewRelic::Rack
         end
 
         assert_equal('unhandled error', last_error.message)
-        assert_equal('/foo/bar', last_error.params[:request_uri])
+        assert_equal('/foo/bar', last_error.request_uri)
       end
     end
 

data/test/performance/lib/performance/instrumentation/stackprof.rb

@@ -5,7 +5,7 @@
 module Performance
   module Instrumentation
     class StackProfProfile < Instrumentor
-      platforms :mri_21
+      platforms :mri_21, :mri_22
 
       def self.setup
         require 'tmpdir'

data/test/performance/script/runner

@@ -39,9 +39,9 @@ parser = OptionParser.new do |opts|
     options[:list] = true
   end
 
-  opts.on("-s", "--suite=NAME", "Filter to just run a single test suite") do |name|
+  opts.on("-s", "--suite=NAME", "Filter test suites to run (allows comma separated list)") do |name|
     options[:suite] ||= []
-    options[:suite]  << name
+    options[:suite].concat(name.split(","))
   end
 
   opts.on("-n", "--name=NAME", "Filter tests to those matching NAME") do |name|

data/test/performance/suites/active_record.rb

@@ -2,13 +2,13 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
-require 'new_relic/agent/instrumentation/active_record_helper'
 
 class ActiveRecordTest < Performance::TestCase
+  def setup
+    require 'new_relic/agent/instrumentation/active_record_helper'
 
-  ActiveRecordHelper = NewRelic::Agent::Instrumentation::ActiveRecordHelper unless defined?(ActiveRecordHelper)
+    const_set(:ActiveRecordHelper, NewRelic::Agent::Instrumentation::ActiveRecordHelper) unless defined?(ActiveRecordHelper)
 
-  def setup
     if ActiveRecordHelper.respond_to?(:metrics_for)
       @run = ActiveRecordHelper.method(:metrics_for)
     else

data/test/performance/suites/agent_attributes.rb

@@ -0,0 +1,62 @@
+# 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 'securerandom'
+
+class AgentAttributesTests < Performance::TestCase
+  def setup
+    require 'new_relic/agent/attribute_filter'
+  end
+
+  ALPHA = "alpha".freeze
+  BETA  = "beta".freeze
+
+  def test_empty_agent_attributes
+    @filter = NewRelic::Agent::AttributeFilter.new(NewRelic::Agent.config)
+
+    measure do
+      @filter.apply(ALPHA, NewRelic::Agent::AttributeFilter::DST_ALL)
+      @filter.apply(BETA, NewRelic::Agent::AttributeFilter::DST_ALL)
+    end
+  end
+
+  def test_with_attribute_rules
+    with_config(:'attributes.include' => ['alpha'],
+                :'attributes.exclude' => ['beta']) do
+
+      @filter = NewRelic::Agent::AttributeFilter.new(NewRelic::Agent.config)
+
+      measure do
+        @filter.apply(ALPHA, NewRelic::Agent::AttributeFilter::DST_ALL)
+        @filter.apply(BETA, NewRelic::Agent::AttributeFilter::DST_ALL)
+      end
+    end
+  end
+
+  def test_with_wildcards
+    with_config(:'attributes.include' => ['alpha*'],
+                :'attributes.exclude' => ['beta*']) do
+
+      @filter = NewRelic::Agent::AttributeFilter.new(NewRelic::Agent.config)
+
+      measure do
+        @filter.apply(ALPHA, NewRelic::Agent::AttributeFilter::DST_ALL)
+        @filter.apply(BETA, NewRelic::Agent::AttributeFilter::DST_ALL)
+      end
+    end
+  end
+
+  def test_with_tons_o_rules
+    with_config(:'attributes.include' => 100.times.map { SecureRandom.hex },
+                :'attributes.exclude' => 100.times.map { SecureRandom.hex }) do
+
+      @filter = NewRelic::Agent::AttributeFilter.new(NewRelic::Agent.config)
+
+      measure do
+        @filter.apply(ALPHA, NewRelic::Agent::AttributeFilter::DST_ALL)
+        @filter.apply(BETA, NewRelic::Agent::AttributeFilter::DST_ALL)
+      end
+    end
+  end
+end

data/test/performance/suites/rack_middleware.rb

@@ -29,6 +29,28 @@ class RackMiddleware < Performance::TestCase
   class TestMiddlewareI < TestMiddleware; def call(e); @app.call(e); end; end
   class TestMiddlewareJ < TestMiddleware; def call(e); @app.call(e); end; end
 
+  class TestAppWithParams
+    def call(env)
+      params = {
+        'user' => {
+          'shipping_address' => {
+            'street' => '1234 Nowhere Road',
+            'city'   => 'Nowhere',
+            'state'  => 'TX'
+          },
+          'billing_address' => {
+            'street' => '4321 Nowhere Lane',
+            'city'   => 'Nowhere',
+            'state'  => 'TX'
+          }
+        }
+      }
+      perform_action_with_newrelic_trace(:name => 'dorkbot', :params => params) do
+        [200, { 'Content-Type' => 'text/html' }, ['<body>hi</body>']]
+      end
+    end
+  end
+
   class TestApp
     def call(env)
       [200, { 'Content-Type' => 'text/html' }, ['<body>hi</body>']]
@@ -37,45 +59,59 @@ class RackMiddleware < Performance::TestCase
 
   def setup
     require 'new_relic/rack/browser_monitoring'
-    require 'new_relic/rack/error_collector'
-    require 'new_relic/rack/agent_hooks'
+
+    @config = {
+      :beacon          => 'beacon',
+      :browser_key     => 'browserKey',
+      :js_agent_loader => 'loader',
+      :encoding_key    => 'lolz',
+      :application_id  => '5, 6', # collector can return app multiple ids
+      :'rum.enabled'   => true,
+      :license_key     => 'a' * 40,
+      :developer_mode  => false
+    }
+    NewRelic::Agent.config.add_config_for_testing(@config)
 
     NewRelic::Agent.manual_start(
       :developer_mode => false,
       :monitor_mode   => false
     )
 
-    @config = {
-      :beacon                 => 'beacon',
-      :browser_key            => 'browserKey',
-      :js_agent_loader        => 'loader',
-      :encoding_key           => 'lolz',
-      :application_id         => '5, 6', # collector can return app multiple ids
-      :'rum.enabled'          => true,
-      :license_key            => 'a' * 40,
-      :developer_mode         => false
-    }
-    NewRelic::Agent.config.add_config_for_testing(@config)
-
     NewRelic::Agent.agent.events.notify(:finished_configuring)
 
+    middlewares = [
+      TestMiddlewareA,
+      TestMiddlewareB,
+      TestMiddlewareC,
+      TestMiddlewareD,
+      TestMiddlewareE,
+      TestMiddlewareF,
+      TestMiddlewareG,
+      TestMiddlewareH,
+      TestMiddlewareI,
+      TestMiddlewareJ,
+      NewRelic::Rack::BrowserMonitoring
+    ]
+
+    TestAppWithParams.class_eval do
+      include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+    end
+
     @stack = Rack::Builder.new do
-      use TestMiddlewareA
-      use TestMiddlewareB
-      use TestMiddlewareC
-      use TestMiddlewareD
-      use TestMiddlewareE
-      use TestMiddlewareF
-      use TestMiddlewareG
-      use TestMiddlewareH
-      use TestMiddlewareI
-      use TestMiddlewareJ
-      use NewRelic::Rack::AgentHooks
-      use NewRelic::Rack::BrowserMonitoring
-      use NewRelic::Rack::ErrorCollector
+      middlewares.each { |m| use m }
       run TestApp.new
     end.to_app
-    @env = {}
+
+    @stack_with_params = Rack::Builder.new do
+      middlewares.each { |m| use m }
+      run TestAppWithParams.new
+    end.to_app
+
+    @env = {
+      'SCRIPT_NAME'  => '',
+      'PATH_INFO'    => '/users/12/blogs',
+      'QUERY_STRING' => 'q=foobar'
+    }
   end
 
   def test_basic_middleware_stack()
@@ -83,4 +119,18 @@ class RackMiddleware < Performance::TestCase
       @stack.call(@env.dup)
     end
   end
+
+  def test_request_with_params_capture_params_off
+    measure do
+      @stack_with_params.call(@env.dup)
+    end
+  end
+
+  def test_request_with_params_capture_params_on
+    NewRelic::Agent.config.add_config_for_testing(:capture_params => true)
+    NewRelic::Agent.agent.events.notify(:finished_configuring)
+    measure do
+      @stack_with_params.call(@env.dup)
+    end
+  end
 end