newrelic_rpm 3.6.2.96 → 3.6.3.103.beta

data/test/multiverse/suites/sinatra/sinatra_classic_test.rb

@@ -0,0 +1,92 @@
+# 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 'mocha'
+require 'sinatra'
+require File.expand_path(File.join(File.dirname(__FILE__), 'sinatra_test_cases'))
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'agent_helper'))
+
+configure do
+  # display exceptions so we see what's going on
+  disable :show_exceptions
+
+  # create a condition (sintra's version of a before_filter) that returns the
+  # value that was passed into it.
+  set :my_condition do |boolean|
+    condition do
+      halt 404 unless boolean
+    end
+  end
+end
+
+get '/user/login' do
+  "please log in"
+end
+
+# this action will always return 404 because of the condition.
+get '/user/:id', :my_condition => false do |id|
+  "Welcome #{id}"
+end
+
+get '/raise' do
+  raise "Uh-oh"
+end
+
+# check that pass works properly
+set(:pass_condition) { |_| condition { pass { halt 418, "I'm a teapot." } } }
+get('/pass', :pass_condition => true) { }
+
+get '/pass' do
+  "I'm not a teapot."
+end
+
+class Error < StandardError; end
+error(Error) { halt 200, 'nothing happened' }
+set(:error_condition) { |_| condition { raise Error } }
+get('/error', :error_condition => true) { }
+
+set(:precondition_check) do |_|
+  condition do
+    raise "Boo" if $precondition_already_checked
+    $precondition_already_checked = true
+  end
+end
+get('/precondition', :precondition_check => true) do
+  'precondition only happened once'
+end
+
+get '/route/:name' do |name|
+  # usually this would be a db test or something
+  pass if name != 'match'
+  'first route'
+end
+
+get '/route/no_match' do
+  'second route'
+end
+
+before '/filtered' do
+  @filtered = true
+end
+
+get '/filtered' do
+  @filtered ? 'got filtered' : 'nope'
+end
+
+newrelic_ignore '/ignored'
+get '/ignored' do
+  "don't trace me bro"
+end
+
+get /\/regex.*/ do
+  "Yeah, regex's!"
+end
+
+class SinatraClassicTest < Test::Unit::TestCase
+  include SinatraTestCases
+
+  def app
+    Sinatra::Application
+  end
+end

data/test/multiverse/suites/sinatra/sinatra_metric_explosion_test.rb

@@ -33,9 +33,6 @@ class SinatraMetricExplosionTest < Test::Unit::TestCase
   end
 
   def setup
-
-    # puts ::NewRelic::Agent.manual_start
-    # puts ::NewRelic::Agent.agent.started?.inspect
     ::NewRelic::Agent.agent.stats_engine.clear_stats
   end
 

data/test/multiverse/suites/sinatra/sinatra_modular_test.rb

@@ -0,0 +1,89 @@
+# 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 'mocha'
+require File.expand_path(File.join(File.dirname(__FILE__), 'sinatra_test_cases'))
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'agent_helper'))
+
+class SinatraModularTestApp < Sinatra::Base
+  configure do
+    # display exceptions so we see what's going on
+    disable :show_exceptions
+
+    # create a condition (sintra's version of a before_filter) that returns the
+    # value that was passed into it.
+    set :my_condition do |boolean|
+      condition do
+        halt 404 unless boolean
+      end
+    end
+  end
+
+  get '/user/login' do
+    "please log in"
+  end
+
+  # this action will always return 404 because of the condition.
+  get '/user/:id', :my_condition => false do |id|
+    "Welcome #{id}"
+  end
+
+  get '/raise' do
+    raise "Uh-oh"
+  end
+
+  # check that pass works properly
+  condition { pass { halt 418, "I'm a teapot." } }
+  get('/pass') { }
+
+  get '/pass' do
+    "I'm not a teapot."
+  end
+
+  class Error < StandardError; end
+  error(Error) { halt 200, 'nothing happened' }
+  condition { raise Error }
+  get('/error') { }
+
+  condition do
+    raise "Boo" if $precondition_already_checked
+    $precondition_already_checked = true
+  end
+  get('/precondition') { 'precondition only happened once' }
+
+  get '/route/:name' do |name|
+    # usually this would be a db test or something
+    pass if name != 'match'
+    'first route'
+  end
+
+  get '/route/no_match' do
+    'second route'
+  end
+
+  before '/filtered' do
+    @filtered = true
+  end
+
+  get '/filtered' do
+    @filtered ? 'got filtered' : 'nope'
+  end
+
+  newrelic_ignore '/ignored'
+  get '/ignored' do
+    "don't trace me bro"
+  end
+
+  get /\/regex.*/ do
+    "Yeah, regex's!"
+  end
+end
+
+class SinatraModularTest < Test::Unit::TestCase
+  include SinatraTestCases
+
+  def app
+    SinatraModularTestApp
+  end
+end

