newrelic_rpm 3.9.1.236 → 3.9.2.239

data/test/multiverse/lib/multiverse/output_collector.rb

@@ -60,7 +60,7 @@ module Multiverse
     # start their processes, make sure we don't blatantly interleave output.
     def self.output(*args)
       @output_lock.synchronize do
-        puts *args
+        puts(*args)
       end
     end
   end

data/test/multiverse/lib/multiverse/runner.rb

@@ -72,7 +72,7 @@ module Multiverse
           puts red("Error when trying to run suite in #{full_path.inspect}")
           puts
           puts "#{e.class}: #{e}"
-          puts *e.backtrace
+          puts(*e.backtrace)
           notice_exit_status 1
         end
       end

data/test/multiverse/lib/multiverse/suite.rb

@@ -176,8 +176,19 @@ module Multiverse
       ENV['SERIALIZE'] || debug
     end
 
+    def check_environment_condition
+      if environments.condition && !environments.condition.call
+        puts yellow("SKIPPED #{directory.inspect}: #{environments.skip_message}")
+        false
+      else
+        true
+      end
+    end
+
     def prime
       ENV["VERBOSE"]= "1"
+      return unless check_environment_condition
+
       puts yellow("\nPriming #{directory.inspect}")
       @environments = nil
 
@@ -196,10 +207,7 @@ module Multiverse
     # implement #fork so we resort to a hack.  We exec this lib file, which
     # loads a new JVM for the tests to run in.
     def execute
-      if environments.condition && !environments.condition.call
-        puts yellow("SKIPPED #{directory.inspect}: #{environments.skip_message}")
-        return
-      end
+      return unless check_environment_condition
 
       label = should_serialize? ? 'serial' : 'parallel'
       env_count = filter_env ? 1 : environments.size
@@ -212,6 +220,13 @@ module Multiverse
         execute_parallel
       end
       environments.after.call if environments.after
+    rescue => e
+      puts red("Failure during execution of suite #{directory.inspect}.")
+      puts red("This typically is a result of a Ruby failure in your Envfile.")
+      puts
+      puts red(e.class)
+      puts red(e.message)
+      exit(1)
     end
 
     def execute_serial

data/test/multiverse/suites/agent_only/audit_log_test.rb

@@ -23,43 +23,6 @@ class AuditLogTest < Minitest::Test
     @contents
   end
 
