newrelic_rpm 3.8.1.221 → 3.9.0.229

data/test/new_relic/agent/cross_app_monitor_test.rb

@@ -33,19 +33,19 @@ module NewRelic::Agent
       NewRelic::Agent.instance.events.clear
       @response = {}
 
-      @monitor = NewRelic::Agent::CrossAppMonitor.new()
+      @monitor = NewRelic::Agent::CrossAppMonitor.new
       @config = {
-        :cross_process_id => AGENT_CROSS_APP_ID,
-        :encoding_key => ENCODING_KEY_NOOP,
+        :cross_process_id    => AGENT_CROSS_APP_ID,
+        :encoding_key        => ENCODING_KEY_NOOP,
         :trusted_account_ids => TRUSTED_ACCOUNT_IDS
       }
 
-      NewRelic::Agent.config.apply_config( @config )
+      NewRelic::Agent.config.add_config_for_testing(@config)
       @monitor.on_finished_configuring
     end
 
     def teardown
-      NewRelic::Agent.config.remove_config( @config )
+      NewRelic::Agent.config.remove_config(@config)
       NewRelic::Agent.instance.events.clear
     end
 
@@ -179,15 +179,33 @@ module NewRelic::Agent
     end
 
     def test_setting_response_headers_freezes_transaction_name
-      request = for_id(REQUEST_CROSS_APP_ID)
-      event_listener = NewRelic::Agent.instance.events
-      event_listener.notify(:before_call, request)
-
       in_transaction do
-        assert !NewRelic::Agent::Transaction.current.name_frozen?
+        request = for_id(REQUEST_CROSS_APP_ID)
+        event_listener = NewRelic::Agent.instance.events
+        event_listener.notify(:before_call, request)
+
+        assert !NewRelic::Agent::Transaction.tl_current.name_frozen?
         event_listener.notify(:after_call, request, [200, @response, ''])
-        assert NewRelic::Agent::Transaction.current.name_frozen?
+        assert NewRelic::Agent::Transaction.tl_current.name_frozen?
+      end
+    end
+
+    def test_listener_in_other_thread_has_correct_txn_state
+      t = Thread.new do
+        event_listener = NewRelic::Agent.instance.events
+        in_transaction('transaction') do
+          request = for_id(REQUEST_CROSS_APP_ID)
+
+          event_listener.notify(:before_call, request)
+          # Fake out our GUID for easier comparison in tests
+          NewRelic::Agent::Transaction.tl_current.stubs(:guid).returns(TRANSACTION_GUID)
+          event_listener.notify(:after_call, request, [200, @response, ''])
+        end
       end
+
+      t.join
+
+      assert_metrics_recorded(["ClientApplication/#{REQUEST_CROSS_APP_ID}/all"])
     end
 
     #
@@ -196,12 +214,12 @@ module NewRelic::Agent
 
     def when_request_runs(request=for_id(REQUEST_CROSS_APP_ID))
       event_listener = NewRelic::Agent.instance.events
-      event_listener.notify(:before_call, request)
       in_transaction('transaction') do
+        event_listener.notify(:before_call, request)
         # Fake out our GUID for easier comparison in tests
-        NewRelic::Agent::Transaction.current.stubs(:guid).returns(TRANSACTION_GUID)
+        NewRelic::Agent::Transaction.tl_current.stubs(:guid).returns(TRANSACTION_GUID)
+        event_listener.notify(:after_call, request, [200, @response, ''])
       end
-      event_listener.notify(:after_call, request, [200, @response, ''])
     end
 
     def when_request_has_error(request=for_id(REQUEST_CROSS_APP_ID))

data/test/new_relic/agent/cross_app_tracing_test.rb

@@ -26,7 +26,7 @@ module NewRelic
       end
 
       def test_start_trace_has_time_even_on_agent_failure
-        NewRelic::Agent::TracedMethodStack.stubs(:push_frame).raises("Boom!")
+        NewRelic::Agent::TracedMethodStack.stubs(:tl_push_frame).raises("Boom!")
         t0, segment = CrossAppTracing.start_trace(request)
         refute_nil t0
         assert_nil segment
@@ -54,7 +54,7 @@ module NewRelic
 
 
       def expects_pop_frame