data/test/multiverse/suites/sinatra/sinatra_test_cases.rb

@@ -0,0 +1,120 @@
+# 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.
+
+# This module brings the base test cases that should run against both classic and
+# module Sinatra apps. The sinatra_class_test and sinatra_modular_test files
+# both maintain the same app structure in both forms, and this exercises them.
+module SinatraTestCases
+  include Rack::Test::Methods
+
+  def app
+    raise "Must implement app on your test case"
+  end
+
+  def app_name
+    app.to_s
+  end
+
+  def setup
+    $precondition_already_checked = false
+    ::NewRelic::Agent.manual_start
+  end
+
+  def teardown
+    reset
+  end
+
+  def reset
+    ::NewRelic::Agent.agent.stats_engine.reset_stats
+    ::NewRelic::Agent.agent.error_collector.harvest_errors([])
+  end
+
+  # https://support.newrelic.com/tickets/24779
+  def test_lower_priority_route_conditions_arent_applied_to_higher_priority_routes
+    get '/user/login'
+    assert_equal 200, last_response.status
+    assert_equal 'please log in', last_response.body
+  end
+
+  def test_conditions_are_applied_to_an_action_that_uses_them
+    get '/user/1'
+    assert_equal 404, last_response.status
+  end
+
+  def test_queue_time_headers_are_passed_to_agent
+    get '/user/login', {}, { 'HTTP_X_REQUEST_START' => 't=1360973845' }
+    assert_metrics_recorded(["WebFrontend/QueueTime"])
+  end
+
+  def test_shown_errors_get_caught
+     get '/raise'
+     assert_equal 1, ::NewRelic::Agent.agent.error_collector.errors.size
+  end
+
+  def test_does_not_break_pass
+    get '/pass'
+    assert_equal 200, last_response.status
+    assert_equal "I'm not a teapot.", last_response.body
+  end
+
+  def test_does_not_break_error_handling
+    get '/error'
+    assert_equal 200, last_response.status
+    assert_equal "nothing happened", last_response.body
+  end
+
+  def test_sees_handled_error
+    get '/error'
+    assert_equal 1, ::NewRelic::Agent.agent.error_collector.errors.size
+  end
+
+  def test_correct_pattern
+    get '/route/match'
+    assert_equal 'first route', last_response.body
+    assert_metrics_recorded(["Controller/Sinatra/#{app_name}/GET route/([^/?#]+)"])
+
+    reset
+
+    get '/route/no_match'
+    assert_equal 'second route', last_response.body
+    assert_metrics_recorded(["Controller/Sinatra/#{app_name}/GET route/no_match"])
+  end
+
+  def test_with_regex_pattern
+    get '/regexes'
+    assert_equal "Yeah, regex's!", last_response.body
+    assert_metrics_recorded(["Controller/Sinatra/#{app_name}/GET regex.*"])
+  end
+
+  def test_set_unknown_transaction_name_if_error_in_routing
+    ::NewRelic::Agent::Instrumentation::Sinatra::TransactionNamer \
+      .stubs(:http_verb).raises(StandardError.new('madness'))
+
+    get '/user/login'
+    assert_metrics_recorded(["Controller/Sinatra/#{app_name}/(unknown)"])
+  end
+
+  # https://support.newrelic.com/tickets/31061
+  def test_precondition_not_over_called
+    get '/precondition'
+
+    assert_equal 200, last_response.status
+    assert_equal 'precondition only happened once', last_response.body
+    assert_metrics_recorded(["Controller/Sinatra/#{app_name}/GET precondition"])
+  end
+
+  def test_filter
+    get '/filtered'
+
+    assert_equal 200, last_response.status
+    assert_equal 'got filtered', last_response.body
+  end
+
+  def test_ignores_route_metrics
+    get '/ignored'
+
+    assert_equal 200, last_response.status
+    assert_metrics_not_recorded(["Controller/Sinatra/#{app_name}/GET ignored"])
+  end
+end

