newrelic_rpm 3.9.1.236 → 3.9.2.239

data/test/multiverse/suites/typhoeus/Envfile

@@ -1,11 +1,8 @@
-suite_condition("Typhoeus not supported in 1.8.6 and excluded on 1.8.7 non-REE") do
-
+suite_condition("Typhoeus excluded on 1.8.7 non-REE") do
   # Under Ruby 1.8.7 (but not REE), there are persistent segfaults with Typhoeus
   # and the Ruby agent. This predated our Typhoeus instrumentation, but given
   # usage levels and obscurity of the issue, it isn't worth deeper digging.
   # Just use REE, or better yet >= 1.9
-
-  (RUBY_VERSION != '1.8.6') &&
   (RUBY_VERSION != '1.8.7' || RUBY_DESCRIPTION =~ /Enterprise/)
 end
 

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

@@ -11,8 +11,7 @@ class NewRelic::Agent::Agent::StartWorkerThreadTest < Minitest::Test
     self.expects(:catch_errors).yields
     self.expects(:connect).with('connection_options')
     self.stubs(:connected?).returns(true)
-    self.expects(:log_worker_loop_start)
-    self.expects(:create_and_run_worker_loop)
+    self.expects(:create_and_run_event_loop)
     deferred_work!('connection_options')
   end
 
@@ -23,17 +22,6 @@ class NewRelic::Agent::Agent::StartWorkerThreadTest < Minitest::Test
     deferred_work!('connection_options')
   end
 
-  def test_create_and_run_worker_loop
-    @should_send_samples = true
-    wl = mock('worker loop')
-    NewRelic::Agent::WorkerLoop.expects(:new).returns(wl)
-    wl.expects(:run).with(30).yields
-    self.expects(:transmit_data)
-    with_config(:data_report_period => 30) do
-      create_and_run_worker_loop
-    end
-  end
-
   def test_handle_force_restart
     # hooray for methods with no branches
     error = mock(:message => 'a message')

data/test/new_relic/agent/agent_logger_test.rb

@@ -337,6 +337,17 @@ class AgentLoggerTest < Minitest::Test
     )
   end
 
+  def test_can_overwrite_log_formatter
+    log_message   = 'How are you?'
+    log_formatter = Proc.new { |s, t, p, m| m.reverse }
+
+    logger = create_basic_logger
+    logger.log_formatter = log_formatter
+    logger.warn log_message
+
+    assert_logged log_message.reverse
+  end
+
   #
   # Helpers
   #

data/test/new_relic/agent/agent_test.rb

@@ -311,15 +311,21 @@ module NewRelic
       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)
-        assert settings.include?(:high_security)
+        expected = [
+         :pid,
+         :host,
+         :app_name,
+         :language,
+         :labels,
+         :agent_version,
+         :environment,
+         :settings,
+         :high_security
+        ]
+
+        expected.each do |expect_key|
+          assert_includes @agent.connect_settings.keys, expect_key
+        end
       end
 
       def test_connect_settings_checks_environment_report_can_marshal
@@ -327,6 +333,23 @@ module NewRelic
         assert_equal [], @agent.connect_settings[:environment]
       end
 
+      def test_connect_settings_includes_labels_from_config
+        with_config({:labels => {'Server' => 'East'}}) do
+          expected = [ {"label_type"=>"Server", "label_value"=>"East"} ]
+          assert_equal expected, @agent.connect_settings[:labels]
+        end
+      end
+
+      def test_connect_settings_includes_labels_from_semicolon_separated_config
+        with_config(:labels => "Server:East;Server:West;") do
+          expected = [
+            {"label_type"=>"Server", "label_value"=>"East"},
+            {"label_type"=>"Server", "label_value"=>"West"}
+          ]
+          assert_equal expected, @agent.connect_settings[:labels]
+        end
+      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)
@@ -514,37 +537,37 @@ module NewRelic
         end
       end
 
-      def test_stop_worker_loop_runs_loop_before_exit_with_force_send_config
+      def test_stop_event_loop_runs_loop_before_exit_with_force_send_config
         fake_loop = mock
-        fake_loop.expects(:run_task)
+        fake_loop.expects(:run_once)
         fake_loop.stubs(:stop)
 
