wd_newrelic_rpm 3.3.4.1 → 3.5.5

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

@@ -0,0 +1,236 @@
+# https://newrelic.atlassian.net/browse/RUBY-747
+
+ENV['NEW_RELIC_DISPATCHER'] = 'test'
+
+require 'action_controller/railtie'
+require 'rails/test_unit/railtie'
+require 'rails/test_help'
+require 'test/unit'
+require 'new_relic/rack/error_collector'
+require 'fake_service'
+
+
+# BEGIN RAILS APP
+
+class MyApp < Rails::Application
+  # We need a secret token for session, cookies, etc.
+  config.active_support.deprecation = :log
+  config.secret_token = "49837489qkuweoiuoqwehisuakshdjksadhaisdy78o34y138974xyqp9rmye8yrpiokeuioqwzyoiuxftoyqiuxrhm3iou1hrzmjk"
+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)
+  match '/:controller(/:action(/:id))'
+end
+
+class ApplicationController < ActionController::Base; end
+
+# a basic active model compliant model we can render
+class Foo
+  extend ActiveModel::Naming
+  def to_model
+    self
+  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 errors
+    obj = Object.new
+    def obj.[](key)         [] end
+    def obj.full_messages() [] end
+    obj
+  end
+end
+
+class TestController < ApplicationController
+  include Rails.application.routes.url_helpers
+  newrelic_ignore :only => :ignored_action
+
+  def controller_error
+    raise 'this is an uncaught controller error'
+  end
+
+  def view_error
+    render :inline => "<% raise 'this is an uncaught view error' %>"
+  end
+
+  def model_error
+    Foo.new.raise_error
+  end
+
+  def ignored_action
+    raise 'this error should not be noticed'
+  end
+
+  def ignored_error
+    raise IgnoredError.new('this error should not be noticed')
+  end
+
+  def server_ignored_error
+    raise ServerIgnoredError.new('this is a server ignored error')
+  end
+
+  def noticed_error
+    newrelic_notice_error(RuntimeError.new('this error should be noticed'))
+    render :text => "Shoulda noticed an error"
+  end
+end
+# END RAILS APP
+
+class IgnoredError < StandardError; end
+class ServerIgnoredError < StandardError; end
+
+class TestControllerTest < ActionDispatch::IntegrationTest
+  def setup
+    NewRelic::Agent::Agent.instance_variable_set(:@instance, NewRelic::Agent::Agent.new)
+
+    @service = NewRelic::FakeService.new
+    NewRelic::Agent::Agent.instance.service = @service
+
+    NewRelic::Agent.manual_start
+  end
+
+  def teardown
+    NewRelic::Agent::Agent.instance.shutdown if NewRelic::Agent::Agent.instance
+  end
+end
+
+class ErrorsWithoutSSCTest < TestControllerTest
+  def setup
+    super
+    reset_error_collector
+  end
+
+  def reset_error_collector
+    @error_collector = NewRelic::Agent.instance.error_collector
+    NewRelic::Agent.instance.error_collector \
+      .instance_variable_set(:@ignore_filter, nil)
+
+    # sanity checks
+    assert(@error_collector.enabled?,
+           'error collector should be enabled')
+    assert(!NewRelic::Agent.instance.error_collector.ignore_error_filter,
+           'no ignore error filter should be set')
+  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)
+  end
+
+  def test_should_capture_error_raised_in_view
+    get '/test/view_error'
+    assert_error_reported_once('this is an uncaught view error')
+  end
+
+  def test_should_capture_error_raised_in_controller
+    get '/test/controller_error'
+    assert_error_reported_once('this is an uncaught controller error')
+  end
+
+  def test_should_capture_error_raised_in_model
+    get '/test/model_error'
+    assert_error_reported_once('this is an uncaught model error')
+  end
+
+  def test_should_capture_noticed_error_in_controller
+    get '/test/noticed_error'
+    assert_error_reported_once('this error should be noticed')
+  end
+
+  def test_should_capture_manually_noticed_error
+    NewRelic::Agent.notice_error(RuntimeError.new('this is a noticed error'))
+    assert_error_reported_once('this is a noticed error')
+  end
+
+  def test_should_capture_routing_error
+    get '/bad_route'
+    assert_error_reported_once('this is an uncaught routing error')
+  end
+
+  def test_should_capture_request_uri_and_params
+    get '/bad_route?eat=static'
+    assert_equal('/bad_route',
+                 @error_collector.errors[0].params[:request_uri])
+    assert_equal({'eat' => 'static'},
+                 @error_collector.errors[0].params[:request_params])
+  end
+
+  def test_should_not_notice_errors_from_ignored_action
+    get '/test/ignored_action'
+    assert(@error_collector.errors.empty?,
+           'Noticed an error that should have been ignored')
+  end
+
+  def test_should_not_notice_ignored_error_classes
+    get '/test/ignored_error'
+    assert(@error_collector.errors.empty?,
+           'Noticed an error that should have been ignored')
+  end
+
+  def test_should_not_notice_filtered_errors
+    NewRelic::Agent.instance.error_collector.ignore_error_filter do |error|
+      !error.kind_of?(RuntimeError)
+    end
+
+    get 'test/controller_error'
+    assert(NewRelic::Agent.instance.error_collector.errors.empty?,
+           'Noticed an error that should have been ignored')
+  end
+
+  def test_should_notice_server_ignored_error_if_no_server_side_config
+    get '/test/server_ignored_error'
+    assert_error_reported_once('this is a server ignored error')
+  end
+
+  protected
+
+  def assert_error_reported_once(message)
+    assert_equal(message,
+                 @error_collector.errors[0].message,
+                 'This error type was not detected')
+    assert_equal(1, @error_collector.errors.size,
+                 'Too many of this error type was detected')
+  end
+end
+
+class ErrorsWithSSCTest < ErrorsWithoutSSCTest
+  def setup
+    super
+    @service.mock['connect'] = {
+      "listen_to_server_config" => true,
+      "agent_run_id" => 1,
+      "error_collector.ignore_errors" => 'IgnoredError,ServerIgnoredError',
+      "error_collector.enabled" => true,
+      "error_collector.capture_source" => true,
+      "collect_errors" => true
+    }
+
+    # Force us to apply the mocked connect values to our configuration
+    NewRelic::Agent.instance.query_server_for_configuration
+  end
+
+  def test_should_notice_server_ignored_error_if_no_server_side_config
+    # Overrides test in base class, since doesn't apply
+  end
+
+  def test_should_ignore_server_ignored_errors
+    get '/test/server_ignored_error'
+    assert(@error_collector.errors.empty?,
+           'Noticed an error that should have been ignored')
+  end
+
+end