data/test/new_relic/agent/agent_logger_test.rb

@@ -6,7 +6,24 @@ require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper
 require 'new_relic/agent/agent_logger'
 require 'new_relic/agent/null_logger'
 
+class ArrayLogDevice
+  def initialize( array=[] )
+    @array = array
+  end
+  attr_reader :array
+
+  def write( message )
+    @array << message
+  end
+
+  def close; end
+end
+
+
 class AgentLoggerTest < Test::Unit::TestCase
+
+  LEVELS = [:fatal, :error, :warn, :info, :debug]
+
   def setup
     @config = {
       :log_file_path => "log/",
@@ -15,66 +32,77 @@ class AgentLoggerTest < Test::Unit::TestCase
     }
   end
 
-  def test_initalizes_from_config
-    override_logger = stub(:level=)
-    ::Logger.stubs(:new).with(any_parameters).returns(override_logger)
 
+  #
+  # Tests
+  #
+
+  def test_initalizes_from_config
     logger = NewRelic::Agent::AgentLogger.new(@config)
-    assert_equal(override_logger, logger.instance_variable_get(:@log))
+
+    wrapped_logger = logger.instance_variable_get( :@log )
+    logdev = wrapped_logger.instance_variable_get( :@logdev )
+    expected_logpath = File.expand_path( @config[:log_file_path] + @config[:log_file_name] )
+
+    assert_kind_of( Logger, wrapped_logger )
+    assert_kind_of( File, logdev.dev )
+    assert_equal( expected_logpath, logdev.filename )
   end
 
   def test_initalizes_from_override
-    override_logger = stub(:level=)
+    override_logger = Logger.new( '/dev/null' )
     logger = NewRelic::Agent::AgentLogger.new(@config, "", override_logger)
     assert_equal override_logger, logger.instance_variable_get(:@log)
   end
 
-  def test_forwards_calls_to_logger
-    [:fatal, :error, :warn, :info, :debug].each do |level|
-      override_logger = stub(:level=)
-      override_logger.expects(level).with(any_parameters)
 
-      logger = NewRelic::Agent::AgentLogger.new(@config, "", override_logger)
+  def test_forwards_calls_to_logger
+    logdev = ArrayLogDevice.new
+    override_logger = Logger.new( logdev )
+    logger = NewRelic::Agent::AgentLogger.new(@config, "", override_logger)
 
+    LEVELS.each do |level|
       logger.send(level, "Boo!")
     end
+
+    assert_equal 4, logdev.array.length # No DEBUG
+
+    assert_match( /FATAL/, logdev.array[0] )
+    assert_match( /ERROR/, logdev.array[1] )
+    assert_match( /WARN/,  logdev.array[2] )
+    assert_match( /INFO/,  logdev.array[3] )
   end
 
 
   def test_forwards_calls_to_logger_with_multiple_arguments
-    [:fatal, :error, :warn, :info, :debug].each do |level|
-      override_logger = stub(:level=)
-      override_logger.expects(level).with("What\nup?")
-
-      logger = NewRelic::Agent::AgentLogger.new(@config, "", override_logger)
+    logdev = ArrayLogDevice.new
+    override_logger = Logger.new( logdev )
+    logger = NewRelic::Agent::AgentLogger.new(@config, "", override_logger)
 
