wd_newrelic_rpm 3.5.5 → 3.5.6

data/test/multiverse/suites/agent_only/testing_app.rb

@@ -0,0 +1,17 @@
+class TestingApp
+
+  attr_accessor :response, :headers
+
+  def initialize
+    reset_headers
+  end
+
+  def reset_headers
+    @headers = {'Content-Type' => 'text/html'}
+  end
+
+  def call(env)
+    [200, headers, [response]]
+  end
+
+end

data/test/multiverse/suites/agent_only/thread_profiling_test.rb

@@ -4,17 +4,18 @@
 if RUBY_VERSION >= '1.9'
 class ThreadProfilingTest < Test::Unit::TestCase
   def setup
-    NewRelic::Agent.manual_start(:'thread_profiler.enabled' => true)
-
-    @agent = NewRelic::Agent.instance
-    @thread_profiler = @agent.thread_profiler
-
     $collector ||= NewRelic::FakeCollector.new
     $collector.reset
     $collector.mock['connect'] = [200, {'return_value' => {"agent_run_id" => 666 }}]
     $collector.mock['get_agent_commands'] = [200, {'return_value' => START_COMMAND}]
     $collector.mock['agent_command_results'] = [200, {'return_value' => []}]
     $collector.run
+
+    NewRelic::Agent::Agent.instance_variable_set(:@instance, nil)
+    NewRelic::Agent.manual_start(:'thread_profiler.enabled' => true)
+
+    @agent = NewRelic::Agent.instance
+    @thread_profiler = @agent.thread_profiler
   end
 
   def teardown

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

@@ -11,7 +11,7 @@ development:
   app_name: test
   host: 127.0.0.1
   api_host: 127.0.0.1
-  port: 30303
+  port: <%= 30_000 + ($$ % 10_000) %>
   transaction_tracer:
     record_sql: obfuscated
     enabled: true

data/test/multiverse/suites/{rails_3_queue_time → rails}/Envfile

@@ -4,12 +4,15 @@ end
 
 gemfile <<-RB
   gem 'rails', '~>3.2.0'
+  gem 'haml'
 RB
 
 gemfile <<-RB
   gem 'rails', '~>3.1.0'
+  gem 'haml'
 RB
 
 gemfile <<-RB
   gem 'rails', '~>3.0.0'
+  gem 'haml'
 RB

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

@@ -0,0 +1,49 @@
+require 'action_controller/railtie'
+
+# 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)
+
+  ENV['NEW_RELIC_DISPATCHER'] = 'test'
+
+  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
+end

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

@@ -0,0 +1,32 @@
+common: &default_settings
+  license_key: 'bd0e1d52adade840f7ca727d29a86249e89a6f1c'
+  host: 127.0.0.1
+  port: <%= 30_000 + ($$ % 10_000) %>
+  app_name: Rails 3 view test ap
+  enabled: true
+  log_level: debug
+  ssl: false
+  apdex_t: 1.0
+  capture_params: true
+  transaction_tracer:
+    enabled: true
+    transaction_threshold: apdex_f
+    record_sql: obfuscated
+    stack_trace_threshold: 0.500
+  error_collector:
+    enabled: true
+    capture_source: true    
+    ignore_errors: IgnoredError
+
+development:
+  <<: *default_settings
+  developer: true
+
+test:
+  <<: *default_settings
+
+production:
+  <<: *default_settings
+
+staging:
+  <<: *default_settings

data/test/multiverse/suites/{rails_3_error_tracing → rails}/error_tracing_test.rb

@@ -1,58 +1,9 @@
 # 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
+require 'fake_collector'
 
-  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
+class ErrorController < ApplicationController
   include Rails.application.routes.url_helpers
   newrelic_ignore :only => :ignored_action
 
@@ -85,36 +36,37 @@ class TestController < ApplicationController
     render :text => "Shoulda noticed an error"
   end
 end
-# END RAILS APP
 
 class IgnoredError < StandardError; end
 class ServerIgnoredError < StandardError; end
 
-class TestControllerTest < ActionDispatch::IntegrationTest
+class ErrorsWithoutSSCTest < ActionDispatch::IntegrationTest
   def setup
-    NewRelic::Agent::Agent.instance_variable_set(:@instance, NewRelic::Agent::Agent.new)
+    $collector ||= NewRelic::FakeCollector.new
+    $collector.reset
+    setup_collector
+    $collector.run
+
+    NewRelic::Agent.reset_config
+    NewRelic::Agent.instance_variable_set(:@agent, nil)
+    NewRelic::Agent::Agent.instance_variable_set(:@instance, nil)
+    NewRelic::Agent.manual_start
 
-    @service = NewRelic::FakeService.new
-    NewRelic::Agent::Agent.instance.service = @service
+    reset_error_collector
+  end
 
-    NewRelic::Agent.manual_start
+  # Let base class override this without moving where we start the agent
+  def setup_collector
+    $collector.mock['connect'] = [200, {'return_value' => {"agent_run_id" => 666 }}]
   end
 
   def teardown
     NewRelic::Agent::Agent.instance.shutdown if NewRelic::Agent::Agent.instance
-  end
-end
-
-class ErrorsWithoutSSCTest < TestControllerTest
-  def setup
-    super
-    reset_error_collector
+    NewRelic::Agent::Agent.instance_variable_set(:@instance, nil)
   end
 
   def reset_error_collector
