newrelic_rpm 3.7.3.204 → 3.8.0.218

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

@@ -7,6 +7,11 @@ class NewRelic::Agent::Agent::StartTest < Minitest::Test
   require 'new_relic/agent/agent'
   include NewRelic::Agent::Agent::Start
 
+  def setup
+    @harvester = stub("dummy harvester")
+    @harvest_samplers = stub("dummy sampler collection")
+  end
+
   def test_already_started_positive
     dummy_logger = mock
     dummy_logger.expects(:error).with("Agent Started Already!")
@@ -51,7 +56,8 @@ class NewRelic::Agent::Agent::StartTest < Minitest::Test
   end
 
   def test_check_config_and_start_agent_normal
-
+    @harvester.expects(:mark_started)
+    @harvest_samplers.expects(:load_samplers)
     self.expects(:generate_environment_report)
     self.expects(:start_worker_thread)
     self.expects(:install_exit_handler)
@@ -61,6 +67,8 @@ class NewRelic::Agent::Agent::StartTest < Minitest::Test
   end
 
   def test_check_config_and_start_agent_sync
+    @harvester.expects(:mark_started)
+    @harvest_samplers.expects(:load_samplers)
     self.expects(:generate_environment_report)
     self.expects(:connect_in_foreground)
     self.expects(:start_worker_thread)

data/test/new_relic/agent/agent_logger_test.rb

@@ -228,6 +228,27 @@ class AgentLoggerTest < Minitest::Test
                   /INFO : Debugging backtrace:\n.*wiggle\s+wobble\s+topple/)
   end
 