+    LEVELS.each do |level|
       logger.send(level, "What", "up?")
     end
-  end
 
-  def test_passing_exceptions_gets_pretty_formatting
-    caught = nil
-    begin
-      raise Exception.new("Boo!")
-    rescue Exception => e
-      caught = e
-    end
-
-    # Checking if it looks like message includes backtrace
-    override_logger = stub(:level=)
-    override_logger.expects(:debug).with {|msg| msg.include?("test_") }
+    assert_equal 8, logdev.array.length # No DEBUG, two per level
 
-    NewRelic::Agent::AgentLogger.new(@config, "", override_logger).debug(e)
+    assert_match( /FATAL/, logdev.array[0] )
+    assert_match( /FATAL/, logdev.array[1] )
+    assert_match( /ERROR/, logdev.array[2] )
+    assert_match( /ERROR/, logdev.array[3] )
+    assert_match( /WARN/,  logdev.array[4] )
+    assert_match( /WARN/,  logdev.array[5] )
+    assert_match( /INFO/,  logdev.array[6] )
+    assert_match( /INFO/,  logdev.array[7] )
   end
 
   def test_wont_log_if_agent_not_enabled
-    null_logger = NewRelic::Agent::NullLogger.new
-    NewRelic::Agent::NullLogger.expects(:new).returns(null_logger)
     @config[:agent_enabled] = false
     logger = NewRelic::Agent::AgentLogger.new(@config)
     assert_nothing_raised do
       logger.warn('hi there')
     end
+
+    assert_kind_of NewRelic::Agent::NullLogger, logger.instance_variable_get( :@log )
   end
 
   def test_does_not_touch_dev_null
@@ -95,64 +123,114 @@ class AgentLoggerTest < Test::Unit::TestCase
   end
 
   def test_sets_log_level
-    override_logger = mock()
-    override_logger.expects(:level=).with(Logger::DEBUG)
     @config[:log_level] = :debug
 
+    override_logger = Logger.new( $stderr )
+    override_logger.level = Logger::FATAL
+
     logger = NewRelic::Agent::AgentLogger.new(@config, "", override_logger)
+
+    assert_equal Logger::DEBUG, override_logger.level
   end
 
   def test_log_to_stdout_and_warns_if_failed_on_create
-    NewRelic::Agent::AgentLogger.any_instance.stubs(:find_or_create_file_path).returns(nil)
+      Dir.stubs(:mkdir).returns(nil)
+      config = @config.merge( :log_file_path => '/someplace/non/existant' )
 
-    stdout = stub(:level=)
-    stdout.expects(:warn)
-    ::Logger.stubs(:new).with(STDOUT).returns(stdout)
+    logger = with_squelched_stdout do
+      NewRelic::Agent::AgentLogger.new(config)
+    end
 
-    logger = NewRelic::Agent::AgentLogger.new(@config)
-    assert_equal stdout, logger.instance_variable_get(:@log)
+    wrapped_logger = logger.instance_variable_get(:@log)
+    logdev = wrapped_logger.instance_variable_get(:@logdev)
+
+    assert_equal $stdout, logdev.dev
   end
 
   def test_log_to_stdout_based_on_config
     @config[:log_file_path] = "STDOUT"
 
-    stdout = stub(:level=)
-    stdout.expects(:warn).never
-    ::Logger.stubs(:new).with(STDOUT).returns(stdout)
-
     logger = NewRelic::Agent::AgentLogger.new(@config)
-    assert_equal stdout, logger.instance_variable_get(:@log)
+    wrapped_logger = logger.instance_variable_get(:@log)
+    logdev = wrapped_logger.instance_variable_get(:@logdev)
+
+    assert_equal $stdout, logdev.dev
   end
 
   def test_startup_purges_memory_logger
-    [:fatal, :error, :warn, :info, :debug].each do |level|
+    LEVELS.each do |level|
       ::NewRelic::Agent::StartupLogger.instance.send(level, "boo!")
