sundawg_newrelic_rpm 3.5.8.1

data/test/multiverse/suites/datamapper/Envfile

@@ -0,0 +1,8 @@
+suite_condition("Datamapper not supported in 1.8.6") do
+  RUBY_VERSION != '1.8.6'
+end
+
+gemfile <<-RB
+  gem 'datamapper'
+RB
+

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

@@ -0,0 +1,22 @@
+---
+development:
+  error_collector:
+    capture_source: true
+    enabled: true
+  apdex_t: 0.5
+  ssl: false
+  monitor_mode: true
+  license_key: bootstrap_newrelic_admin_license_key_000
+  developer_mode: false
+  app_name: test
+  host: 127.0.0.1
+  api_host: 127.0.0.1
+  port: <%= 30_000 + ($$ % 10_000) %>
+  transaction_tracer:
+    record_sql: obfuscated
+    enabled: true
+    stack_trace_threshold: 0.5
+    transaction_threshold: 1.0
+  capture_params: false
+  log_level: debug
+  log_file_path: agent.log

data/test/multiverse/suites/datamapper/encoding_test.rb

@@ -0,0 +1,36 @@
+# https://support.newrelic.com/tickets/2101
+# https://github.com/newrelic/rpm/pull/42
+# https://github.com/newrelic/rpm/pull/45
+require 'test/unit'
+require 'new_relic/agent/instrumentation/data_mapper'
+
+class DatabaseAdapter
+  # we patch in here
+  def log(*args)
+  end
+  include ::NewRelic::Agent::Instrumentation::DataMapperInstrumentation
+end
+
+class EncodingTest < Test::Unit::TestCase
+  # datamapper wants a msg object
+  MSG = Object.new
+  def MSG.query
+    # Contains invalid UTF8 Byte
+    q = "select ICS95095010000000000083320000BS01030000004100+\xFF00000000000000000"
+    if RUBY_VERSION >= '1.9'
+      # Force the query to an invalid encoding
+      q.force_encoding 'UTF-8'
+    end
+    q
+  end
+  def MSG.duration; 1.0; end
+
+  def test_should_not_bomb_out_if_a_query_is_in_an_invalid_encoding
+    if RUBY_VERSION >= '1.9'
+      assert_equal false, MSG.query.valid_encoding?
+    end
+    db = DatabaseAdapter.new
+    db.send(:log, MSG)
+  end
+end
+

data/test/multiverse/suites/rails/Envfile

@@ -0,0 +1,18 @@
+suite_condition("Rails 3 does not support 1.8.6") do
+  RUBY_VERSION != '1.8.6'
+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/app/views/foos/_foo.html.haml

@@ -0,0 +1 @@
+= foo.inspect

data/test/multiverse/suites/rails/app/views/views/_a_partial.html.erb

@@ -0,0 +1 @@
+This is a partial

data/test/multiverse/suites/rails/app/views/views/_mid_partial.html.erb

@@ -0,0 +1 @@
+<%= render 'a_partial' %>

data/test/multiverse/suites/rails/app/views/views/_top_partial.html.erb

@@ -0,0 +1,3 @@
+<% (1..10).each do |i| %>
+  <%= render 'mid_partial', :i => i %>
+<% end %>

data/test/multiverse/suites/rails/app/views/views/deep_partial.html.erb

@@ -0,0 +1,3 @@
+<%- 10.times do |i| %>
+  <%= render 'top_partial' %>
+<%- end %>

data/test/multiverse/suites/rails/app/views/views/haml_view.html.haml

@@ -0,0 +1,6 @@
+!!!
+%html
+  %head
+    %title Hello
+  %body
+    hello from haml

data/test/multiverse/suites/rails/app/views/views/index.html.erb

@@ -0,0 +1,4 @@
+
+<%- 3.times do |i| %>
+<%= render "a_partial" %>
+<%- 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/error_tracing_test.rb

@@ -0,0 +1,211 @@
+# https://newrelic.atlassian.net/browse/RUBY-747
+
+require 'rails/test_help'
+require 'fake_collector'
+
+class ErrorController < 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
+
+class IgnoredError < StandardError; end
+class ServerIgnoredError < StandardError; end
+
+class ErrorsWithoutSSCTest < ActionDispatch::IntegrationTest
+  def setup
+    $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
+
+    reset_error_collector
+  end
+
+  # 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
+    NewRelic::Agent::Agent.instance_variable_set(:@instance, nil)
+  end
+
+  def reset_error_collector
+    @error_collector = NewRelic::Agent::Agent.instance.error_collector
+
+    # 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 '/error/view_error'
+    assert_error_reported_once('this is an uncaught view error',
+                               'Controller/error/view_error')
+  end
+
+  def test_should_capture_error_raised_in_controller
+    get '/error/controller_error'
+    assert_error_reported_once('this is an uncaught controller error',
+                               'Controller/error/controller_error')
+  end
+
+  def test_should_capture_error_raised_in_model
+    get '/error/model_error'
+    assert_error_reported_once('this is an uncaught model error',
+                               'Controller/error/model_error')
+  end
+
+  def test_should_capture_noticed_error_in_controller
+    get '/error/noticed_error'
+    assert_error_reported_once('this error should be noticed',
+                               'Controller/error/noticed_error')
+  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')
+  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 '/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 '/error/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 '/error/server_ignored_error'
+    assert_error_reported_once('this is a server ignored error')
+  end
+
+ protected
+
+  def assert_errors_reported(message, queued_count, total_count=queued_count, txn_name=nil)
+    error_count = NewRelic::Agent::Agent.instance.stats_engine.get_stats("Errors/all")
+    assert_equal(total_count, error_count.call_count,
+                 'Incorrect call count on Errors/all')
+
+    if txn_name
+      error_count = NewRelic::Agent::Agent.instance.stats_engine \
+        .get_stats("Errors/#{txn_name}")
+      assert_equal(total_count, error_count.call_count,
+                   "Incorrect call count on Errors/#{txn_name}")
+    end
+
+    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, txn_name=nil)
+    assert_errors_reported(message, 1, 1, txn_name)
+  end
+end
+
+class ErrorsWithSSCTest < ErrorsWithoutSSCTest
+  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
+    }}]
+  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 '/error/server_ignored_error'
+    assert(@error_collector.errors.empty?,
+           'Noticed an error that should have been ignored')
+  end
+
+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