+  def recursion_is_an_antipattern
+    recursion_is_an_antipattern
+  end
+
+  def test_log_exception_gets_backtrace_for_system_stack_error
+    # This facility compensates for poor SystemStackError traces on MRI.
+    # JRuby and Rubinius raise errors with good backtraces, so skip this test.
+    return if jruby? || rubinius?
+
+    logger = create_basic_logger
+
+    begin
+      recursion_is_an_antipattern
+    rescue SystemStackError => e
+      logger.log_exception(:error, e)
+    end
+
+    assert_logged(/ERROR : /,
+                  /ERROR : Debugging backtrace:\n.*#{__method__}/)
+  end
+
   def test_logs_to_stdout_if_fails_on_file
     Logger::LogDevice.any_instance.stubs(:open).raises(Errno::EACCES)
 
@@ -289,9 +310,9 @@ class AgentLoggerTest < Minitest::Test
   end
 
   def assert_logged(*args)
-    assert_equal(args.length, logged_lines.length)
+    assert_equal(args.length, logged_lines.length, "Unexpected log length #{logged_lines}")
     logged_lines.each_with_index do |line, index|
-      assert_match(args[index], line)
+      assert_match(args[index], line, "Missing match for #{args[index]}")
     end
   end
 end

data/test/new_relic/agent/agent_test.rb

@@ -15,6 +15,13 @@ module NewRelic
         @agent.service = default_service
         @agent.agent_command_router.stubs(:new_relic_service).returns(@agent.service)
         @agent.stubs(:start_worker_thread)
+
+        @config = { :license_key => "a" * 40 }
+        NewRelic::Agent.config.apply_config(@config)
+      end
+
+      def teardown
+        NewRelic::Agent.config.remove_config(@config)
       end
 
       def test_after_fork_reporting_to_channel
@@ -27,9 +34,11 @@ module NewRelic
       end
 
       def test_after_fork_reporting_to_channel_should_not_collect_environment_report
-        @agent.stubs(:connected?).returns(true)
-        @agent.expects(:generate_environment_report).never
-        @agent.after_fork(:report_to_channel => 123)
+        with_config(:monitor_mode => true) do
+          @agent.stubs(:connected?).returns(true)
+          @agent.expects(:generate_environment_report).never
+          @agent.after_fork(:report_to_channel => 123)
+        end
       end
 
       def test_after_fork_should_close_pipe_if_parent_not_connected
@@ -70,6 +79,24 @@ module NewRelic
         end
       end
 
+      def test_after_fork_should_mark_as_started
+        with_config(:monitor_mode => true) do
+          refute @agent.started?
+          @agent.after_fork
+          assert @agent.started?
+        end
+      end
+
+      def test_after_fork_should_prevent_further_thread_restart_attempts
+        with_config(:monitor_mode => true) do
+          # Disconnecting will tell us not to restart the thread
+          @agent.disconnect
+          @agent.after_fork
+
+          refute @agent.harvester.needs_restart?
+        end
+      end
+
       def test_transmit_data_should_emit_before_harvest_event
         got_it = false
         @agent.events.subscribe(:before_harvest) { got_it = true }
@@ -273,12 +300,28 @@ module NewRelic
         @agent.send(:connect, :force_reconnect => true)
       end
 
+      def test_connect_settings
+        settings = @agent.connect_settings
+        assert settings.include?(:pid)
+        assert settings.include?(:host)
+        assert settings.include?(:app_name)
+        assert settings.include?(:language)
+        assert settings.include?(:agent_version)
+        assert settings.include?(:environment)
+        assert settings.include?(:settings)
+      end
+
+      def test_connect_settings_checks_environment_report_can_marshal
+        @agent.service.stubs(:valid_to_marshal?).returns(false)
+        assert_equal [], @agent.connect_settings[:environment]
+      end
+
       def test_defer_start_if_resque_dispatcher_and_channel_manager_isnt_started_and_forkable
         NewRelic::LanguageSupport.stubs(:can_fork?).returns(true)
         NewRelic::Agent::PipeChannelManager.listener.stubs(:started?).returns(false)
 
         # :send_data_on_exit setting to avoid setting an at_exit
-        with_config( :send_data_on_exit => false, :dispatcher => :resque ) do
+        with_config( :monitor_mode => true, :send_data_on_exit => false, :dispatcher => :resque ) do
           @agent.start
         end
 
@@ -288,8 +331,7 @@ module NewRelic
       def test_doesnt_defer_start_if_resque_dispatcher_and_channel_manager_started
         NewRelic::Agent::PipeChannelManager.listener.stubs(:started?).returns(true)
 
-        # :send_data_on_exit setting to avoid setting an at_exit
-        with_config( :send_data_on_exit => false, :dispatcher => :resque ) do
+        with_config( :monitor_mode => true, :send_data_on_exit => false, :dispatcher => :resque ) do
           @agent.start
         end
 
@@ -301,7 +343,7 @@ module NewRelic
         NewRelic::Agent::PipeChannelManager.listener.stubs(:started?).returns(false)
 
         # :send_data_on_exit setting to avoid setting an at_exit
-        with_config( :send_data_on_exit => false, :dispatcher => :resque ) do
+        with_config( :monitor_mode => true, :send_data_on_exit => false, :dispatcher => :resque ) do
           @agent.start
         end
 

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

@@ -257,6 +257,14 @@ module NewRelic::Agent::Configuration
       @manager.remove_config(config)
     end
 
+    def test_config_stack_index_for
+      assert_equal 0, @manager.config_stack_index_for(EnvironmentSource)
+      assert_equal 1, @manager.config_stack_index_for(DefaultSource)
+      assert_equal nil, @manager.config_stack_index_for(ManualSource)
+      assert_equal nil, @manager.config_stack_index_for(ServerSource)
+      assert_equal nil, @manager.config_stack_index_for(YamlSource)
+    end
+
     class TestSource < ::Hash
       def test_config_accessor
         'some value'

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

@@ -57,6 +57,13 @@ class OrphanedConfigTest < Minitest::Test
       end
     end
 
+    # Remove any config keys that are annotated with the 'dynamic_name' setting
+    # This indicates that the names of these keys are constructed dynamically at
+    # runtime, so we don't expect any explicit references to them in code.
+    @default_keys.delete_if do |key_name|
+      NewRelic::Agent::Configuration::DEFAULTS[key_name][:dynamic_name]
+    end
+
     assert_empty @default_keys
   end
 

data/test/new_relic/agent/cross_app_monitor_test.rb

@@ -29,6 +29,7 @@ module NewRelic::Agent
 
     def setup
       NewRelic::Agent.reset_config
+      NewRelic::Agent.instance.stats_engine.clear_stats
       NewRelic::Agent.instance.events.clear
       @response = {}
 
@@ -164,19 +165,17 @@ module NewRelic::Agent
     def test_writes_metric
       with_default_timings
 
-      expected_metric_name = "ClientApplication/#{REQUEST_CROSS_APP_ID}/all"
-      NewRelic::Agent.instance.stats_engine.expects(:record_metrics). \
-        with(expected_metric_name, APP_TIME)
-
       when_request_runs
+
+      assert_metrics_recorded(["ClientApplication/#{REQUEST_CROSS_APP_ID}/all"])
     end
 
     def test_doesnt_write_metric_if_id_blank
       with_default_timings
 
-      NewRelic::Agent.instance.stats_engine.expects(:record_metrics).never
-
       when_request_runs(for_id(''))
+
+      assert_metrics_recorded_exclusive([])
     end
 
     def test_setting_response_headers_freezes_transaction_name

data/test/new_relic/agent/harvester_test.rb

@@ -10,11 +10,16 @@ module NewRelic
     class HarvesterTest < Minitest::Test
 
       attr_reader :harvester
+
       def setup
         @after_forker = stub_everything
         @harvester = Harvester.new(nil, @after_forker)
       end
 
+      def test_doesnt_mark_started_process_on_initialize
+        assert_nil harvester.starting_pid
+      end
+
       def test_marks_started_in_process
         pretend_started_in_another_process
 
@@ -34,27 +39,27 @@ module NewRelic
         end
       end
 
-      def test_doesnt_call_to_restart_by_default
+      def test_calls_to_restart_by_default
         pretend_started_in_another_process
-        @after_forker.expects(:after_fork).never
+        @after_forker.expects(:after_fork).once
 
         harvester.on_transaction
       end
 
-      def test_doesnt_call_to_restart_if_explicitly_disabled
+      def test_calls_to_restart_if_explicitly_enabled
         pretend_started_in_another_process
-        @after_forker.expects(:after_fork).never
+        @after_forker.expects(:after_fork).once
 
-        with_config(:restart_thread_in_children => false) do
+        with_config(:restart_thread_in_children => true) do
           harvester.on_transaction
         end
       end
 
-      def test_calls_to_restart
+      def test_doesnt_call_to_restart_if_explicitly_disabled
         pretend_started_in_another_process
-        @after_forker.expects(:after_fork).once
+        @after_forker.expects(:after_fork).never
 
-        with_config(:restart_thread_in_children => true) do
+        with_config(:restart_thread_in_children => false) do
           harvester.on_transaction
         end
       end

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

@@ -204,25 +204,46 @@ class NewRelic::Agent::Instrumentation::ActionControllerSubscriberTest < Minites
   end
 
   def test_record_queue_time_metrics
-    t0 = Time.now
-    Time.stubs(:now).returns(t0)
+    t0 = freeze_time
     env = { 'HTTP_X_REQUEST_START' => (t0 - 5).to_f.to_s }
     NewRelic::Agent.instance.events.notify(:before_call, env)
 
-    Time.stubs(:now).returns(t0, t0 + 2)
     @subscriber.start('process_action.action_controller', :id, @entry_payload)
+    advance_time(2)
     @subscriber.finish('process_action.action_controller', :id, @exit_payload)
 
-    metric = @stats_engine.lookup_stats('WebFrontend/QueueTime')
-    assert_equal 1, metric.call_count
-    assert_in_delta(5.0, metric.total_call_time, 0.1)
+    assert_metrics_recorded(
+      'WebFrontend/QueueTime' => {
+        :call_count => 1,
+        :total_call_time => 5.0
+      }
+    )
   end
 
   def test_dont_record_queue_time_if_no_header
     @subscriber.start('process_action.action_controller', :id, @entry_payload)
     @subscriber.finish('process_action.action_controller', :id, @exit_payload)
 
-    assert_nil @stats_engine.lookup_stats('WebFrontend/QueueTime')
+    assert_metrics_not_recorded('WebFrontend/QueueTime')
+  end
+
+  def test_dont_record_queue_time_in_nested_transaction
+    t0 = freeze_time
+
+    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)
+
+    assert_metrics_recorded(
+      'WebFrontend/QueueTime' => {
+        :call_count => 1,
+        :total_call_time => 5.0
+      }
+    )
   end
 
   def test_records_request_params_in_txn

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

