newrelic_rpm 3.8.1.221 → 3.9.0.229

data/test/multiverse/suites/rails/Envfile

@@ -32,3 +32,13 @@ gemfile <<-RB
   gem 'haml', '4.0.2'   # Getting load issues with haml 4.0.3
   gem 'minitest_tu_shim', :require => false
 RB
+
+if RUBY_VERSION <= '1.9.3' && (!defined?(RUBY_ENGINE) || RUBY_ENGINE != 'jruby')
+  gemfile <<-RB
+    gem 'newrelic_rpm', :require => false, :path => File.expand_path('../../../../')
+    gem 'rails', '~> 2.3.18'
+    gem 'haml', '~> 3.1.0'   # last haml version that supports Rails 2
+    gem 'minitest_tu_shim', :require => false
+    gem 'sqlite3'
+  RB
+end

data/test/multiverse/suites/rails/app.rb

@@ -2,79 +2,44 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
-require 'action_controller/railtie'
-require 'active_model'
-
 require 'multiverse_helpers'
-require 'rails/test_help'
-
-# We define our single Rails application here, one time, upon the first inclusion
-# Tests should feel free to define their own Controllers locally, but if they
-# need anything special at the Application level, put it here
-if !defined?(MyApp)
+require File.join(File.dirname(__FILE__), 'middlewares')
 
-  ENV['NEW_RELIC_DISPATCHER'] = 'test'
+suite_dir = File.expand_path(File.dirname(__FILE__))
 
-  class ErrorMiddleware
-    def initialize(app, options={})
-      @app = app
-    end
+if defined?(Rails::VERSION::MAJOR) && Rails::VERSION::MAJOR > 2
+  require File.join(suite_dir, 'rails3_app', 'app_rails3_plus')
+  class RailsMultiverseTest < ActionDispatch::IntegrationTest; end
+elsif !defined?(RAILS_ROOT)
+  RAILS_ROOT = File.join(suite_dir, 'rails2_app')
+  require File.join(RAILS_ROOT, 'config', 'environment')
+  class RailsMultiverseTest < ActionController::IntegrationTest; end
+end
 
-    def call(env)
-      path = ::Rack::Request.new(env).path_info
-      raise "middleware error" if path.match(/\/middleware_error\/before/)
-      result = @app.call(env)
-      raise "middleware error" if path.match(/\/middleware_error\/after/)
-      result
-    end
-  end
+# a basic active model compliant model we can render
+class Foo
+  extend ActiveModel::Naming if defined?(ActiveModel::Naming)
 
-  class MyApp < Rails::Application
-    # We need a secret token for session, cookies, etc.
-    config.active_support.deprecation = :log
-    config.secret_token = "49837489qkuweoiuoqwehisuakshdjksadhaisdy78o34y138974xyqp9rmye8yrpiokeuioqwzyoiuxftoyqiuxrhm3iou1hrzmjk"
-    config.eager_load = false
-    config.filter_parameters += [:secret]
-    initializer "install_error_middleware" do
-      config.middleware.use ErrorMiddleware
-    end
+  def to_model
+    self
   end
-  MyApp.initialize!
 
-  MyApp.routes.draw do
-    get('/bad_route' => 'test#controller_error',
-        :constraints => lambda do |_|
-          raise ActionController::RoutingError.new('this is an uncaught routing error')
-        end)
-    get '/:controller(/:action(/:id))'
+  def to_partial_path
+    'foos/foo'
   end
 
-  class ApplicationController < ActionController::Base; end
+  def valid?()      true end
+  def new_record?() true end
+  def destroyed?()  true end
 
-  # a basic active model compliant model we can render
-  class Foo
-    extend ActiveModel::Naming
-    def to_model
-      self
-    end
-
-    def to_partial_path
-      'foos/foo'
-    end
-
-    def valid?()      true end
-    def new_record?() true end
-    def destroyed?()  true end
-
-    def raise_error
-      raise 'this is an uncaught model error'
-    end
+  def raise_error
+    raise 'this is an uncaught model error'
+  end
 
-    def errors
-      obj = Object.new
-      def obj.[](key)         [] end
-      def obj.full_messages() [] end
-      obj
-    end
+  def errors
+    obj = Object.new
+    def obj.[](key)         [] end
+    def obj.full_messages() [] end
+    obj
   end
 end