-        @agent.instance_variable_set(:@worker_loop, fake_loop)
+        @agent.instance_variable_set(:@event_loop, fake_loop)
 
         with_config(:force_send => true) do
-          @agent.stop_worker_loop
+          @agent.stop_event_loop
         end
       end
 
-      def test_stop_worker_loop_doesnt_run_loop_if_force_send_is_false
+      def test_stop_event_loop_doesnt_run_loop_if_force_send_is_false
         fake_loop = mock
-        fake_loop.expects(:run_task).never
+        fake_loop.expects(:run_once).never
         fake_loop.stubs(:stop)
 
-        @agent.instance_variable_set(:@worker_loop, fake_loop)
+        @agent.instance_variable_set(:@event_loop, fake_loop)
 
         with_config(:force_send => false) do
-          @agent.stop_worker_loop
+          @agent.stop_event_loop
         end
       end
 
-      def test_stop_worker_loop_stops_the_loop
+      def test_stop_event_loop_stops_the_loop
         fake_loop = mock
         fake_loop.expects(:stop)
 
-        @agent.instance_variable_set(:@worker_loop, fake_loop)
+        @agent.instance_variable_set(:@event_loop, fake_loop)
 
-        @agent.stop_worker_loop
+        @agent.stop_event_loop
       end
 
       def test_untraced_graceful_disconnect_logs_errors

data/test/new_relic/agent/audit_logger_test.rb

@@ -32,9 +32,13 @@ class AuditLoggerTest < Minitest::Test
   end
 
   def assert_log_contains_string(str)
+    log_body = read_log_body
+    assert(log_body.include?(str), "Expected log to contain string '#{str}'\nLog body was: #{log_body}")
+  end
+
+  def read_log_body
     @fakelog.rewind
-    log_body = @fakelog.read
-    assert(log_body.include?(str), "Expected log to contain string '#{str}'")
+    @fakelog.read
   end
 
   def test_never_setup_if_disabled
@@ -117,7 +121,7 @@ class AuditLoggerTest < Minitest::Test
       setup_fake_logger
       json_marshaller = marshaller_cls.new
       @logger.log_request(@uri, @dummy_data, json_marshaller)
-      assert_log_contains_string(JSON.dump(@dummy_data))
+      assert_audit_log_contains_object(read_log_body, @dummy_data, :json)
     end
   end
 

data/test/new_relic/agent/commands/thread_profiler_session_test.rb

@@ -63,7 +63,6 @@ if !NewRelic::Agent::Threading::BacktraceService.is_supported?
     end
 
     def test_wont_start_and_reports_error
-      errors = nil
       assert_raises NewRelic::Agent::Commands::AgentCommandRouter::AgentCommandError do
         @profiler.handle_start_command(start_command)
       end

data/test/new_relic/agent/commands/xray_session_collection_test.rb

@@ -325,7 +325,7 @@ module NewRelic::Agent::Commands
     end
 
     def command_for(*session_ids)
-      command = create_agent_command({ "xray_ids" => session_ids})
+      create_agent_command({ "xray_ids" => session_ids})
     end
 
   end

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

@@ -0,0 +1,53 @@
+# 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'))
+
+module NewRelic::Agent::Configuration
+  class DottedHashTest < Minitest::Test
+    def test_without_nesting
+      hash = DottedHash.new({ :turtle => 1 })
+      assert_equal({ :turtle => 1 }, hash)
+    end
+
+    def test_with_nesting
+      hash = DottedHash.new({ :turtle => { :turtle => 1 } })
+      assert_equal({ :'turtle.turtle' => 1 }, hash)
+    end
+
+    def test_with_multiple_layers_of_nesting
+      hash = DottedHash.new({ :turtle => { :turtle => { :turtle => 1 } } })
+      assert_equal({ :'turtle.turtle.turtle' => 1 }, hash)
+    end
+
+    def test_turns_keys_to_symbols
+      hash = DottedHash.new({ "turtle" => { "turtle" => { "turtle" => 1 } } })
+      assert_equal({ :'turtle.turtle.turtle' => 1 }, hash)
+    end
+
+    def test_to_hash
+      dotted = DottedHash.new({ "turtle" => { "turtle" => { "turtle" => 1 } } })
+      hash = dotted.to_hash
+
+      assert_instance_of(Hash, hash)
+      assert_equal({ :'turtle.turtle.turtle' => 1 }, hash)
+    end
+
+    def test_option_to_keep_nesting
+      hash = DottedHash.new({ :turtle => { :turtle => 1 } }, true)
+      expected = {
+        :turtle => { :turtle => 1},
+        :'turtle.turtle' => 1,
+      }
+
+      assert_equal(expected, hash)
+    end
+
+    def test_borks_with_non_symbolizing_key
+      assert_raises(NoMethodError) do
+        DottedHash.new({ Object.new => 2 }, true)
+      end
+    end
+  end
+end

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