-    @error_collector = NewRelic::Agent.instance.error_collector
-    NewRelic::Agent.instance.error_collector \
-      .instance_variable_set(:@ignore_filter, nil)
+    @error_collector = NewRelic::Agent::Agent.instance.error_collector
 
     # sanity checks
     assert(@error_collector.enabled?,
@@ -132,25 +84,35 @@ class ErrorsWithoutSSCTest < TestControllerTest
   end
 
   def test_should_capture_error_raised_in_view
-    get '/test/view_error'
+    get '/error/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'
+    get '/error/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'
+    get '/error/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'
+    get '/error/noticed_error'
     assert_error_reported_once('this error should be noticed')
   end
 
+  # Important choice of controllor_error, since this goes through both the
+  # metric_frame and the rack error collector, so risks multiple counting!
+  def test_should_capture_multiple_errors
+    40.times do
+      get '/error/controller_error'
+    end
+
+    assert_errors_reported('this is an uncaught controller error', 20, 40)
+  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')
@@ -170,13 +132,13 @@ class ErrorsWithoutSSCTest < TestControllerTest
   end
 
   def test_should_not_notice_errors_from_ignored_action
-    get '/test/ignored_action'
+    get '/error/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'
+    get '/error/ignored_error'
     assert(@error_collector.errors.empty?,
            'Noticed an error that should have been ignored')
   end
@@ -192,35 +154,36 @@ class ErrorsWithoutSSCTest < TestControllerTest
   end
 
   def test_should_notice_server_ignored_error_if_no_server_side_config
-    get '/test/server_ignored_error'
+    get '/error/server_ignored_error'
     assert_error_reported_once('this is a server ignored error')
   end
 
-  protected
+ protected
+
+  def assert_errors_reported(message, queued_count, total_count=queued_count)
+    error_count = NewRelic::Agent::Agent.instance.stats_engine.get_stats("Errors/all")
+    assert_equal total_count, error_count.call_count
+
+    assert_equal(queued_count,
+      @error_collector.errors.select{|error| error.message == message}.size,
+      "Wrong number of errors with message '#{message} found'")
+  end
 
   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')
+    assert_errors_reported(message, 1)
   end
 end
 
 class ErrorsWithSSCTest < ErrorsWithoutSSCTest
-  def setup
-    super
-    @service.mock['connect'] = {
+  def setup_collector
+    $collector.mock['connect'] = [200, {'return_value' => {
       "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
@@ -228,7 +191,7 @@ class ErrorsWithSSCTest < ErrorsWithoutSSCTest
   end
 
   def test_should_ignore_server_ignored_errors
-    get '/test/server_ignored_error'
+    get '/error/server_ignored_error'
     assert(@error_collector.errors.empty?,
            'Noticed an error that should have been ignored')
   end

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

@@ -0,0 +1,79 @@
+require './app'
+
+# GC instrumentation only works with REE or 1.9.x
+if (defined?(RUBY_DESCRIPTION) && RUBY_DESCRIPTION =~ /Enterprise/) ||
+    RUBY_VERSION >= '1.9.2'
+
+class GcController < ApplicationController
+  include Rails.application.routes.url_helpers
+  def gc_action
+    long_string = "01234567" * 100_000
+    long_string = nil
+    another_long_string = "01234567" * 100_000
+
+    GC.start
+
+    render :text => 'ha'
+  end
+end
+
+class GCRailsInstrumentationTest < ActionController::TestCase
+  tests GcController
+  def setup
+    enable_gc_stats
+
+    @controller = GcController.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 test_records_accurate_time_for_gc_activity
+    start = Time.now
+    get :gc_action
+    elapsed = Time.now.to_f - start.to_f
+
+    assert_in_range(elapsed, get_call_time('GC/cumulative'))
+    assert_in_range(elapsed, get_call_time('GC/cumulative', 'Controller/gc/gc_action'))
+  end
+
+  def test_records_transaction_param_for_gc_activity
+    start = Time.now.to_f
+    get :gc_action
+    elapsed = Time.now.to_f - start
+
+    trace = NewRelic::Agent.instance.transaction_sampler.last_sample
+    assert_in_range(elapsed, trace.params[:custom_params][:gc_time])
+  end
+
+  def assert_in_range(duration, gc_time)
+    assert gc_time > 0.0, "GC Time wasn't recorded!"
+
+    # This is a guess for a reasonable threshold here.
+    # Since these are timing based, we can revise or ditch as evidence ditacts
+    # One CI failure we saw at least had duration=0.314 and gc_time=0.088
+    ratio = gc_time / duration
+    assert(ratio > 0.1 && ratio < 1.0,
+      "Problem with GC/duration ratio. #{gc_time}/#{duration} = #{ratio} not between 0.1 and 1.0")
+  end
+
+  def get_call_time(name, scope=nil)
+    NewRelic::Agent.agent.stats_engine.
+      get_stats(name, true, false, scope).
+      total_call_time
+  end
+
+  def enable_gc_stats
+    if RUBY_DESCRIPTION =~ /Enterprise/
+      GC.enable_stats
+    elsif RUBY_VERSION >= '1.9.2'
+      GC::Profiler.enable
+    end
+  end
+end
+
+end