+    end
 
-      override_logger = stub(:level=)
-      override_logger.expects(level).with("boo!")
+    logdev = ArrayLogDevice.new
+    override_logger = Logger.new( logdev )
+    logger = NewRelic::Agent::AgentLogger.new(@config, "", override_logger)
+
+    assert_equal 4, logdev.array.length # No DEBUG
+
+    assert_match( /FATAL/, logdev.array[0] )
+    assert_match( /ERROR/, logdev.array[1] )
+    assert_match( /WARN/,  logdev.array[2] )
+    assert_match( /INFO/,  logdev.array[3] )
+  end
 
-      NewRelic::Agent::AgentLogger.new(@config, "", override_logger)
+  def test_passing_exceptions_only_logs_the_message_at_levels_higher_than_debug
+    logdev = ArrayLogDevice.new
+    override_logger = Logger.new( logdev )
+    logger = NewRelic::Agent::AgentLogger.new(@config, "", override_logger)
+
+    begin
+      raise "Something bad happened"
+    rescue => err
+      logger.error( err )
     end
+
+    assert_equal 1, logdev.array.length
+    assert_match( /ERROR : RuntimeError: Something bad happened/i, logdev.array[0] )
+  end
+
+  def test_passing_exceptions_logs_the_backtrace_at_debug_level
+    config = @config.merge(:log_level => :debug)
+
+    logdev = ArrayLogDevice.new
+    override_logger = Logger.new( logdev )
+    logger = NewRelic::Agent::AgentLogger.new(config, "", override_logger)
+
+    begin
+      raise "Something bad happened"
+    rescue => err
+      logger.error( err )
+    end
+
+    assert_equal 2, logdev.array.length
+    assert_match( /ERROR : RuntimeError: Something bad happened/i, logdev.array[0] )
+    assert_match( /DEBUG : Debugging backtrace:\n.*test_passing_exceptions/i,
+                  logdev.array[1] )
   end
 
   def test_format_message_allows_nil_backtrace
-    override_logger = stub(:level=)
-    override_logger.expects(:debug)
+    logdev = ArrayLogDevice.new
+    override_logger = Logger.new( logdev )
+    logger = NewRelic::Agent::AgentLogger.new(@config, "", override_logger)
 
-    logger = ::NewRelic::Agent::AgentLogger.new(@config, "", override_logger)
+    logger.error(Exception.new("Look Ma, no backtrace!"))
 
-    logger.debug(Exception.new("Look Ma, no backtrace!"))
+    assert_equal 1, logdev.array.length
+    assert_match( /ERROR : Exception: Look Ma, no backtrace!/i, logdev.array[0] )
   end
 
 
   def test_logs_to_stdout_if_fails_on_file
-    stdout = stub_everything()
-    ::Logger.stubs(:new).with(STDOUT).returns(stdout)
-    ::Logger.stubs(:new).with(instance_of(String)).raises(Errno::EACCES)
+    Logger::LogDevice.any_instance.stubs(:open).raises(Errno::EACCES)
+
+    logger = with_squelched_stdout do
+      NewRelic::Agent::AgentLogger.new(@config, "")
+    end
 
-    logger = NewRelic::Agent::AgentLogger.new(@config, "")
+    wrapped_logger = logger.instance_variable_get(:@log)
+    logdev = wrapped_logger.instance_variable_get(:@logdev)
 
-    assert_equal stdout, logger.instance_variable_get(:@log)
+    assert_equal $stdout, logdev.dev
   end
 
   def test_null_logger_works_with_impolite_gems_that_add_stuff_to_kernel
@@ -169,4 +247,19 @@ class AgentLoggerTest < Test::Unit::TestCase
       remove_method :debug
     end
   end
+
+
+
+  #
+  # Helpers
+  #
+
+  def with_squelched_stdout
+    orig = $stdout.dup
+    $stdout.reopen( '/dev/null' )
+    yield
+  ensure
+    $stdout.reopen( orig )
+  end
+
 end