newrelic_rpm 3.9.5.251 → 3.9.6.257

data/test/new_relic/agent/transaction_state_test.rb

@@ -21,21 +21,18 @@ module NewRelic::Agent
 
     def test_without_transaction_stack_on_thread
       assert_equal false, state.in_background_transaction?
-      assert_equal false, state.in_request_transaction?
+      assert_equal false, state.in_web_transaction?
     end
 
     def test_in_background_transaction
       in_transaction(:category => :task) do |txn|
-        txn.request = nil # this makes it a "background transaction"
         assert state.in_background_transaction?
       end
     end
 
     def test_in_request_tranasction
-      in_transaction do |txn|
-        txn.request = stub()
-
-        assert state.in_request_transaction?
+      in_web_transaction do
+        assert state.in_web_transaction?
       end
     end
 

data/test/new_relic/agent/transaction_test.rb

@@ -14,6 +14,8 @@ class NewRelic::Agent::TransactionTest < Minitest::Test
 
   def teardown
     # Failed transactions can leave partial stack, so pave it for next test
+
+    ::NewRelic::Agent.logger.clear_already_logged
     cleanup_transaction
   end
 
@@ -606,6 +608,102 @@ class NewRelic::Agent::TransactionTest < Minitest::Test
     end
   end
 
+  module ::Java
+    module JavaLangManagement
+      class ManagementFactory
+      end
+    end
+  end
+
+  def test_jruby_cpu_time_returns_0_for_neg1_java_utime
+    in_transaction do |txn|
+      with_java_classes_loaded do
+        bean = mock(:getCurrentThreadUserTime => -1)
+        bean.stubs(:isCurrentThreadCpuTimeSupported).returns(true)
+        ::Java::JavaLangManagement::ManagementFactory.stubs(:getThreadMXBean).returns(bean)
+        assert_equal 0.0, txn.send(:jruby_cpu_time)
+      end
+    end
+  end
+
+  def test_jruby_cpu_time_returns_java_utime_over_1e9_if_java_utime_is_1
+    java_utime = 1
+    in_transaction do |txn|
+      with_java_classes_loaded do
+        bean = stub(:getCurrentThreadUserTime => java_utime)
+        bean.stubs(:isCurrentThreadCpuTimeSupported).returns(true)
+        ::Java::JavaLangManagement::ManagementFactory.stubs(:getThreadMXBean).returns(bean)
+        assert_equal java_utime/1e9, txn.send(:jruby_cpu_time)
+      end
+    end
+  end
+
+  def test_jruby_cpu_time_logs_errors_once_at_warn
+    in_transaction do |txn|
+      with_java_classes_loaded do
+        bean = mock
+        bean.stubs(:isCurrentThreadCpuTimeSupported).returns(true)
+        bean.stubs(:getCurrentThreadUserTime).raises(StandardError, 'Error calculating JRuby CPU Time')
+        ::Java::JavaLangManagement::ManagementFactory.stubs(:getThreadMXBean).returns(bean)
+
+        expects_logging(:warn, includes("Error calculating JRuby CPU Time"), any_parameters)
+        txn.send(:jruby_cpu_time)
+        expects_no_logging(:warn)
+        txn.send(:jruby_cpu_time)
+      end
+    end
+  end
+
+  def test_jruby_cpu_time_always_logs_errors_at_debug
+    in_transaction do |txn|
+      with_java_classes_loaded do
+        bean = mock
+        bean.stubs(:isCurrentThreadCpuTimeSupported).returns(true)
+        bean.stubs(:getCurrentThreadUserTime).raises(StandardError, 'Error calculating JRuby CPU Time')
+        ::Java::JavaLangManagement::ManagementFactory.stubs(:getThreadMXBean).returns(bean)
+
+        expects_logging(:warn, includes("Error calculating JRuby CPU Time"), any_parameters)
+        txn.send(:jruby_cpu_time)
+        expects_logging(:debug, includes("Error calculating JRuby CPU Time"), any_parameters)
+        txn.send(:jruby_cpu_time)
+      end
+    end
+  end
+
+  def test_jruby_cpu_time_returns_nil_if_current_thread_user_time_raises
+    in_transaction do |txn|
+      with_java_classes_loaded do
+        bean = mock
+        bean.stubs(:isCurrentThreadCpuTimeSupported).returns(true)
+        bean.stubs(:getCurrentThreadUserTime).raises(StandardError, 'Error calculating JRuby CPU Time')
+        ::Java::JavaLangManagement::ManagementFactory.stubs(:getThreadMXBean).returns(bean)
+
+        assert_nil txn.send(:jruby_cpu_time)
+      end
+    end
+  end
+
+  def test_jruby_cpu_time_does_not_call_get_current_thread_user_time_if_unsupported
+    in_transaction do |txn|
+      with_java_classes_loaded do
+        bean = mock
+        bean.stubs(:isCurrentThreadCpuTimeSupported).returns(false)
+        ::Java::JavaLangManagement::ManagementFactory.stubs(:getThreadMXBean).returns(bean)
+        bean.expects(:getCurrentThreadUserTime).never
+
+        assert_nil txn.send(:jruby_cpu_time)
+      end
+    end
+  end
+
+  def with_java_classes_loaded
+    # class_variable_set is private on 1.8.7 :(
+    ::NewRelic::Agent::Transaction.send(:class_variable_set, :@@java_classes_loaded, true)
+    yield
+  ensure
+    ::NewRelic::Agent::Transaction.send(:class_variable_set, :@@java_classes_loaded, false)
+  end
+
   def test_cpu_burn_normal
     in_transaction do |txn|
       txn.expects(:normal_cpu_burn).twice.returns(1)