@@ -23,36 +23,47 @@ class NewRelic::Agent::Instrumentation::ControllerInstrumentationTest < Minitest
 
   def setup
     @object = TestObject.new
+    @dummy_headers = { :request => 'headers' }
     @txn_namer = NewRelic::Agent::Instrumentation:: \
       ControllerInstrumentation::TransactionNamer.new(@object)
   end
 
-  def test_detect_upstream_wait_basic
-    start_time = Time.now
-    # should return the start time above by default
-    @object.expects(:newrelic_request_headers).returns({:request => 'headers'}).twice
-    NewRelic::Agent::Instrumentation::QueueTime.expects(:parse_frontend_timestamp) \
-      .with({:request => 'headers'}, start_time).returns(start_time)
-    assert_equal(start_time, @object.send(:_detect_upstream_wait, start_time))
+  def test_detect_upstream_wait_returns_transaction_start_time_if_nothing_from_headers
+    @object.stubs(:newrelic_request_headers).returns(@dummy_headers)
+    in_transaction do |txn|
+      NewRelic::Agent::Instrumentation::QueueTime.expects(:parse_frontend_timestamp) \
+        .with(@dummy_headers, txn.start_time).returns(txn.start_time)
+      assert_equal(txn.start_time, @object.send(:_detect_upstream_wait, txn))
+    end
   end
 