-  def assert_audit_log_contains(needle)
-    # Original request bodies dumped to the log have symbol keys, but once
-    # they go through a dump/load, they're strings again, so we strip
-    # double-quotes and colons from the log, and the strings we searching for.
-    regex = /[:"]/
-    needle = needle.gsub(regex, '')
-    haystack = audit_log_contents.gsub(regex, '')
-    assert(haystack.include?(needle), "Expected log to contain '#{needle}'")
-  end
-
-  # Because we don't generate a strictly machine-readable representation of
-  # request bodies for the audit log, the transformation into strings is
-  # effectively one-way. This, combined with the fact that Hash traversal order
-  # is arbitrary in Ruby 1.8.x means that it's difficult to directly assert that
-  # some object graph made it into the audit log (due to different possible
-  # orderings of the key/value pairs in Hashes that were embedded in the request
-  # body). So, this method traverses an object graph and only makes assertions
-  # about the terminal (non-Array-or-Hash) nodes therein.
-  def assert_audit_log_contains_object(o, format)
-    if format == :json
-      assert_audit_log_contains(JSON.dump(o))
-    else
-      case o
-      when Hash
-        o.each do |k,v|
-          assert_audit_log_contains_object(v, format)
-        end
-      when Array
-        o.each do |el|
-          assert_audit_log_contains_object(el, format)
-        end
-      else
-        assert_audit_log_contains(o.inspect)
-      end
-    end
-  end
-
   def test_logs_nothing_by_default
     run_agent do
       perform_actions
@@ -79,7 +42,7 @@ class AuditLogTest < Minitest::Test
       perform_actions
       format = NewRelic::Agent::NewRelicService::JsonMarshaller.is_supported? ? :json : :pruby
       $collector.agent_data.each do |req|
-        assert_audit_log_contains_object(req.body, format)
+        assert_audit_log_contains_object(audit_log_contents, req.body, format)
       end
     end
   end

data/test/multiverse/suites/agent_only/collector_exception_handling_test.rb

@@ -8,19 +8,30 @@ require 'open3'
 class CollectorExceptionHandlingTest < Minitest::Test
   include MultiverseHelpers
 
-  setup_and_teardown_agent
+  setup_and_teardown_agent do
+    NewRelic::Agent.agent.stubs(:sleep)
+  end
 
-  def test_should_reconnect_on_force_restart_exception
+  def after_setup
+    # there's a call to sleep in handle_force_restart that we want to skip
     $collector.reset
+  end
+
+
+  RESTART_PAYLOAD       = { 'error_type' => 'NewRelic::Agent::ForceRestartException'    }
+  DISCONNECT_PAYLOAD    = { 'error_type' => 'NewRelic::Agent::ForceDisconnectException' }
+  RUNTIME_ERROR_PAYLOAD = { 'error_type' => 'RuntimeError'                              }
+
+
+  def test_should_reconnect_on_force_restart_exception
+    # We stub these exceptions because we want the EventLoop to exit with a
+    # ForceRestartException the first time through, then (after reconnecting)
+    # we force the disconnect so that this test will end cleanly.
 
-    payload = { 'error_type' => 'NewRelic::Agent::ForceRestartException' }
-    $collector.stub_exception('metric_data', payload).once
+    $collector.stub_exception('metric_data'       , RESTART_PAYLOAD   ).once
+    $collector.stub_exception('get_agent_commands', DISCONNECT_PAYLOAD).once
 
     with_config(:data_report_period => 0) do
-      worker_loop = NewRelic::Agent::WorkerLoop.new(:limit => 1)
-      NewRelic::Agent.agent.stubs(:create_worker_loop).returns(worker_loop)
-      # there's a call to sleep in handle_force_restart that we want to skip
-      NewRelic::Agent.agent.stubs(:sleep)
       NewRelic::Agent.agent.deferred_work!({})
     end
 
@@ -34,10 +45,7 @@ class CollectorExceptionHandlingTest < Minitest::Test
   end
 
   def test_should_stop_reporting_after_force_disconnect
-    $collector.reset
-
-    payload = { 'error_type' => 'NewRelic::Agent::ForceDisconnectException' }
-    $collector.stub_exception('metric_data', payload).once
+    $collector.stub_exception('metric_data', DISCONNECT_PAYLOAD).once
 
     with_config(:data_report_period => 0) do
       NewRelic::Agent.agent.deferred_work!({})
@@ -48,15 +56,9 @@ class CollectorExceptionHandlingTest < Minitest::Test
   end
 
   def test_should_stop_reporting_after_force_disconnect_on_connect
-    $collector.reset
-
-    payload = { 'error_type' => 'NewRelic::Agent::ForceDisconnectException' }
-    $collector.stub_exception('connect', payload).once
+    $collector.stub_exception('connect', DISCONNECT_PAYLOAD).once
 
     with_config(:data_report_period => 0) do
-      worker_loop = NewRelic::Agent::WorkerLoop.new(:limit => 1)
-      NewRelic::Agent.agent.stubs(:create_worker_loop).returns(worker_loop)
-      NewRelic::Agent.agent.stubs(:sleep)
       NewRelic::Agent.agent.deferred_work!({})
     end
 
@@ -64,16 +66,10 @@ class CollectorExceptionHandlingTest < Minitest::Test
   end
 
   def test_should_reconnect_on_connect_exception
-    $collector.reset
-
-    payload = { 'error_type' => 'RuntimeError' }
-    $collector.stub_exception('connect', payload).once
+    $collector.stub_exception('connect', RUNTIME_ERROR_PAYLOAD).once
+    $collector.stub_exception('metric_data', DISCONNECT_PAYLOAD).once
 
     with_config(:data_report_period => 0) do
-      worker_loop = NewRelic::Agent::WorkerLoop.new(:limit => 1)
-      NewRelic::Agent.agent.stubs(:create_worker_loop).returns(worker_loop)
-      # there's a call to sleep in connect that we want to skip
-      NewRelic::Agent.agent.stubs(:sleep)
       NewRelic::Agent.agent.deferred_work!({})
     end
 
@@ -81,16 +77,10 @@ class CollectorExceptionHandlingTest < Minitest::Test
   end
 
   def test_should_reconnect_on_get_redirect_host_exception
-    $collector.reset
-
-    payload = { 'error_type' => 'RuntimeError' }
-    $collector.stub_exception('get_redirect_host', payload).once
+    $collector.stub_exception('get_redirect_host', RUNTIME_ERROR_PAYLOAD).once
+    $collector.stub_exception('metric_data', DISCONNECT_PAYLOAD).once
 
     with_config(:data_report_period => 0) do
-      worker_loop = NewRelic::Agent::WorkerLoop.new(:limit => 1)
-      NewRelic::Agent.agent.stubs(:create_worker_loop).returns(worker_loop)
-      # there's a call to sleep in connect that we want to skip
-      NewRelic::Agent.agent.stubs(:sleep)
       NewRelic::Agent.agent.deferred_work!({})
     end
 

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

@@ -18,3 +18,5 @@ development:
   capture_params: false
   browser_monitoring:
     auto_instrument: true
+  labels:
+    Server: Yaml

data/test/multiverse/suites/agent_only/encoding_handling_test.rb

@@ -88,6 +88,7 @@ class EncodingHandlingTest < Minitest::Test
 
   def assert_endpoint_received_string(endpoint, string)
     agent.send(:transmit_data)
+    agent.send(:transmit_transaction_event_data)
     requests = $collector.calls_for(endpoint)
     assert_equal(1, requests.size)
     request = requests.first

data/test/multiverse/suites/agent_only/harvest_timestamps_test.rb

@@ -11,7 +11,7 @@ class HarvestTimestampsTest < Minitest::Test
   setup_and_teardown_agent
 
   def test_resets_metric_data_timestamps_after_forking
-    t0 = freeze_time
+    freeze_time
 
     t1 = advance_time 10
     NewRelic::Agent.after_fork

data/test/multiverse/suites/agent_only/keepalive_test.rb

@@ -0,0 +1,29 @@
+# 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 'newrelic_rpm'
+require 'multiverse_helpers'
+
+class KeepaliveTest < Minitest::Test
+  include MultiverseHelpers
+
+  def test_can_reestablish_connection
+    setup_agent(:aggressive_keepalive => true)
+
+    NewRelic::Agent.agent.send(:transmit_data)
+
+    # This is the closest I can easily get to closing the underlying TCP
+    # connection from the server side in between harvests.
+    conn0 = NewRelic::Agent.agent.service.http_connection
+    conn0.instance_variable_get(:@socket).close
+
+    NewRelic::Agent.agent.send(:transmit_data)
+
+    conn1 = NewRelic::Agent.agent.service.http_connection
+
+    metric_data_calls = $collector.calls_for('metric_data')
+    assert_equal(2, metric_data_calls.size)
+    assert_same(conn0, conn1)
+  end
+end

data/test/multiverse/suites/agent_only/labels_test.rb

@@ -0,0 +1,89 @@
+# 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.join(File.dirname(__FILE__), '..', '..', '..', 'agent_helper')
+require 'fake_collector'
+require 'multiverse_helpers'
+
+class LabelsTest < Minitest::Test
+  include MultiverseHelpers
+
+  setup_and_teardown_agent
+
+  EXPECTED     = [{'label_type' => 'Server', 'label_value' => 'East'}]
+  YML_EXPECTED = [{'label_type' => 'Server', 'label_value' => 'Yaml'}]
+
+  def after_setup
+    $collector.reset
+    make_sure_agent_reconnects({})
+  end
+
+  def test_yaml_makes_it_to_the_collector
+    # Relies on the agent_only/config/newrelic.yml!
+    NewRelic::Agent.manual_start
+    assert_connect_had_labels(YML_EXPECTED)
+  end
+
+  def test_labels_from_config_hash_make_it_to_the_collector
+    with_config("labels" => { "Server" => "East" }) do
+      NewRelic::Agent.manual_start
+      assert_connect_had_labels(EXPECTED)
+    end
+  end
+
+  def test_labels_from_manual_start_hash_make_it_to_the_collector
+    NewRelic::Agent.manual_start(:labels => { "Server" => "East" })
+    assert_connect_had_labels(EXPECTED)
+  end
+
+  def test_numeric_values_for_labels
+    NewRelic::Agent.manual_start(:labels => { "Server" => 42 })
+    expected = [
+      { 'label_type' => 'Server', 'label_value' => '42' }
+    ]
+    assert_connect_had_labels(expected)
+  end
+
+  def test_boolean_values_for_labels
+    NewRelic::Agent.manual_start(:labels => { "Server" => true })
+    expected = [
+      { 'label_type' => 'Server', 'label_value' => 'true' }
+    ]
+    assert_connect_had_labels(expected)
+  end
+
+  # All testing of string parsed label pairs should go through the cross agent
+  # test file for labels. Our dictionary passing is custom to Ruby, though.
+  load_cross_agent_test("labels").each do |testcase|
+    define_method("test_#{testcase['name']}_from_config_string") do
+      with_config("labels" => testcase["labelString"]) do
+        NewRelic::Agent.manual_start
+        assert_connect_had_labels(testcase["expected"])
+      end
+    end
+
+    define_method("test_#{testcase['name']}_from_manual_start") do
+      NewRelic::Agent.manual_start(:labels => testcase["labelString"])
+      assert_connect_had_labels(testcase["expected"])
+    end
+
+    define_method("test_#{testcase['name']}_from_env") do
+      begin
+        # Value must be here before reset for EnvironmentSource to see it
+        ENV['NEW_RELIC_LABELS'] = testcase["labelString"]
+        NewRelic::Agent.config.reset_to_defaults
+
+        NewRelic::Agent.manual_start
+        assert_connect_had_labels(testcase["expected"])
+      ensure
+        ENV['NEW_RELIC_LABELS'] = nil
+      end
+    end
+  end
+
+  def assert_connect_had_labels(expected)
+    result = $collector.calls_for('connect').first['labels']
+    assert_equal expected, result
+  end
+end

data/test/multiverse/suites/agent_only/marshaling_test.rb

@@ -16,7 +16,7 @@ class MarshalingTest < Minitest::Test
   end
 
   def test_transaction_trace_marshaling
-    time = freeze_time
+    freeze_time
 
     in_transaction do
       trace_execution_scoped('a') do
@@ -31,8 +31,6 @@ class MarshalingTest < Minitest::Test
     agent.service.connect
     agent.send(:harvest_and_send_transaction_traces)
 
-    marshaller = agent.service.marshaller
-
     actual = $collector.calls_for('transaction_sample_data')[0][1][0]
     encoder = NewRelic::Agent::NewRelicService::Encoders::Identity
 

data/test/multiverse/suites/agent_only/service_timeout_test.rb

@@ -12,7 +12,7 @@ class ServiceTimeoutTest < Minitest::Test
 
     Thread.new {
       client = hk.accept
-      what = client.gets
+      client.gets
       sleep 4
       client.close
       Thread.exit

data/test/multiverse/suites/agent_only/start_up_test.rb

@@ -10,7 +10,7 @@ class StartUpTest < Minitest::Test
     ruby = 'require "newrelic_rpm"; NewRelic::Agent.manual_start; NewRelic::Agent.shutdown'
     cmd = "bundle exec ruby -e '#{ruby}'"
 
-    sin, sout, serr = Open3.popen3(cmd)
+    _sin, sout, serr = Open3.popen3(cmd)
     output = sout.read + serr.read
 
     expected_noise = [
@@ -30,4 +30,12 @@ class StartUpTest < Minitest::Test
     problems = output.scan(/ERROR : .*/)
     assert_empty problems
   end
+
+  def test_after_fork_does_not_blow_away_manual_start_settings
+    NewRelic::Agent.manual_start(:app_name => 'my great app')
+
+    NewRelic::Agent.after_fork
+
+    assert_equal('my great app', NewRelic::Agent.config[:app_name])
+  end
 end

data/test/multiverse/suites/capistrano/config/deploy.rb

@@ -6,5 +6,9 @@ set :application, 'test'
 
 # Since Capistrano 3 doesn't allow settings direct from command-line, add any
 # settings we want to conditionally toggle from tests in the following manner.
-set :newrelic_user, ENV["NEWRELIC_USER"] if ENV["NEWRELIC_USER"]
-set :newrelic_appname, ENV["NEWRELIC_APPNAME"] if ENV["NEWRELIC_APPNAME"]
+ENV.keys.each do |key|
+  if key.match(/NEWRELIC_CAPISTRANO_/)
+    name = key.gsub('NEWRELIC_CAPISTRANO_', '').downcase
+    set "newrelic_#{name}".to_sym, ENV[key]
+  end
+end

data/test/multiverse/suites/capistrano/deployment_test.rb

@@ -4,6 +4,7 @@
 
 require 'fake_rpm_site'
 require 'multiverse_helpers'
+require 'new_relic/cli/command'
 
 class DeploymentTest < Minitest::Test
   def setup
@@ -21,14 +22,21 @@ class DeploymentTest < Minitest::Test
     # Capistrano 3 doesn't provide built-in commandline params -> settings
     # We wire our own up via ENV to test setting out setting custom values
     env = {
-      'NEWRELIC_USER'      => "someone",
-      'NEWRELIC_APPNAME'   => "somewhere"
+      'NEWRELIC_CAPISTRANO_USER'        => "Optimus Prime",
+      'NEWRELIC_CAPISTRANO_APPNAME'     => "Tesseract",
+      'NEWRELIC_CAPISTRANO_REVISION'    => "C-001",
+      'NEWRELIC_CAPISTRANO_CHANGELOG'   => "The greatest weakness of most humans is their hesitancy to tell others they love them while they're alive.",
     }
 
     cap_it(env)
 
-    assert_deployment_value("user",           "someone")
-    assert_deployment_value("application_id", "somewhere")
+    assert_deployment_value("user",           "Optimus Prime")
+    assert_deployment_value("application_id", "Tesseract")
+    assert_deployment_value("revision",       "C-001")
+    assert_deployment_value("changelog",      "The greatest weakness of most humans is their hesitancy to tell others they love them while they're alive.")
+  end
+
+  def test_newrelic_revision_override
   end
 
   def assert_deployment_value(key, value)