@@ -719,6 +817,16 @@ class NewRelic::Agent::TransactionTest < Minitest::Test
     assert_metrics_not_recorded(['Controller/sinatra', 'Controller/toddler', 'Controller/infant'])
   end
 
+  def test_nested_other_transaction
+    in_transaction('OtherTransaction/outer', :category => :task) do
+      in_transaction('OtherTransaction/inner', :category => :task) do
+      end
+    end
+
+    assert_metrics_recorded(['OtherTransaction/inner'])
+    assert_metrics_not_recorded(['OtherTransaction/outer'])
+  end
+
   def test_failure_during_ignore_error_filter_doesnt_prevent_transaction
     filter = Proc.new do |*_|
       raise "HAHAHAHAH, error in the filter for ignoring errors!"
@@ -784,6 +892,61 @@ class NewRelic::Agent::TransactionTest < Minitest::Test
     NewRelic::Agent::Transaction.stop(state)
   end
 
+  def test_user_defined_rules_ignore_returns_true_for_matched_uri
+    rule = 'ignored'
+    with_config(:rules => { :ignore_url_regexes => [rule] }) do
+      in_transaction do |txn|
+        txn.stubs(:uri).returns(rule + '/uri')
+        assert txn.user_defined_rules_ignore?, "URIs should be ignored based on user defined rules. Rule: '#{rule}', URI: '#{txn.uri}'."
+      end
+    end
+  end
+
+  def test_stop_ignores_transactions_from_ignored_uris
+    with_config(:rules => { :ignore_url_regexes => ['ignored/uri'] }) do
+      in_transaction do |txn|
+        txn.stubs(:uri).returns('ignored/uri')
+        txn.expects(:ignore!)
+      end
+    end
+  end
+
+  def test_transactions_are_not_ignored_if_rules_match_http_auth
+    with_config(:rules => { :ignore_url_regexes => ['ignored'] }) do
+      in_transaction do |txn|
+        txn.stubs(:uri).returns('http://ignored_user:ignored_pass@foo.com/bar/baz')
+        txn.expects(:ignore!).never
+      end
+    end
+  end
+
+  def test_transactions_are_not_ignored_if_rules_match_query_string
+    with_config(:rules => { :ignore_url_regexes => ['ignored'] }) do
+      in_transaction do |txn|
+        txn.stubs(:uri).returns('http://foo.com/bar/baz/?ignored=1')
+        txn.expects(:ignore!).never
+      end
+    end
+  end
+
+  def test_user_defined_rules_ignore_does_not_parse_the_uri_if_rules_are_empty
+    with_config(:rules => { :ignore_url_regexes => [] }) do
+      in_transaction do |txn|
+        txn.stubs(:uri).returns('http://foo.com/bar/baz')
+        NewRelic::Agent::HTTPClients::URIUtil.expects(:parse_url).never
+      end
+    end
+  end
+
+  def test_user_defined_rules_ignore_does_not_filter_the_uri_if_rules_are_empty
+    with_config(:rules => { :ignore_url_regexes => [] }) do
+      in_transaction do |txn|
+        txn.stubs(:uri).returns('http://foo.com/bar/baz')
+        NewRelic::Agent::HTTPClients::URIUtil.expects(:filter_uri).never
+      end
+    end
+  end
+
   def assert_has_custom_parameter(txn, key, value = key)
     assert_equal(value, txn.custom_parameters[key])
   end

data/test/new_relic/agent_test.rb

@@ -89,6 +89,18 @@ module NewRelic
       NewRelic::Agent.shutdown
     end
 