data/test/multiverse/suites/rails_3_gc/Envfile

@@ -0,0 +1,8 @@
+suite_condition("GC instrumentation only works with REE or 1.9.x") do
+  (defined?(RUBY_DESCRIPTION) && RUBY_DESCRIPTION =~ /Enterprise/) ||
+    RUBY_VERSION >= '1.9.2'
+end
+
+gemfile <<-RB
+  gem 'rails', '~>3.2.0'
+RB

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

@@ -0,0 +1,167 @@
+#
+# This file configures the NewRelic RPM Agent, NewRelic RPM monitors Rails 
+# applications with deep visibility and low overhead.  For more information, 
+# visit www.newrelic.com.
+#
+# 
+#
+# here are the settings that are common to all environments
+common: &default_settings
+
+  # ============================== LICENSE KEY ===============================
+  # You must specify the licence key associated with your New Relic account.
+  # This key binds your Agent's data to your account in the New Relic RPM service.
+
+  #license_key: 'bootstrap_newrelic_admin_license_key_000'
+  #host: localhost
+  #port: 3000
+
+  license_key: 'bd0e1d52adade840f7ca727d29a86249e89a6f1c'
+  host: localhost
+
+  # Agent Enabled
+  # Use this setting to force the agent to run or not run.
+  # Default is 'auto' which means the agent will install and run only if a
+  # valid dispatcher such as Mongrel is running.  This prevents it from running
+  # with Rake or the console.  Set to false to completely turn the agent off
+  # regardless of the other settings.  Valid values are true, false and auto.
+  # agent_enabled: auto
+  
+  # Application Name
+  # Set this to be the name of your application as you'd like it show up in RPM.
+  # RPM will then auto-map instances of your application into a RPM "application"
+  # on your home dashboard page. This setting does not prevent you from manually
+  # defining applications.
+  app_name: Rails 3 view test ap
+
+  # When 'enabled' is turned on, the agent collects performance data by inserting lightweight
+  # tracers on key methods inside the rails framework and asynchronously aggregating
+  # and reporting this performance data to the NewRelic RPM service at newrelic.com.
+  enabled: false
+
+  # The newrelic agent generates its own log file to keep its logging information
+  # separate from that of your application.  Specify its log level here.
+  log_level: debug
+  
+  # The newrelic agent communicates with the RPM service via http by default.
+  # If you want to communicate via https to increase security, then turn on
+  # SSL by setting this value to true.  Note, this will result in increased
+  # CPU overhead to perform the encryption involved in SSL communication, but this
+  # work is done asynchronously to the threads that process your application code, so
+  # it should not impact response times.
+  ssl: false
+  
+  # Set your application's Apdex threshold value with the 'apdex_t' setting, in seconds. The
+  # apdex_t value determines the buckets used to compute your overall Apdex score. Requests
+  # that take less than apdex_t seconds to process will be classified as Satisfying transactions;
+  # more than apdex_t seconds as Tolerating transactions; and more than four times the apdex_t 
+  # value as Frustrating transactions. For more
+  # about the Apdex standard, see http://support.newrelic.com/faqs/general/apdex
+  apdex_t: 1.0
+    
+
+  # Proxy settings for connecting to the RPM server.
+  #
+  # If a proxy is used, the host setting is required.  Other settings are optional.  Default
+  # port is 8080.
+  #
+  # proxy_host: hostname
+  # proxy_port: 8080
+  # proxy_user:
+  # proxy_pass:
+
+  
+  # Tells transaction tracer and error collector (when enabled) whether or not to capture HTTP params. 
+  # When true, the RoR filter_parameter_logging mechanism is used so that sensitive parameters are not recorded
+  capture_params: false
+
+
+  # Transaction tracer captures deep information about slow
+  # transactions and sends this to the RPM service once a minute. Included in the
+  # transaction is the exact call sequence of the transactions including any SQL statements
+  # issued.
+  transaction_tracer:
+  
+    # Transaction tracer is enabled by default. Set this to false to turn it off. This feature
+    # is only available at the Silver and above product levels.
+    enabled: true
+    
+    # Threshold in seconds for when to collect a transaction trace. When the response time of
+    # a controller action exceeds this threshold, a transaction trace will be recorded and sent
+    # to RPM. Valid values are any float value, or (default) "apdex_f", which will use the
+    # threshold for an dissatisfying Apdex controller action - four times the Apdex T value.
+    transaction_threshold: apdex_f
+ 
+    # When transaction tracer is on, SQL statements can optionally be recorded. The recorder
+    # has three modes, "off" which sends no SQL, "raw" which sends the SQL statement in its 
+    # original form, and "obfuscated", which strips out numeric and string literals
+    record_sql: obfuscated
+    
+    # Threshold in seconds for when to collect stack trace for a SQL call. In other words, 
+    # when SQL statements exceed this threshold, then capture and send to RPM the current
+    # stack trace. This is helpful for pinpointing where long SQL calls originate from  
+    stack_trace_threshold: 0.500
+  
+  # Error collector captures information about uncaught exceptions and sends them to RPM for
+  # viewing
+  error_collector:
+    
+    # Error collector is enabled by default. Set this to false to turn it off. This feature
+    # is only available at the Silver and above product levels
+    enabled: true
+    
+    # Tells error collector whether or not to capture a source snippet around the place of the
+    # error when errors are View related.
+    capture_source: true    
+    
+    # To stop specific errors from reporting to RPM, set this property to comma separated 
+    # values
+    #
+    #ignore_errors: ActionController::RoutingError, ...
+
+  # (Advanced) Uncomment this to ensure the cpu and memory samplers won't run.  Useful when you
+  # are using the agent to monitor an external resource
+  # disable_samplers: true
+
+# override default settings based on your application's environment
+
+# NOTE if your application has other named environments, you should
+# provide newrelic conifguration settings for these enviromnents here.
+
+  disable_memory_profiling: false
+
+development:
+  <<: *default_settings
+  # turn off communication to RPM service in development mode.
+  # NOTE: for initial evaluation purposes, you may want to temporarily turn
+  # the agent on in development mode.
+  enabled: true
+
+  # When running in Developer Mode, the New Relic Agent will present 
+  # performance information on the last 100 transactions you have 
+  # executed since starting the mongrel.  to view this data, go to 
+  # http://localhost:3000/newrelic
+  developer: true
+
+test:
+  <<: *default_settings
+  # it almost never makes sense to turn on the agent when running unit, functional or
+  # integration tests or the like.
+  enabled: true
+  log_level: debug
+  developer: true
+
+# Turn on the agent in production for 24x7 monitoring.  NewRelic testing shows
+# an average performance impact of < 5 ms per transaction, you you can leave this on
+# all the time without incurring any user-visible performance degredation.
+production:
+  <<: *default_settings
+  enabled: true
+
+# many applications have a staging environment which behaves identically to production.
+# Support for that environment is provided here.  By default, the staging environment has
+# the agent turned on.
+staging:
+  <<: *default_settings
+  enabled: true
+  app_name: My Application (Staging)