data/test/multiverse/suites/rails/bad_instrumentation_test.rb

@@ -5,20 +5,18 @@
 require './app'
 
 class BadInstrumentationController < ApplicationController
-  include Rails.application.routes.url_helpers
-
   # This action is intended to simulate a chunk of instrumentation that pushes
   # a traced method frame, but then never pops it. Such a situation will break
   # instrumentation of that request, but should not actually cause the request
   # to fail.
   # https://newrelic.atlassian.net/browse/RUBY-1158
   def failwhale
-    NewRelic::Agent::TracedMethodStack.push_frame('failwhale', Time.now)
+    NewRelic::Agent::TracedMethodStack.tl_push_frame('failwhale', Time.now)
     render :text => 'everything went great'
   end
 end
 
-class BadInstrumentationTest < ActionDispatch::IntegrationTest
+class BadInstrumentationTest < RailsMultiverseTest
   include MultiverseHelpers
   setup_and_teardown_agent
 

data/test/multiverse/suites/rails/config/newrelic.yml

@@ -2,7 +2,7 @@ common: &default_settings
   license_key: 'bd0e1d52adade840f7ca727d29a86249e89a6f1c'
   host: 127.0.0.1
   port: <%= $collector && $collector.port %>
-  app_name: Rails 3 view test ap
+  app_name: Rails multiverse test app
   enabled: true
   ssl: false
   apdex_t: 1.0
@@ -14,7 +14,6 @@ common: &default_settings
     stack_trace_threshold: 0.500
   error_collector:
     enabled: true
-    capture_source: true
     ignore_errors: NewRelic::TestHelpers::Exceptions::IgnoredError
 
 development:

data/test/multiverse/suites/rails/dummy.txt

@@ -0,0 +1 @@
+hello!

data/test/multiverse/suites/rails/error_tracing_test.rb

@@ -8,7 +8,6 @@ require 'fake_collector'
 require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'helpers', 'exceptions'))
 
 class ErrorController < ApplicationController
-  include Rails.application.routes.url_helpers
   include NewRelic::TestHelpers::Exceptions
 
   newrelic_ignore :only => :ignored_action
@@ -65,9 +64,13 @@ class ErrorController < ApplicationController
     NewRelic::Agent.add_custom_parameters(:texture => 'chunky')
     raise 'bad things'
   end
+
+  if Rails::VERSION::MAJOR == 2
+    filter_parameter_logging(:secret)
+  end
 end
 
-class ErrorsWithoutSSCTest < ActionDispatch::IntegrationTest
+class ErrorsWithoutSSCTest < RailsMultiverseTest
   extend Multiverse::Color
 
   include MultiverseHelpers
@@ -86,11 +89,34 @@ class ErrorsWithoutSSCTest < ActionDispatch::IntegrationTest
     @error_collector.errors.last
   end
 
-  def test_error_collector_should_be_enabled
-    assert NewRelic::Agent.config[:agent_enabled]
-    assert NewRelic::Agent.config[:'error_collector.enabled']
-    assert @error_collector.enabled?
-    assert Rails.application.config.middleware.include?(NewRelic::Rack::ErrorCollector)
+  if Rails::VERSION::MAJOR >= 3
+    def test_error_collector_should_be_enabled
+      assert NewRelic::Agent.config[:agent_enabled]
+      assert NewRelic::Agent.config[:'error_collector.enabled']
+      assert @error_collector.enabled?
+      assert Rails.application.config.middleware.include?(NewRelic::Rack::ErrorCollector)
+    end
+
+    def test_should_capture_routing_error
+      get '/bad_route'
+      assert_error_reported_once('this is an uncaught routing error', nil, nil)
+    end
+
+    def test_should_capture_errors_raised_in_middleware_before_call
+      get '/error/middleware_error/before'
+      assert_error_reported_once('middleware error', nil, nil)
+    end
+
+    def test_should_capture_errors_raised_in_middleware_after_call
+      get '/error/middleware_error/after'
+      assert_error_reported_once('middleware error', nil, nil)
+    end
+
+    def test_should_capture_request_uri_and_params
+      get '/bad_route?eat=static'
+      assert_equal('/bad_route', last_error.params[:request_uri])
+      assert_equal({'eat' => 'static'}, last_error.params[:request_params])
+    end
   end
 
   def test_should_capture_error_raised_in_view