+    def test_manual_start_kicks_dependency_check_again
+      with_config(:monitor_mode => true, :license_key => "a" * 40, :sync_startup => true) do
+        NewRelic::Agent.manual_start
+        assert NewRelic::Agent.instance.started?
+
+        NewRelic::Control.instance.stubs(:init_config)
+        DependencyDetection.expects(:detect!).once
+
+        NewRelic::Agent.manual_start
+      end
+    end
+
     def test_get_stats
       agent = mocked_agent
       mock_stats_engine = mock('stats_engine')
@@ -266,7 +278,7 @@ module NewRelic
       Transactor.new.txn do
         NewRelic::Agent.set_transaction_name('new_name')
       end
-      assert engine.lookup_stats('Controller/new_name')
+      assert_metrics_recorded(['Controller/new_name'])
     end
 
     def test_get_transaction_name_returns_nil_outside_transaction

data/test/new_relic/fake_collector.rb

@@ -54,8 +54,8 @@ module NewRelic
 
     attr_accessor :agent_data, :mock
 
-    def initialize
-      super
+    def initialize(ssl=false)
+      super(DEFAULT_PORT, ssl)
       @id_counter = 0
       @mock = {
         'get_redirect_host'       => Response.new(200, {'return_value' => 'localhost'}),
@@ -109,7 +109,7 @@ module NewRelic
           status, body = @mock[method].evaluate
           res.status = status
           if format == :json
-            res.write JSON.dump(body)
+            res.write ::NewRelic::JSONWrapper.dump(body)
           else
             res.write Marshal.dump(body)
           end
@@ -125,7 +125,7 @@ module NewRelic
           raw_body = Zlib::Inflate.inflate(raw_body) if req.env["HTTP_CONTENT_ENCODING"] == "deflate"
 
           body = if format == :json
-            body = JSON.load(raw_body)
+            body = ::NewRelic::JSONWrapper.load(raw_body)
           else
             body = Marshal.load(raw_body)
 
@@ -162,7 +162,7 @@ module NewRelic
     end
 
     def calls_for(method)
-      @agent_data.select {|d| d.action == method }
+      @agent_data.select { |d| d.action == method.to_s }
     end
 
     def reported_stats_for_metric(name, scope=nil)

data/test/new_relic/fake_server.rb

@@ -22,13 +22,15 @@ module NewRelic
       :AccessLog => [ ['/dev/null', ''] ]
     }
 
-    CONFIG_PATH = File.join(File.dirname(__FILE__), "..", "config")
+    CONFIG_PATH        = File.join(File.dirname(__FILE__), "..", "config")
+    FAKE_SSL_CERT_PATH = File.join(CONFIG_PATH, "test.cert.crt")
+    FAKE_SSL_KEY_PATH  = File.join(CONFIG_PATH, "test.cert.key")
 
     SSL_OPTIONS = {
       :SSLEnable => true,
       :SSLVerifyClient => OpenSSL::SSL::VERIFY_NONE,
-      :SSLPrivateKey => OpenSSL::PKey::RSA.new(File.open(File.join(CONFIG_PATH, "test.cert.key")).read),
-      :SSLCertificate => OpenSSL::X509::Certificate.new(File.open(File.join(CONFIG_PATH, "test.cert.crt")).read),
+      :SSLPrivateKey => OpenSSL::PKey::RSA.new(File.read(FAKE_SSL_KEY_PATH)),
+      :SSLCertificate => OpenSSL::X509::Certificate.new(File.read(FAKE_SSL_CERT_PATH)),
       :SSLCertName => [["CN", "newrelic.com"]]
     }
 

data/test/new_relic/http_client_test_cases.rb

@@ -38,10 +38,6 @@ module HttpClientTestCases
 
   # Helpers to support shared tests
 
-  def use_ssl
-    @ssl = true
-  end
-
   def use_ssl?
     @ssl
   end

data/test/new_relic/marshalling_test_cases.rb

@@ -0,0 +1,54 @@
+# 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.
+
+# These tests are intended to exercise the basic marshalling functionality of
+# the agent in it's different permutations (Ruby and JSON)
+module MarshallingTestCases
+
+  def test_sends_metrics
+    NewRelic::Agent.record_metric('Boo', 42)
+
+    transmit_data
+
+    result = $collector.calls_for('metric_data')
+    assert_equal 1, result.length
+    assert_includes result.first.metric_names, 'Boo'
+  end
+
+  def test_sends_errors
+    NewRelic::Agent.notice_error(StandardError.new("Boom"))
+
+    transmit_data
+
+    result = $collector.calls_for('error_data')
+    assert_equal 1, result.length
+    assert_equal 1, result.first.errors.length
+    assert_equal "StandardError", result.first.errors.first.exception_class_name
+  end
+
+  def test_sends_transaction_traces
+    with_config(:'transaction_tracer.transaction_threshold' => -1.0) do
+      Transactioner.new.do_it
+    end
+
+    transmit_data
+
+    result = $collector.calls_for('transaction_sample_data')
+    assert_equal 1, result.length
+    assert_equal "Controller/MarshallingTestCases::Transactioner/do_it", result.first.metric_name
+  end
+
+  class Transactioner
+    include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+
+    def do_it
+    end
+
+    add_transaction_tracer :do_it
+  end
+
+  def transmit_data
+    NewRelic::Agent.instance.send(:transmit_data)
+  end
+end

