newrelic_rpm 3.6.5.130 → 3.6.6.147

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

@@ -5,8 +5,13 @@
 # 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.
+
+require 'multiverse_helpers'
+
 module SinatraTestCases
   include Rack::Test::Methods
+  include MultiverseHelpers
+
 
   def app
     raise "Must implement app on your test case"
@@ -16,18 +21,10 @@ module SinatraTestCases
     app.to_s
   end
 
-  def setup
-    $precondition_already_checked = false
-    ::NewRelic::Agent.manual_start
-  end
-
-  def teardown
-    reset
-  end
+  setup_and_teardown_agent
 
-  def reset
-    ::NewRelic::Agent.agent.stats_engine.reset_stats
-    ::NewRelic::Agent.agent.error_collector.harvest_errors([])
+  def after_setup
+    $precondition_already_checked = false
   end
 
   # https://support.newrelic.com/tickets/24779
@@ -73,9 +70,9 @@ module SinatraTestCases
     get '/route/match'
     assert_equal 'first route', last_response.body
     assert_metrics_recorded(["Controller/Sinatra/#{app_name}/GET route/([^/?#]+)"])
+  end
 
-    reset
-
+  def test_finds_second_route
     get '/route/no_match'
     assert_equal 'second route', last_response.body
     assert_metrics_recorded(["Controller/Sinatra/#{app_name}/GET route/no_match"])

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

@@ -11,11 +11,9 @@ development:
   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

data/test/multiverse/suites/typhoeus/typhoeus_test.rb

@@ -11,7 +11,7 @@ require File.join(File.dirname(__FILE__), "..", "..", "..", "agent_helper")
 
 if NewRelic::Agent::Instrumentation::TyphoeusTracing.is_supported_version?
 
-  class TyphoeusTest < Test::Unit::TestCase
+  class TyphoeusTest < MiniTest::Unit::TestCase
     include HttpClientTestCases
 
     USE_SSL_VERIFYPEER_VERSION = NewRelic::VersionNumber.new("0.5.0")
@@ -46,8 +46,11 @@ if NewRelic::Agent::Instrumentation::TyphoeusTracing.is_supported_version?
       NewRelic::Agent::HTTPClients::TyphoeusHTTPRequest.new(Typhoeus::Request.new("http://newrelic.com"))
     end
 
-    def response_instance
-      headers = "HTTP/1.1 200 OK \r\nX-Whatever-Man: 42"
+    def response_instance(headers = {})
+      headers = headers.map do |k,v|
+        "#{k}: #{v}"
+      end.join("\r\n")
+
       NewRelic::Agent::HTTPClients::TyphoeusHTTPResponse.new(Typhoeus::Response.new(:response_headers => headers))
     end
 
@@ -66,7 +69,7 @@ if NewRelic::Agent::Instrumentation::TyphoeusTracing.is_supported_version?
 
 else
 
-  class TyphoeusNotInstrumented < Test::Unit::TestCase
+  class TyphoeusNotInstrumented < MiniTest::Unit::TestCase
     def test_works_without_instrumentation
       # Typhoeus.get wasn't supported back before 0.5.x
       Typhoeus::Request.get("http://localhost/not/there")

data/test/multiverse/test/suite_examples/one/a/a_test.rb

@@ -12,4 +12,3 @@ class ATest < Test::Unit::TestCase
     assert !defined?(Haml)
   end
 end
-

data/test/multiverse/test/suite_examples/one/a/config/newrelic.yml

@@ -13,7 +13,6 @@ development:
   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

data/test/multiverse/test/suite_examples/one/b/b_test.rb

@@ -12,4 +12,3 @@ class BTest < Test::Unit::TestCase
     assert Haml
   end
 end
-

data/test/multiverse/test/suite_examples/one/b/config/newrelic.yml

@@ -13,7 +13,6 @@ development:
   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

data/test/new_relic/agent/agent/connect_test.rb

@@ -70,7 +70,7 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
   def test_log_error
     error = StandardError.new("message")
 