@@ -146,11 +172,6 @@ class ErrorsWithoutSSCTest < ActionDispatch::IntegrationTest
     assert_error_reported_once('this is a noticed error', nil, nil)
   end
 
-  def test_should_capture_routing_error
-    get '/bad_route'
-    assert_error_reported_once('this is an uncaught routing error', nil, nil)
-  end
-
   def test_should_apply_parameter_filtering
     get '/error/controller_error?secret=shouldnotbecaptured&other=whatever'
     params = last_error.params[:request_params]
@@ -165,12 +186,6 @@ class ErrorsWithoutSSCTest < ActionDispatch::IntegrationTest
     assert_equal('whatever', params['other'])
   end
 
-  def test_should_capture_request_uri_and_params
-    get '/bad_route?eat=static'
-    assert_equal('/bad_route', last_error.params[:request_uri])
-    assert_equal({'eat' => 'static'}, last_error.params[:request_params])
-  end
-
   def test_should_not_notice_errors_from_ignored_action
     get '/error/ignored_action'
     assert(@error_collector.errors.empty?,
@@ -183,12 +198,23 @@ class ErrorsWithoutSSCTest < ActionDispatch::IntegrationTest
            'Noticed an error that should have been ignored')
   end
 
+  def test_should_treat_apdex_as_success_when_ignored_error_class_noticed
+    get '/error/ignored_error'
+    assert_metrics_recorded({
+      'Apdex'                     => { :apdex_s => 1, :apdex_t => 0, :apdex_f => 0 },
+      'Apdex/error/ignored_error' => { :apdex_s => 1, :apdex_t => 0, :apdex_f => 0 }
+    })
+  end
+
   def test_should_not_notice_filtered_errors
-    NewRelic::Agent.instance.error_collector.ignore_error_filter do |error|
+    filter = Proc.new do |error|
       !error.kind_of?(RuntimeError)
     end
 
-    get 'test/controller_error'
+    with_ignore_error_filter(filter) do
+      get '/error/controller_error'
+    end
+
     assert(NewRelic::Agent.instance.error_collector.errors.empty?,
            'Noticed an error that should have been ignored')
   end
@@ -198,16 +224,6 @@ class ErrorsWithoutSSCTest < ActionDispatch::IntegrationTest
     assert_error_reported_once('this is a server ignored error')
   end
 
-  def test_should_capture_errors_raised_in_middleware_before_call
-    get '/error/middleware_error/before'
-    assert_error_reported_once('middleware error', nil, nil)
-  end
-
-  def test_should_capture_errors_raised_in_middleware_after_call
-    get '/error/middleware_error/after'
-    assert_error_reported_once('middleware error', nil, nil)
-  end
-
   # These really shouldn't be skipped for Rails 4, see RUBY-1242
   if ::Rails::VERSION::MAJOR.to_i < 4
     def test_captured_errors_should_include_custom_params
@@ -261,7 +277,6 @@ class ErrorsWithSSCTest < ErrorsWithoutSSCTest
       "agent_run_id" => 1,
       "error_collector.ignore_errors" => 'NewRelic::TestHelpers::Exceptions::IgnoredError,NewRelic::TestHelpers::Exceptions::ServerIgnoredError',
       "error_collector.enabled" => true,
-      "error_collector.capture_source" => true,
       "collect_errors" => true
     }, 200)
   end

data/test/multiverse/suites/rails/gc_instrumentation_test.rb

@@ -9,7 +9,6 @@ if NewRelic::LanguageSupport.ree? ||
     (RUBY_VERSION >= '1.9.2' && !NewRelic::LanguageSupport.jruby?)
 
 class GcController < ApplicationController
-  include Rails.application.routes.url_helpers
   def gc_action
     begin
       profiler = NewRelic::Agent::StatsEngine::GCProfiler.init

data/test/multiverse/suites/rails/ignore_test.rb

@@ -7,8 +7,6 @@
 require './app'
 
 class IgnoredController < ApplicationController
-  include Rails.application.routes.url_helpers
-
   newrelic_ignore :only => :action_to_ignore
   newrelic_ignore_apdex :only => :action_to_ignore_apdex
 
@@ -21,7 +19,7 @@ class IgnoredController < ApplicationController
   end
 end
 