data/test/multiverse/suites/rails_3_gc/instrumentation_test.rb

@@ -0,0 +1,92 @@
+require "action_controller/railtie"
+require "rails/test_unit/railtie"
+require 'rails/test_help'
+require 'test/unit'
+
+# BEGIN RAILS APP
+
+class MyApp < Rails::Application
+  config.active_support.deprecation = :log
+  config.secret_token = '!*#$#' * 31
+end
+MyApp.initialize!
+
+MyApp.routes.draw do
+  match '/:controller(/:action(/:id))'
+end
+
+class ApplicationController < ActionController::Base; end
+
+class TestController < ApplicationController
+  include Rails.application.routes.url_helpers
+  def gc_action
+    GC.disable
+
+    long_string = "01234567" * 100_000
+    long_string = nil
+    another_long_string = "01234567" * 100_000
+
+    start = Time.now
+    GC.enable
+    GC.start
+    stop = Time.now
+
+    @duration = stop.to_f - start.to_f
+
+    render :text => @duration.to_s
+  ensure
+    GC.enable
+  end
+end
+
+# END RAILS APP
+
+class TestControllerTest < ActionController::TestCase
+  tests TestController
+  def setup
+    enable_gc_stats
+
+    @controller = TestController.new
+    NewRelic::Agent.instance.stats_engine.reset_stats
+    NewRelic::Agent.instance.transaction_sampler \
+      .instance_variable_set(:@samples, [])
+    NewRelic::Agent.manual_start
+  end
+
+  def teardown
+    NewRelic::Agent.shutdown
+  end
+
+  def enable_gc_stats
+    if RUBY_DESCRIPTION =~ /Enterprise/
+      GC.enable_stats
+    elsif RUBY_VERSION >= '1.9.2'
+      GC::Profiler.enable
+    end
+  end
+end
+
+class GCRailsInstrumentationTest < TestControllerTest
+  def test_records_accurate_time_for_gc_activity
+    get :gc_action
+
+    assert_in_delta(assigns[:duration],
+                    NewRelic::Agent.agent.stats_engine \
+                      .get_stats('GC/cumulative') \
+                      .total_call_time, 0.1,
+                    'problem with unscoped GC metric')
+    assert_in_delta(assigns[:duration],
+                    NewRelic::Agent.agent.stats_engine \
+                      .get_stats('GC/cumulative', true, false,
+                                 'Controller/test/gc_action') \
+                      .total_call_time, 0.1,
+                    'problem with scoped GC metric')
+  end
+
+  def test_records_transaction_param_for_gc_activity
+    get :gc_action
+
+    trace = NewRelic::Agent.instance.transaction_sampler.last_sample
+    assert_in_delta(assigns[:duration], trace.params[:custom_params][:gc_time], 0.1)
+  end
+end