-    expects_logging(:error, 
+    expects_logging(:error,
       includes("Error establishing connection with New Relic Service"), \
       instance_of(StandardError))
 

data/test/new_relic/agent/agent/start_test.rb

@@ -200,4 +200,3 @@ class NewRelic::Agent::Agent::StartTest < Test::Unit::TestCase
     fake_control
   end
 end
-

data/test/new_relic/agent/agent/start_worker_thread_test.rb

@@ -89,4 +89,3 @@ class NewRelic::Agent::Agent::StartWorkerThreadTest < Test::Unit::TestCase
     fake_control
   end
 end
-

data/test/new_relic/agent/agent_logger_test.rb

@@ -209,16 +209,50 @@ class AgentLoggerTest < Test::Unit::TestCase
   end
 
   def test_format_message_allows_nil_backtrace
+    config = @config.merge(:log_level => :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!"))
+    e = Exception.new("Look Ma, no backtrace!")
+    assert_nil(e.backtrace)
+    logger.error(e)
 
-    assert_equal 1, logdev.array.length
+    assert_equal 2, logdev.array.length
     assert_match( /ERROR : Exception: Look Ma, no backtrace!/i, logdev.array[0] )
+    assert_match( /DEBUG : No backtrace available./, logdev.array[1])
   end
 
+  def test_log_exception_logs_backtrace_at_same_level_as_message_by_default
+    logdev = ArrayLogDevice.new
+    override_logger = Logger.new(logdev)
+    logger = NewRelic::Agent::AgentLogger.new(@config, "", override_logger)
+
+    e = Exception.new("howdy")
+    e.set_backtrace(["wiggle", "wobble", "topple"])
+
+    logger.log_exception(:info, e)
+
+    assert_match(/INFO : Exception: howdy/i, logdev.array[0])
+    assert_match(/INFO : Debugging backtrace:\n.*wiggle\s+wobble\s+topple/,
+                  logdev.array[1])
+  end
+
+  def test_log_exception_logs_backtrace_at_explicitly_specified_level
+    logdev = ArrayLogDevice.new
+    override_logger = Logger.new(logdev)
+    logger = NewRelic::Agent::AgentLogger.new(@config, "", override_logger)
+
+    e = Exception.new("howdy")
+    e.set_backtrace(["wiggle", "wobble", "topple"])
+
+    logger.log_exception(:warn, e, :info)
+
+    assert_match(/WARN : Exception: howdy/i, logdev.array[0])
+    assert_match(/INFO : Debugging backtrace:\n.*wiggle\s+wobble\s+topple/,
+                  logdev.array[1])
+  end
 
   def test_logs_to_stdout_if_fails_on_file
     Logger::LogDevice.any_instance.stubs(:open).raises(Errno::EACCES)

data/test/new_relic/agent/agent_test.rb

@@ -245,7 +245,7 @@ module NewRelic
 
       def test_merge_data_from_abides_by_error_queue_limit
         errors = []
-        40.times { |i| errors << Exception.new("boo #{i}") }
+        40.times { |i| errors << NewRelic::NoticedError.new("", {}, Exception.new("boo #{i}")) }
 
         @agent.merge_data_from([{}, [], errors])
 
@@ -335,5 +335,27 @@ module NewRelic
       end
 
     end
+
+
+    class AgentStartingTest < Test::Unit::TestCase
+      def test_no_service_if_not_monitoring
+        with_config(:monitor_mode => false) do
+          agent = NewRelic::Agent::Agent.new
+          assert_nil agent.service
+        end
+      end
+
+      def test_abides_by_disabling_harvest_thread
+        with_config(:disable_harvest_thread => true) do
+          threads_before = Thread.list.length
+
+          agent = NewRelic::Agent::Agent.new
+          agent.send(:start_worker_thread)
+
+          assert_equal threads_before, Thread.list.length
+        end
+      end
+
+    end
   end
 end

data/test/new_relic/agent/browser_monitoring_test.rb

@@ -2,7 +2,6 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
-ENV['SKIP_RAILS'] = 'true'
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
 require "new_relic/agent/browser_monitoring"
 require "new_relic/rack/browser_monitoring"

data/test/new_relic/agent/busy_calculator_test.rb

@@ -2,8 +2,6 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
-# Run faster standalone
-ENV['SKIP_RAILS'] = 'true'
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
 class NewRelic::Agent::BusyCalculatorTest < Test::Unit::TestCase
   attr_reader :now
@@ -68,6 +66,8 @@ class NewRelic::Agent::BusyCalculatorTest < Test::Unit::TestCase
     # Get busy for 8 - 2 seconds
     NewRelic::Agent::BusyCalculator.dispatcher_finish(now - 2.0)
     worker.join
+
+    NewRelic::Agent::BusyCalculator.stubs(:time_now).returns(now - 1.0)
     NewRelic::Agent::BusyCalculator.harvest_busy
 
     assert_equal 1, @instance_busy.call_count

data/test/new_relic/agent/configuration/environment_source_test.rb

@@ -56,6 +56,28 @@ module NewRelic::Agent::Configuration
       end
     end
 
+    %w| NEWRELIC_DISABLE_HARVEST_THREAD NEW_RELIC_DISABLE_HARVEST_THREAD |.each do |var|
+      define_method("test_environment_booleans_truths_are_applied_to_#{var}") do
+        ENV[var] = 'true'
+        assert EnvironmentSource.new[:disable_harvest_thread]
+        ENV[var] = 'on'
+        assert EnvironmentSource.new[:disable_harvest_thread]
+        ENV[var] = 'yes'
+        assert EnvironmentSource.new[:disable_harvest_thread]
+        ENV.delete(var)
+      end
+
+      define_method("test_environment_booleans_falsehoods_are_applied_to_#{var}") do
+        ENV[var] = 'false'
+        assert !EnvironmentSource.new[:disable_harvest_thread]
+        ENV[var] = 'off'
+        assert !EnvironmentSource.new[:disable_harvest_thread]
+        ENV[var] = 'no'
+        assert !EnvironmentSource.new[:disable_harvest_thread]
+        ENV.delete(var)
+      end
+    end
+
     def test_set_log_config_from_environment
       ENV['NEW_RELIC_LOG'] = 'off/in/space.log'
       source = EnvironmentSource.new

data/test/new_relic/agent/error_collector/notice_error_test.rb

@@ -129,7 +129,7 @@ class NewRelic::Agent::ErrorCollector::NoticeErrorTest < Test::Unit::TestCase
   end
 
   def test_over_queue_limit_positive
-    @errors = %w(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21)
+    @errors = (1..21).map{|_| NewRelic::NoticedError.new("", {}, nil)}
     expects_logging(:warn, includes('The error reporting queue has reached 20'))
     assert over_queue_limit?('hooray')
   end

data/test/new_relic/agent/error_collector_test.rb

@@ -2,9 +2,8 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
-# Run faster standalone
-ENV['SKIP_RAILS'] = 'true'
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+require 'new_relic/agent/internal_agent_error'
 
 class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
   def setup
@@ -13,6 +12,8 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
     NewRelic::Agent.config.apply_config(@test_config)
     @error_collector = NewRelic::Agent::ErrorCollector.new
     @error_collector.stubs(:enabled).returns(true)
+
+    NewRelic::Agent.instance.stats_engine.reset_stats
   end
 
   def teardown
@@ -197,26 +198,107 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
   end
 
   def test_increment_error_count_record_summary_and_txn_metric
-    stats_engine = NewRelic::Agent.instance.stats_engine
-    stats_engine.reset_stats
-
     @error_collector.increment_error_count!(StandardError.new('Boo'),
                                             :metric => 'Controller/class/method')
 
-    assert_equal(1, stats_engine.get_stats('Errors/all').call_count,
-                 'Missing Errors/all metric')
-    assert_equal(1, stats_engine.get_stats('Errors/Controller/class/method').call_count,
-                 'Missing Errors/Controller/class/method metric')
+    assert_metrics_recorded(['Errors/all', 'Errors/Controller/class/method'])
   end
 
   def test_doesnt_increment_error_count_on_transaction_if_nameless
-    stats_engine = NewRelic::Agent.instance.stats_engine
-    stats_engine.reset_stats
-
     @error_collector.increment_error_count!(StandardError.new('Boo'),
                                             :metric => '(unknown)')
 
-    assert_equal(0, stats_engine.get_stats('Errors/(unknown)').call_count)
+    assert_metrics_not_recorded(['Errors/(unknown)'])
+  end
+
+
+  class DifficultToDebugAgentError < NewRelic::Agent::InternalAgentError
+  end
+
+  class AnotherToughAgentError < NewRelic::Agent::InternalAgentError
+  end
+
+  def test_notices_agent_error
+    @error_collector.notice_agent_error(DifficultToDebugAgentError.new)
+    assert_equal 1, @error_collector.errors.size
+  end
+
+  def test_only_notices_agent_error_per_type
+    @error_collector.notice_agent_error(DifficultToDebugAgentError.new)
+    @error_collector.notice_agent_error(DifficultToDebugAgentError.new)
+
+    assert_equal 1, @error_collector.errors.size
+  end
+
+  def test_only_notices_agent_error_per_type_allows_other_types
+    @error_collector.notice_agent_error(DifficultToDebugAgentError.new)
+    @error_collector.notice_agent_error(DifficultToDebugAgentError.new)
+    @error_collector.notice_agent_error(AnotherToughAgentError.new)
+
+    assert_equal 2, @error_collector.errors.size
+  end
+
+  def test_does_not_touch_error_metrics
+    @error_collector.notice_agent_error(DifficultToDebugAgentError.new)
+    @error_collector.notice_agent_error(DifficultToDebugAgentError.new)
+    @error_collector.notice_agent_error(AnotherToughAgentError.new)
+
+    assert_metrics_recorded_exclusive([])
+  end
+
+  def test_notice_agent_error_set_noticed_error_attributes
+    @error_collector.notice_agent_error(DifficultToDebugAgentError.new)
+
+    err = @error_collector.errors.first
+    assert_equal "NewRelic/AgentError", err.path
+    assert_kind_of Hash, err.params
+    assert_not_nil err.params[:stack_trace]
+  end
+
+  def test_notice_agent_error_uses_exception_backtrace_if_present
+    trace = ["boo", "yeah", "error"]
+    exception = DifficultToDebugAgentError.new
+    exception.set_backtrace(trace)
+    @error_collector.notice_agent_error(exception)
+
+    assert_equal trace, @error_collector.errors.first.params[:stack_trace]
+  end
+
+  def test_notice_agent_error_uses_caller_if_no_exception_backtrace
+    exception = DifficultToDebugAgentError.new
+    exception.set_backtrace(nil)
+    @error_collector.notice_agent_error(exception)
+
+    trace = @error_collector.errors.first.params[:stack_trace]
+    assert trace.any? {|line| line.include?(__FILE__)}
+  end
+
+  def test_notice_agent_error_allows_an_error_past_queue_limit
+    100.times { @error_collector.notice_error(StandardError.new("Ouch")) }
+
+    exception = DifficultToDebugAgentError.new
+    @error_collector.notice_agent_error(exception)
+
+    assert_equal 21, @error_collector.errors.size
+    assert_equal DifficultToDebugAgentError, @error_collector.errors.last.exception_class_constant
+  end
+
+  def test_notice_agent_error_doesnt_clog_up_the_queue_limit
+    exception = DifficultToDebugAgentError.new
+    @error_collector.notice_agent_error(exception)
+
+    100.times { @error_collector.notice_error(StandardError.new("Ouch")) }
+
+    assert_equal 21, @error_collector.errors.size
+  end
+
+  def test_notice_agent_error_adds_support_message
+    exception = DifficultToDebugAgentError.new("BOO")
+    @error_collector.notice_agent_error(exception)
+
+    err = @error_collector.errors.first
+    assert err.message.include?(exception.message)
+    assert err.message.include?("Ruby agent internal error")
   end
 
   private

data/test/new_relic/agent/event_listener_test.rb

@@ -68,4 +68,3 @@ class EventListenerTest < Test::Unit::TestCase
   end
 
 end
-