-        NewRelic::Agent::TracedMethodStack.stubs(:pop_frame).once
+        NewRelic::Agent::TracedMethodStack.stubs(:tl_pop_frame).once
       end
     end
   end

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

@@ -85,29 +85,6 @@ class NewRelic::Agent::ErrorCollector::NoticeErrorTest < Minitest::Test
     end
   end
 
-  def test_extract_source_base
-    with_config(:'error_collector.capture_source' => true) do
-      error_collector = NewRelic::Agent::ErrorCollector.new
-      error_collector.expects(:sense_method).with(nil, 'source_extract')
-      assert_equal(nil, error_collector.extract_source(nil))
-    end
-  end
-
-  def test_extract_source_disabled
-    with_config(:'error_collector.capture_source' => false) do
-      error_collector = NewRelic::Agent::ErrorCollector.new
-      assert_equal(nil, error_collector.extract_source(mock('exception')))
-    end
-  end
-
-  def test_extract_source_with_source
-    with_config(:'error_collector.capture_source' => true) do
-      error_collector = NewRelic::Agent::ErrorCollector.new
-      error_collector.expects(:sense_method).with('happy', 'source_extract').returns('THE SOURCE')
-      assert_equal('THE SOURCE', error_collector.extract_source('happy'))
-    end
-  end
-
   def test_extract_stack_trace
     exception = mock('exception')
     self.expects(:sense_method).with(exception, 'original_exception')
@@ -138,9 +115,8 @@ class NewRelic::Agent::ErrorCollector::NoticeErrorTest < Minitest::Test
     exception = mock('exception')
     self.expects(:sense_method).with(exception, 'file_name').returns('file_name')
     self.expects(:sense_method).with(exception, 'line_number').returns('line_number')
-    self.expects(:extract_source).with(exception).returns('source')
     self.expects(:extract_stack_trace).with(exception).returns('stack_trace')