@@ -32,11 +32,11 @@ module NewRelic::Agent::Configuration
         :bar => 'default bar',
         :baz => 'default baz'
       }
-      @manager.add_config_for_testing(config0)
-      config1 = { :foo => 'real foo' }
+      @manager.add_config_for_testing(config0, false)
+      config1 = { :foo => 'wrong foo', :bar => 'real bar' }
       @manager.add_config_for_testing(config1)
-      config2 = { :foo => 'wrong foo', :bar => 'real bar' }
-      @manager.add_config_for_testing(config2, 1)
+      config2 = { :foo => 'real foo' }
+      @manager.add_config_for_testing(config2)
 
       assert_equal 'real foo'   , @manager['foo']
       assert_equal 'real bar'   , @manager['bar']
@@ -63,7 +63,7 @@ module NewRelic::Agent::Configuration
 
     def test_identifying_config_source
       hash_source = {:foo => 'foo', :bar => 'default'}
-      @manager.add_config_for_testing(hash_source, 3)
+      @manager.add_config_for_testing(hash_source, false)
       test_source = ManualSource.new(:bar => 'bar', :baz => 'baz')
       @manager.replace_or_add_config(test_source)
 
@@ -109,7 +109,7 @@ module NewRelic::Agent::Configuration
     def test_should_read_license_key_from_env
       ENV['NEWRELIC_LICENSE_KEY'] = 'right'
       manager = NewRelic::Agent::Configuration::Manager.new
-      manager.add_config_for_testing({:license_key => 'wrong'}, 1)
+      manager.add_config_for_testing({:license_key => 'wrong'}, false)
 
       assert_equal 'right', manager['license_key']
     ensure
@@ -282,5 +282,98 @@ module NewRelic::Agent::Configuration
       refute @manager.config_classes_for_testing.include?(YamlSource)
       refute @manager.config_classes_for_testing.include?(HighSecuritySource)
     end
+
+    load_cross_agent_test("labels").each do |testcase|
+      define_method("test_#{testcase['name']}") do
+        @manager.add_config_for_testing(:labels => testcase["labelString"])
+
+        assert_warning if testcase["warning"]
+        assert_equal(testcase["expected"], @manager.parse_labels_from_string)
+      end
+    end
+
+    def test_parse_labels_from_dictionary_with_hard_failure
+      bad_label_object = Object.new
+      @manager.add_config_for_testing(:labels => bad_label_object)
+
+      assert_parsing_error
+      assert_parsed_labels([])
+    end
+
+    def test_parse_labels_from_string_with_hard_failure
+      bad_string = "baaaad"
+      bad_string.stubs(:gsub).raises("Booom")
+      @manager.add_config_for_testing(:labels => bad_string)
+
+      assert_parsing_error
+      assert_parsed_labels([])
+    end
+
+    def test_parse_labels_from_dictionary
+      @manager.add_config_for_testing(:labels => { 'Server' => 'East', 'Data Center' => 'North' })
+
+      assert_parsed_labels([
+        { 'label_type' => 'Server', 'label_value' => 'East' },
+        { 'label_type' => 'Data Center', 'label_value' => 'North' }
+      ])
+    end
+
+    def test_parse_labels_from_dictionary_applies_length_limits
+      @manager.add_config_for_testing(:labels => { 'K' * 256 => 'V' * 256 })
+      expected = [ { 'label_type' => 'K' * 255, 'label_value' => 'V' * 255 } ]
+
+      expects_logging(:warn, includes("truncated"))
+      assert_parsed_labels(expected)
+    end
+
+    def test_parse_labels_from_dictionary_disallows_further_nested_hashes
+      @manager.add_config_for_testing(:labels => {
+        "More Nesting" => { "Hahaha" => "Ha" }
+      })
+
+      assert_warning
+      assert_parsed_labels([])
+    end
+
+    def test_parse_labels_from_dictionary_allows_numerics
+      @manager.add_config_for_testing(:labels => {
+        "the answer" => 42
+      })
+
+      expected = [{ 'label_type' => 'the answer', 'label_value' => '42' }]
+      assert_parsed_labels(expected)
+    end
+
+    def test_parse_labels_from_dictionary_allows_booleans
+      @manager.add_config_for_testing(:labels => {
+        "truthy" => true,
+        "falsy"  => false
+      })
+
+      expected = [
+        { 'label_type' => 'truthy', 'label_value' => 'true' },
+        { 'label_type' => 'falsy',  'label_value' => 'false' }
+      ]
+      assert_parsed_labels(expected)
+    end
+
+    def assert_parsed_labels(expected)
+      result = @manager.parsed_labels
+
+      # 1.8.7 hash ordering means we can't directly compare. Lean on the
+      # structure and flattened array sorting to do the comparison we need.
+      result = result.map(&:to_a).sort
+      expected = expected.map(&:to_a).sort
+
+      assert_equal expected, result
+    end
+
+    def assert_warning
+      expects_logging(:warn, any_parameters, any_parameters)
+    end
+
+    def assert_parsing_error
+      expects_logging(:error, includes(Manager::PARSING_LABELS_FAILURE), any_parameters)
+    end
   end
 end

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