data/test/new_relic/multiverse_helpers.rb

@@ -99,11 +99,11 @@ module MultiverseHelpers
   # This helps so the runner process can decide before spawning the child
   # whether we want the collector running or not.
 
-  def setup_collector
+  def setup_collector(use_ssl=false)
     return if omit_collector?
 
     require 'fake_collector'
-    $collector ||= NewRelic::FakeCollector.new
+    $collector ||= NewRelic::FakeCollector.new(use_ssl)
     $collector.reset
     $collector.run
 

data/test/new_relic/rack/browser_monitoring_test.rb

@@ -97,6 +97,12 @@ EOL
     assert !app.should_instrument?({NewRelic::Rack::BrowserMonitoring::ALREADY_INSTRUMENTED_KEY => true}, 200, {'Content-Type' => 'text/html'})
   end
 
+  def test_should_not_instrument_when_disabled_by_config
+    with_config(:'browser_monitoring.auto_instrument' => false) do
+      refute app.should_instrument?({}, 200, {'Content-Type' => 'text/html'})
+    end
+  end
+
   def test_insert_header_should_mark_environment
     get '/'
     assert last_request.env.key?(NewRelic::Rack::BrowserMonitoring::ALREADY_INSTRUMENTED_KEY)

data/test/new_relic/rack/developer_mode_test.rb

@@ -64,6 +64,14 @@ class DeveloperModeTest < Minitest::Test
     assert last_response.body.include?('Key Length')
     assert last_response.body.include?('Using index')
   end
+
+  def test_doesnt_record_transaction
+    NewRelic::Agent.instance.transaction_sampler.dev_mode_sample_buffer.reset!
+
+    get "/newrelic"
+
+    assert_empty NewRelic::Agent.instance.transaction_sampler.dev_mode_sample_buffer.samples
+  end
 end
 
 else

data/test/new_relic/rack/error_collector_test.rb

@@ -54,25 +54,6 @@ module NewRelic::Rack
              'noticed an error that should have been ignored')
     end
 
-    def test_handles_parameter_parsing_exceptions
-      if defined?(ActionDispatch::Request)
-        bad_request = stub.stubs(:filtered_params).raises(TypeError, "can't convert nil into Hash")
-        ActionDispatch::Request.stubs(:new).returns(bad_request)
-      else
-        bad_request = stub(:env => {}, :path => '/', :referer => '', :cookies => {})
-        bad_request.stubs(:params).raises(TypeError, "whatever, man")
-        Rack::Request.stubs(:new).returns(bad_request)
-      end
-
-      assert_raises RuntimeError do
-        get '/'
-      end
-
-      assert_equal('unhandled error', last_error.message)
-      assert_match(/failed to capture request parameters/i,
-                   last_error.params[:request_params]['error'])
-    end
-
     # Ideally we'd test this for failures to create Rack::Request as well,
     # but unfortunately rack-test, which we're using to drive, creates
     # Rack::Request objects internally, so there's not an easy way to.
@@ -89,28 +70,6 @@ module NewRelic::Rack
       end
     end
 
-    def test_captures_parameters_with_rails
-      assert_raises RuntimeError do
-        get '/?foo=bar&baz=qux'
-      end
-
-      expected_params = { 'foo' => 'bar', 'baz' => 'qux' }
-      assert_equal('unhandled error', last_error.message)
-      assert_equal(expected_params, last_error.params[:request_params])
-    end
-
-    def test_captures_parameters_without_rails
-      undefine_constant(:'ActionDispatch::Request') do
-        assert_raises RuntimeError do
-          get '/?foo=bar&baz=qux'
-        end
-      end
-
-      expected_params = { 'foo' => 'bar', 'baz' => 'qux' }
-      assert_equal('unhandled error', last_error.message)
-      assert_equal(expected_params, last_error.params[:request_params])
-    end
-
     def last_error
       NewRelic::Agent.instance.error_collector.errors[0]
     end