-    assert_equal({:file_name => 'file_name', :line_number => 'line_number', :source => 'source', :stack_trace => 'stack_trace'},
+    assert_equal({:file_name => 'file_name', :line_number => 'line_number', :stack_trace => 'stack_trace'},
                  exception_info(exception))
   end
 
@@ -164,34 +140,34 @@ class NewRelic::Agent::ErrorCollector::NoticeErrorTest < Minitest::Test
     assert_equal([], @errors)
   end
 
-  def test_should_exit_notice_error_disabled
+  def test_skip_notice_error_is_true_if_the_error_collector_is_disabled
     error = mocked_error
     with_error_collector_config(:'error_collector.enabled' => false) do |error_collector|
-      assert error_collector.should_exit_notice_error?(error)
+      assert error_collector.skip_notice_error?(error)
     end
   end
 
-  def test_should_exit_notice_error_nil
+  def test_skip_notice_error_is_true_if_the_error_is_nil
     error = nil
     with_error_collector_config(:'error_collector.enabled' => true) do |error_collector|
       error_collector.expects(:error_is_ignored?).with(error).returns(false)
-      assert error_collector.should_exit_notice_error?(error)
+      assert error_collector.skip_notice_error?(error)
     end
   end
 
-  def test_should_exit_notice_error_positive
+  def test_skip_notice_error_is_true_if_the_error_is_ignored
     error = mocked_error
     with_error_collector_config(:'error_collector.enabled' => true) do |error_collector|
       error_collector.expects(:error_is_ignored?).with(error).returns(true)
-      assert error_collector.should_exit_notice_error?(error)
+      assert error_collector.skip_notice_error?(error)
     end
   end
 
-  def test_should_exit_notice_error_negative
+  def test_skip_notice_error_returns_false_for_non_nil_unignored_errors_with_an_enabled_error_collector
     error = mocked_error
     with_error_collector_config(:'error_collector.enabled' => true) do |error_collector|
       error_collector.expects(:error_is_ignored?).with(error).returns(false)
-      assert !error_collector.should_exit_notice_error?(error)
+      assert !error_collector.skip_notice_error?(error)
     end
   end
 

data/test/new_relic/agent/error_collector_test.rb

@@ -9,19 +9,19 @@ require 'new_relic/agent/internal_agent_error'
 class NewRelic::Agent::ErrorCollectorTest < Minitest::Test
   def setup
     @test_config = { :capture_params => true }
-    NewRelic::Agent.config.apply_config(@test_config)
+    NewRelic::Agent.config.add_config_for_testing(@test_config)
 
     @error_collector = NewRelic::Agent::ErrorCollector.new
     @error_collector.stubs(:enabled).returns(true)
 
-    NewRelic::Agent::TransactionState.clear
+    NewRelic::Agent::TransactionState.tl_clear_for_testing
     NewRelic::Agent.instance.stats_engine.reset!
   end
 
   def teardown
     super
-    NewRelic::Agent::TransactionState.clear
-    NewRelic::Agent.config.remove_config(@test_config)
+    NewRelic::Agent::TransactionState.tl_clear_for_testing
+    NewRelic::Agent.config.reset_to_defaults
   end
 
   # Helpers for DataContainerTests
@@ -57,7 +57,6 @@ class NewRelic::Agent::ErrorCollectorTest < Minitest::Test
     assert_equal '', err.params[:request_referer]
     assert_equal 'path', err.path
     assert_equal 'Error', err.exception_class_name
-    assert_equal String, err.exception_class_constant
   end
 
   def test_simple
@@ -73,7 +72,6 @@ class NewRelic::Agent::ErrorCollectorTest < Minitest::Test
     assert_equal '/myurl/', err.params[:request_uri]
     assert_equal 'test_referer', err.params[:request_referer]
     assert_equal 'path', err.path
-    assert_equal StandardError, err.exception_class_constant
     assert_equal 'StandardError', err.exception_class_name
 
     # the collector should now return an empty array since nothing
@@ -175,7 +173,7 @@ class NewRelic::Agent::ErrorCollectorTest < Minitest::Test
   def test_exclude_later_config_changes
     @error_collector.notice_error(IOError.new("message"))
 
-    NewRelic::Agent.config.apply_config(:'error_collector.ignore_errors' => "IOError")
+    NewRelic::Agent.config.add_config_for_testing(:'error_collector.ignore_errors' => "IOError")
     @error_collector.notice_error(IOError.new("message"))
 
     errors = @error_collector.harvest!
@@ -195,6 +193,18 @@ class NewRelic::Agent::ErrorCollectorTest < Minitest::Test
     assert_equal 1, errors.length
   end
 
+  def test_failure_in_exclude_block
+    @error_collector.ignore_error_filter do
+      raise "HAHAHAHAH, error in the filter for ignoring errors!"
+    end
+
+    @error_collector.notice_error(StandardError.new("message"))
+
+    errors = @error_collector.harvest!
+
+    assert_equal 1, errors.length
+  end
+
   def test_obfuscates_error_messages_when_high_security_is_set
     with_config(:high_security => true) do
       @error_collector.notice_error(StandardError.new("YO SQL BAD: serect * flom test where foo = 'bar'"))
@@ -296,7 +306,7 @@ class NewRelic::Agent::ErrorCollectorTest < Minitest::Test
     @error_collector.notice_agent_error(exception)
 
     assert_equal 21, @error_collector.errors.size
-    assert_equal DifficultToDebugAgentError, @error_collector.errors.last.exception_class_constant
+    assert_equal DifficultToDebugAgentError.name, @error_collector.errors.last.exception_class_name
   end
 
   def test_notice_agent_error_doesnt_clog_up_the_queue_limit
@@ -317,17 +327,38 @@ class NewRelic::Agent::ErrorCollectorTest < Minitest::Test
     assert err.message.include?("Ruby agent internal error")
   end
 
-  def test_blamed_metric_from_options
-    assert_equal "Errors/boo", @error_collector.blamed_metric_name(:metric => "boo")
+  def test_blamed_metric_from_options_outside_txn
+    @error_collector.notice_error(StandardError.new('wut'), :metric => 'boo')
+    assert_metrics_recorded(
+      'Errors/boo' => { :call_count => 1}
+    )
+  end
+
+  def test_blamed_metric_from_options_inside_txn
+    in_transaction('Not/What/Youre/Looking/For') do
+      @error_collector.notice_error(StandardError.new('wut'), :metric => 'boo')
+    end
+    assert_metrics_recorded_exclusive(
+      {
+        'Errors/all' => { :call_count => 1 },
+        'Errors/boo' => { :call_count => 1 }
+      },
+      :filter => /^Errors\//
+    )
   end
 
   def test_blamed_metric_from_transaction
-    NewRelic::Agent::TransactionState.get.most_recent_transaction = stub(:name => "Controller/foo/bar")
-    assert_equal "Errors/Controller/foo/bar", @error_collector.blamed_metric_name({})
+    in_transaction('Controller/foo/bar') do
+      @error_collector.notice_error(StandardError.new('wut'))
+    end
+    assert_metrics_recorded(
+      'Errors/Controller/foo/bar' => { :call_count => 1 }
+    )
   end
 
-  def test_blamed_metric_with_no_transaction
-    assert_nil @error_collector.blamed_metric_name({})
+  def test_blamed_metric_with_no_transaction_and_no_options
+    @error_collector.notice_error(StandardError.new('wut'))
+    assert_metrics_recorded_exclusive(['Errors/all'])
   end
 
   private

data/test/new_relic/agent/harvester_test.rb

@@ -64,6 +64,15 @@ module NewRelic
         end
       end
 
+      def test_doesnt_call_to_restart_if_harvest_thread_disabled
+        pretend_started_in_another_process
+        @after_forker.expects(:after_fork).never
+
+        with_config(:disable_harvest_thread => true) do
+          harvester.on_transaction
+        end
+      end
+
       def test_calls_to_restart_only_once
         pretend_started_in_another_process
         @after_forker.expects(:after_fork).once

data/test/new_relic/agent/hostname_test.rb

@@ -0,0 +1,41 @@
+# 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 File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+require 'new_relic/agent/hostname'
+
+module NewRelic
+  module Agent
+    class HostnameTest < MiniTest::Unit::TestCase
+      def test_get_returns_socket_hostname
+        Socket.stubs(:gethostname).returns('Rivendell')
+        assert_equal 'Rivendell', NewRelic::Agent::Hostname.get
+      end
+
+      def test_get_uses_dyno_name_if_dyno_env_set_and_dyno_names_enabled
+        with_config(:use_heroku_dyno_names => true) do
+          Socket.stubs(:gethostname).returns('Rivendell')
+          ENV['DYNO'] = 'Imladris'
+
+          expected = 'Imladris'
+          assert_equal expected, NewRelic::Agent::Hostname.get
+        end
+      ensure
+        ENV.delete('DYNO')
+      end
+
+      def test_get_uses_socket_gethostname_if_dyno_env_set_and_dyno_names_disabled
+        with_config(:use_heroku_dyno_names => false) do
+          Socket.stubs(:gethostname).returns('Rivendell')
+          ENV['DYNO'] = 'Imladris'
+
+          expected = 'Rivendell'
+          assert_equal expected, NewRelic::Agent::Hostname.get
+        end
+      ensure
+        ENV.delete('DYNO')
+      end
+    end
+  end
+end

data/test/new_relic/agent/instrumentation/action_controller_subscriber_test.rb

@@ -41,7 +41,7 @@ class NewRelic::Agent::Instrumentation::ActionControllerSubscriberTest < Minites
     @stats_engine = NewRelic::Agent.instance.stats_engine
     @stats_engine.clear_stats
     NewRelic::Agent.manual_start
-    NewRelic::Agent::TransactionState.clear
+    NewRelic::Agent::TransactionState.tl_clear_for_testing
   end
 
   def teardown
@@ -76,7 +76,11 @@ class NewRelic::Agent::Instrumentation::ActionControllerSubscriberTest < Minites
   def test_record_apdex_metrics_with_error
     @subscriber.start('process_action.action_controller', :id, @entry_payload)
     advance_time(1.5)
-    @exit_payload[:exception] = StandardError.new("boo")
+
+    error = StandardError.new("boo")
+    @exit_payload[:exception] = error
+    NewRelic::Agent.notice_error(error)
+
     @subscriber.finish('process_action.action_controller', :id, @exit_payload)
 
     expected_values = { :apdex_f => 1, :apdex_t => 0, :apdex_s => 0 }
@@ -117,14 +121,14 @@ class NewRelic::Agent::Instrumentation::ActionControllerSubscriberTest < Minites
 
   def test_sets_default_transaction_name_on_start
     @subscriber.start('process_action.action_controller', :id, @entry_payload)
-    assert_equal 'Controller/test/index', NewRelic::Agent::Transaction.current.best_name
+    assert_equal 'Controller/test/index', NewRelic::Agent::Transaction.tl_current.best_name
   ensure
     @subscriber.finish('process_action.action_controller', :id, @entry_payload)
   end
 
   def test_sets_default_transaction_keeps_name_through_stop
     @subscriber.start('process_action.action_controller', :id, @entry_payload)
-    txn = NewRelic::Agent::Transaction.current
+    txn = NewRelic::Agent::Transaction.tl_current
     @subscriber.finish('process_action.action_controller', :id, @entry_payload)
     assert_equal 'Controller/test/index', txn.best_name
   end
@@ -132,14 +136,14 @@ class NewRelic::Agent::Instrumentation::ActionControllerSubscriberTest < Minites
   def test_sets_transaction_name
     @subscriber.start('process_action.action_controller', :id, @entry_payload)
     NewRelic::Agent.set_transaction_name('something/else')
-    assert_equal 'Controller/something/else', NewRelic::Agent::Transaction.current.best_name
+    assert_equal 'Controller/something/else', NewRelic::Agent::Transaction.tl_current.best_name
   ensure
     @subscriber.finish('process_action.action_controller', :id, @entry_payload)
   end
 
   def test_sets_transaction_name_holds_through_stop
     @subscriber.start('process_action.action_controller', :id, @entry_payload)
-    txn = NewRelic::Agent::Transaction.current
+    txn = NewRelic::Agent::Transaction.tl_current
     NewRelic::Agent.set_transaction_name('something/else')
     @subscriber.finish('process_action.action_controller', :id, @entry_payload)
     assert_equal 'Controller/something/else', txn.best_name
@@ -173,9 +177,10 @@ class NewRelic::Agent::Instrumentation::ActionControllerSubscriberTest < Minites
     @entry_payload[:action] = 'ignored_enduser'
     @exit_payload[:action] = 'ignored_enduser'
     @subscriber.start('process_action.action_controller', :id, @entry_payload)
+    txn = NewRelic::Agent::Transaction.tl_current
     @subscriber.finish('process_action.action_controller', :id, @exit_payload)
 
-    assert NewRelic::Agent::TransactionState.get.request_ignore_enduser
+    assert txn.ignore_enduser?
   end
 
   def test_record_busy_time
@@ -217,13 +222,15 @@ class NewRelic::Agent::Instrumentation::ActionControllerSubscriberTest < Minites
   end
 
   def test_record_queue_time_metrics
+    app = lambda do |env|
+      @subscriber.start('process_action.action_controller', :id, @entry_payload)
+      advance_time(2)
+      @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+    end
+
     t0 = Time.now
     env = { 'HTTP_X_REQUEST_START' => (t0 - 5).to_f.to_s }
-    NewRelic::Agent.instance.events.notify(:before_call, env)
-
-    @subscriber.start('process_action.action_controller', :id, @entry_payload)
-    advance_time(2)
-    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+    ::NewRelic::Rack::AgentHooks.new(app).call(env)
 
     assert_metrics_recorded(
       'WebFrontend/QueueTime' => {
@@ -241,15 +248,16 @@ class NewRelic::Agent::Instrumentation::ActionControllerSubscriberTest < Minites
   end
 
   def test_dont_record_queue_time_in_nested_transaction
-    t0 = Time.now
+    app = lambda do |env|
+      @subscriber.start('process_action.action_controller',  :id, @entry_payload)
+      @subscriber.start('process_action.action_controller',  :id, @entry_payload)
+      @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+      @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+    end
 
+    t0 = Time.now
     env = { 'HTTP_X_REQUEST_START' => (t0 - 5).to_f.to_s }
-    NewRelic::Agent.instance.events.notify(:before_call, env)
-
-    @subscriber.start('process_action.action_controller', :id, @entry_payload)
-    @subscriber.start('process_action.action_controller', :id, @entry_payload)
-    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
-    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+    ::NewRelic::Rack::AgentHooks.new(app).call(env)
 
     assert_metrics_recorded(
       'WebFrontend/QueueTime' => {