-  def test_detect_upstream_wait_with_upstream
-    start_time = Time.now
-    runs_at = start_time + 1
-    @object = TestObject.new
-    @object.expects(:newrelic_request_headers).returns(true).twice
-    NewRelic::Agent::Instrumentation::QueueTime.expects(:parse_frontend_timestamp) \
-      .with(true, runs_at).returns(start_time)
-    assert_equal(start_time, @object.send(:_detect_upstream_wait, runs_at))
+  def test_detect_upstream_wait_returns_parsed_timestamp_from_headers
+    @object.stubs(:newrelic_request_headers).returns(@dummy_headers)
+    in_transaction do |txn|
+      earlier_time = txn.start_time - 1
+      NewRelic::Agent::Instrumentation::QueueTime.expects(:parse_frontend_timestamp) \
+        .with(@dummy_headers, txn.start_time).returns(earlier_time)
+      assert_equal(earlier_time, @object.send(:_detect_upstream_wait, txn))
+    end
   end
 
   def test_detect_upstream_wait_swallows_errors
-    start_time = Time.now
-    # should return the start time above when an error is raised
-    @object.expects(:newrelic_request_headers).returns({:request => 'headers'}).twice
-    NewRelic::Agent::Instrumentation::QueueTime.expects(:parse_frontend_timestamp) \
-      .with({:request => 'headers'}, start_time).raises("an error")
-    assert_equal(start_time, @object.send(:_detect_upstream_wait, start_time))
+    @object.stubs(:newrelic_request_headers).returns(@dummy_headers)
+    in_transaction do |txn|
+      NewRelic::Agent::Instrumentation::QueueTime.expects(:parse_frontend_timestamp) \
+        .with(@dummy_headers, txn.start_time).raises("an error")
+      assert_equal(txn.start_time, @object.send(:_detect_upstream_wait, txn))
+    end
+  end
+
+  def test_detect_upsteam_wait_does_not_parse_timestamp_in_nested_transaction
+    @object.stubs(:newrelic_request_headers).returns(@dummy_headers)
+    in_transaction do |outer|
+      in_transaction do |inner|
+        NewRelic::Agent::Instrumentation::QueueTime.expects(:parse_frontend_timestamp).never
+        assert_equal(inner.start_time, @object.send(:_detect_upstream_wait, inner))
+      end
+    end
   end
 
   def test_transaction_name_calls_newrelic_metric_path