@@ -0,0 +1,18 @@
+# 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'))
+
+module NewRelic::Agent::Configuration
+  class ManualSourceTest < Minitest::Test
+    def test_prepopulates_nested_keys
+      source = ManualSource.new({ :outer => { :inner => "stuff" } })
+      expected = {
+        :outer => { :inner => "stuff" },
+        :'outer.inner' => "stuff"
+      }
+      assert_equal(expected, source)
+    end
+  end
+end

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

@@ -33,7 +33,7 @@ class OrphanedConfigTest < Minitest::Test
     end
   end
 
-  AGENT_CONFIG_PATTERN      = /Agent\.config\[:['"]?([a-z\._]+)['"]?\]/
+  AGENT_CONFIG_PATTERN      = /Agent\.config\[:['"]?([a-z\._]+)['"]?\s*\]/
   REGISTER_CALLBACK_PATTERN = /register_callback\(:['"]?([a-z\._]+)['"]?\)/
   NAMED_DEPENDENCY_PATTERN  = /^\s*named[ (]+\:?([a-z\._]+).*$/
 

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

@@ -44,6 +44,10 @@ module NewRelic::Agent::Configuration
       assert_equal 'raw', @source[:'transaction_tracer.record_sql']
     end
 
+    def test_should_still_have_nested_hashes_around
+      refute_nil @source[:transaction_tracer]
+    end
+
     def test_should_ignore_apdex_f_setting_for_transaction_threshold
       assert_equal nil, @source[:'transaction_tracer.transaction_threshold']
     end
@@ -59,18 +63,18 @@ module NewRelic::Agent::Configuration
 
     def test_should_log_if_no_file_is_found
       expects_logging(:warn, any_parameters)
-      source = YamlSource.new('no_such_file.yml', 'test')
+      YamlSource.new('no_such_file.yml', 'test')
     end
 
     def test_should_log_if_environment_is_not_present
       expects_logging(:error, any_parameters)
-      source = YamlSource.new(@test_yml_path, 'nonsense')
+      YamlSource.new(@test_yml_path, 'nonsense')
     end
 
     def test_should_not_fail_to_log_missing_file_during_startup
       without_logger do
         ::NewRelic::Agent::StartupLogger.any_instance.expects(:warn)
-        source = YamlSource.new('no_such_file.yml', 'test')
+        YamlSource.new('no_such_file.yml', 'test')
       end
     end
 
@@ -81,7 +85,7 @@ module NewRelic::Agent::Configuration
         File.stubs(:exists?).returns(true)
         File.stubs(:read).raises(StandardError.new("boo"))
 
-        source = YamlSource.new('fake.yml', 'test')
+        YamlSource.new('fake.yml', 'test')
       end
     end