-class IgnoredActionsTest < ActionDispatch::IntegrationTest
+class IgnoredActionsTest < RailsMultiverseTest
   include MultiverseHelpers
 
   setup_and_teardown_agent(:cross_process_id => "boo",
@@ -44,6 +42,14 @@ class IgnoredActionsTest < ActionDispatch::IntegrationTest
     assert_metrics_not_recorded(["Apdex"])
   end
 
+  def test_ignored_transaction_traces_dont_leak
+    get 'ignored/action_to_ignore'
+    get 'request_stats/stats_action'
+
+    trace = NewRelic::Agent.instance.transaction_sampler.last_sample
+    assert_equal 1, trace.root_segment.called_segments.count
+  end
+
   def test_should_not_write_cat_response_headers_for_ignored_transactions
     get 'ignored/action_to_ignore', nil, {'X-NewRelic-ID' => Base64.encode64('1#234')}
     assert_nil @response.headers["X-NewRelic-App-Data"]

data/test/multiverse/suites/rails/middleware_instrumentation_test.rb

@@ -0,0 +1,41 @@
+# 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.
+
+# https://newrelic.atlassian.net/browse/RUBY-927
+
+require './app'
+
+if Rails::VERSION::MAJOR.to_i >= 3
+
+class MiddlewareInstrumentationTest < RailsMultiverseTest
+  def test_rails_middleware_records_metrics
+    get('/')
+    assert_metrics_recorded(
+      ['Middleware/all', 'Middleware/Rack/Rails::Rack::Logger/call']
+    )
+  end
+
+  def test_rails_routeset_is_instrumented
+    get('/')
+    assert_metrics_recorded(
+      'Middleware/Rack/ActionDispatch::Routing::RouteSet/call'
+    )
+  end
+
+  if Rails::VERSION::MAJOR >= 4
+    def test_rails_middlewares_constructed_by_name
+      get('/')
+      assert response.headers['NamedMiddleware'], "NamedMiddleware should have been called, but wasn't"
+      assert_metrics_recorded('Middleware/Rack/NamedMiddleware/call')
+    end
+
+    def test_rails_middlewares_passed_as_instances
+      get('/')
+      assert response.headers['InstanceMiddleware'], "InstanceMiddleware should have been called, but wasn't"
+      assert_metrics_recorded('Middleware/Rack/InstanceMiddleware/call')
+    end
+  end
+end
+
+end

data/test/multiverse/suites/rails/middlewares.rb

@@ -0,0 +1,19 @@
+# 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.
+
+# Middlewares (potentially) for use from both Rails 2 and Rails 3+ tests
+
+class ErrorMiddleware
+  def initialize(app, options={})
+    @app = app
+  end
+
+  def call(env)
+    path = ::Rack::Request.new(env).path_info
+    raise "middleware error" if path.match(/\/middleware_error\/before/)
+    result = @app.call(env)
+    raise "middleware error" if path.match(/\/middleware_error\/after/)
+    result
+  end
+end

data/test/multiverse/suites/rails/parameter_capture_test.rb

@@ -0,0 +1,169 @@
+# 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 './app'
+
+class ParameterCaptureController < ApplicationController
+  def transaction
+    render :text => 'hi!'
+  end
+
+  def sql
+    NewRelic::Agent.agent.sql_sampler.notice_sql(
+      'SELECT * FROM table',
+      'ActiveRecord/foos/find',
+      {},
+      100.0
+    )
+  end
+
+  def error
+    raise 'wut'
+  end
+
+  # For Rails 3+, this is configured globally in the config block for the app
+  if Rails::VERSION::MAJOR == 2
+    filter_parameter_logging(:secret)
+  end
+end
+
+class ParameterCaptureTest < RailsMultiverseTest
+  def setup
+    NewRelic::Agent.drop_buffered_data
+  end
+
+  def test_no_params_captured_on_errors_when_disabled
+    with_config(:capture_params => false) do
+      get '/parameter_capture/error?other=1234&secret=4567'
+    end
+    assert_nil last_traced_error_request_params
+  end
+
+  def test_no_params_captured_on_tts_when_disabled
+    with_config(:capture_params => false) do
+      get '/parameter_capture/transaction?other=1234&secret=4567'
+    end
+    assert_equal({}, last_transaction_trace_request_params)
+  end
+
+  def test_filters_parameters_on_traced_errors
+    with_config(:capture_params => true) do
+      get '/parameter_capture/error?other=1234&secret=4567'
+    end
+
+    captured_params = last_traced_error_request_params
+    assert_equal('[FILTERED]', captured_params['secret'])
+    assert_equal('1234',       captured_params['other'])
+  end
+
+  def test_filters_parameters_on_transaction_traces
+    with_config(:capture_params => true) do
+      get '/parameter_capture/transaction?other=1234&secret=4567'
+    end
+
+    captured_params = last_transaction_trace_request_params
+    assert_equal('[FILTERED]', captured_params['secret'])
+    assert_equal('1234',       captured_params['other'])
+  end
+
+
+  def test_no_params_captured_when_bails_before_rails
+    with_config(:capture_params => false) do
+      get '/middleware_error/before?other=1234&secret=4567'
+    end
+    assert_nil last_traced_error_request_params
+    assert_equal({}, last_transaction_trace_request_params)
+  end
+
+  if Rails::VERSION::MAJOR.to_i >= 3
+    # NewRelic::Rack::ErrorCollector grabs things out of the request so
+    # we get the actual params even if we never got to a controller
+    def test_sees_error_params_even_when_bailing_before_rails_if_enabled
+      with_config(:capture_params => true) do
+        get '/middleware_error/before?other=1234&secret=4567'
+      end
+
+      captured_params = last_traced_error_request_params
+      assert_equal('[FILTERED]', captured_params['secret'])
+      assert_equal('1234',       captured_params['other'])
+    end
+  else
+    def test_sees_error_params_even_when_bailing_before_rails_if_enabled
+      with_config(:capture_params => true) do
+        get '/middleware_error/before?other=1234&secret=4567'
+      end
+      assert_nil last_traced_error_request_params
+    end
+  end
+
+  def test_no_params_captured_on_tt_when_bails_before_rails_even_when_enabled
+    with_config(:capture_params => true) do
+      get '/middleware_error/before?other=1234&secret=4567'
+    end
+
+    assert_equal({}, last_transaction_trace_request_params)
+  end
+
+  def test_uri_on_tt_should_not_contain_query_string_with_capture_params_off
+    with_config(:capture_params => false) do
+      get '/parameter_capture/transaction?param1=value1&param2=value2'
+    end
+    assert_equal('/parameter_capture/transaction', last_transaction_trace.params[:uri])
+  end
+
+  def test_uri_on_tt_should_not_contain_query_string_with_capture_params_on
+    with_config(:capture_params => true) do
+      get '/parameter_capture/transaction?param1=value1&param2=value2'
+    end
+    assert_equal('/parameter_capture/transaction', last_transaction_trace.params[:uri])
+  end
+
+  def test_uri_on_traced_error_should_not_contain_query_string_with_capture_params_off
+    with_config(:capture_params => false) do
+      get '/parameter_capture/error?param1=value1&param2=value2'
+    end
+    assert_equal('/parameter_capture/error', last_traced_error.params[:request_uri])
+  end
+
+  def test_uri_on_traced_error_should_not_contain_query_string_with_capture_params_on
+    with_config(:capture_params => true) do
+      get '/parameter_capture/error?param1=value1&param2=value2'
+    end
+    assert_equal('/parameter_capture/error', last_traced_error.params[:request_uri])
+  end
+
+  def test_uri_on_sql_trace_should_not_contain_query_string_with_capture_params_off
+    with_config(:capture_params => false) do
+      get '/parameter_capture/sql?param1=value1&param2=value2'
+    end
+    assert_equal('/parameter_capture/sql', last_sql_trace.url)
+  end
+
+  def test_uri_on_sql_trace_should_not_contain_query_string_with_capture_params_on
+    with_config(:capture_params => true) do
+      get '/parameter_capture/sql?param1=value1&param2=value2'
+    end
+    assert_equal('/parameter_capture/sql', last_sql_trace.url)
+  end
+
+  def last_traced_error
+    NewRelic::Agent.agent.error_collector.errors.last
+  end
+
+  def last_traced_error_request_params
+    last_traced_error.params[:request_params]
+  end
+
+  def last_transaction_trace
+    NewRelic::Agent.agent.transaction_sampler.last_sample
+  end
+
+  def last_transaction_trace_request_params
+    last_transaction_trace.params[:request_params]
+  end
+
+  def last_sql_trace
+    NewRelic::Agent.agent.sql_sampler.sql_traces.values.last
+  end
+end