data/test/new_relic/agent/new_relic_service_test.rb

@@ -589,6 +589,20 @@ class NewRelicServiceTest < Minitest::Test
     assert_equal(spec1, metric_data.metric_spec)
   end
 
+  def test_valid_to_marshal
+    assert @service.valid_to_marshal?({})
+  end
+
+  def test_not_valid_to_marshal
+    @service.marshaller.stubs(:dump).raises(StandardError.new("Failed to marshal"))
+    refute @service.valid_to_marshal?({})
+  end
+
+  def test_not_valid_to_marshal_with_system_stack_error
+    @service.marshaller.stubs(:dump).raises(SystemStackError.new)
+    refute @service.valid_to_marshal?({})
+  end
+
   def build_stats_hash(items={})
     hash = NewRelic::Agent::StatsHash.new
     items.each do |key, value|

data/test/new_relic/agent/request_sampler_test.rb

@@ -90,7 +90,7 @@ class NewRelic::Agent::RequestSamplerTest < Minitest::Test
     stats_hash.record(NewRelic::MetricSpec.new('WebFrontend/QueueTime'), 13)
     stats_hash.record(NewRelic::MetricSpec.new('External/allWeb'), 14)
     stats_hash.record(NewRelic::MetricSpec.new('Datastore/all'), 15)
-    stats_hash.record(NewRelic::MetricSpec.new("GC/cumulative"), 16)
+    stats_hash.record(NewRelic::MetricSpec.new("GC/Transaction/all"), 16)
     stats_hash.record(NewRelic::MetricSpec.new('Memcache/allWeb'), 17)
 
     with_sampler_config do
@@ -111,7 +111,8 @@ class NewRelic::Agent::RequestSamplerTest < Minitest::Test
     stats_hash = NewRelic::Agent::StatsHash.new
     stats_hash.record(NewRelic::MetricSpec.new('External/allOther'), 12)
     stats_hash.record(NewRelic::MetricSpec.new('Datastore/all'), 13)
-    stats_hash.record(NewRelic::MetricSpec.new('Memcache/allOther'), 14)
+    stats_hash.record(NewRelic::MetricSpec.new("GC/Transaction/all"), 14)
+    stats_hash.record(NewRelic::MetricSpec.new('Memcache/allOther'), 15)
 
     with_sampler_config do
       generate_request('name', :metrics => stats_hash)
@@ -119,7 +120,8 @@ class NewRelic::Agent::RequestSamplerTest < Minitest::Test
       event_data = single_sample[EVENT_DATA_INDEX]
       assert_equal 12, event_data["externalDuration"]
       assert_equal 13, event_data["databaseDuration"]
-      assert_equal 14, event_data["memcacheDuration"]
+      assert_equal 14, event_data["gcCumulative"]
+      assert_equal 15, event_data["memcacheDuration"]
 
       assert_equal 1, event_data["databaseCallCount"]
       assert_equal 1, event_data["externalCallCount"]