newrelic_rpm 3.6.5.130 → 3.6.6.147

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

@@ -9,17 +9,24 @@
 require 'logger'
 require 'newrelic_rpm'
 require 'fake_collector'
+require 'multiverse_helpers'
 
-class LoggingTest < Test::Unit::TestCase
+class LoggingTest < MiniTest::Unit::TestCase
+
+  include MultiverseHelpers
+
+  def setup
+    NewRelic::Agent.stubs(:logger).returns(NewRelic::Agent::MemoryLogger.new)
+  end
 
   def test_logs_app_name
-    running_agent_writes_to_log( 
+    running_agent_writes_to_log(
        {:app_name => "My App"},
        "Application: My App")
   end
 
   def test_logs_error_with_bad_app_name
-    running_agent_writes_to_log( 
+    running_agent_writes_to_log(
        {:app_name => false},
         "No application name configured.")
   end
@@ -50,23 +57,13 @@ class LoggingTest < Test::Unit::TestCase
 
   def test_logs_ssl_warning
     running_agent_writes_to_log(
-      {:ssl => false},
+      {:ssl => true},
       "Agent is configured not to use SSL when communicating with New Relic's servers") do
 
       NewRelic::Agent.config.apply_config(:ssl => false)
     end
   end
 
-  def test_logs_ssl_verify_cert_warning
-    running_agent_writes_to_log(
-      {:ssl => false, :verify_certificate => false},
-      "Agent is configured to use SSL but to skip certificate validation when communicating with New Relic's servers") do
-
-      NewRelic::Agent.config.apply_config(:ssl => true, :verify_certificate => false)
-    end
-  end
-
-
   def test_logs_if_sending_errors_on_change
     running_agent_writes_to_log(
       {:'error_collector.enabled' => false},
@@ -92,9 +89,13 @@ class LoggingTest < Test::Unit::TestCase
   end
 
   def test_invalid_license_key
-    with_connect_response(401)
-    running_agent_writes_to_log({},
-      "Visit NewRelic.com to obtain a valid license key")
+    setup_agent({}) do |collector|
+      collector.stub('connect', {}, 401)
+    end
+
+    saw?("Visit NewRelic.com to obtain a valid license key")
+
+    teardown_agent
   end
 
   def test_logs_monitor_mode_disabled
@@ -121,45 +122,20 @@ class LoggingTest < Test::Unit::TestCase
       "Connecting workers after forking.")
   end
 
-  # Initialization
-  def setup
-    $collector ||= NewRelic::FakeCollector.new
-    $collector.reset
-    $collector.mock['connect'] = [200, {'return_value' => {"agent_run_id" => 666 }}]
-    $collector.run
-
-    NewRelic::Agent.reset_config 
-    NewRelic::Agent::Agent.instance_variable_set(:@instance, nil)
-
-    @logger = NewRelic::Agent::MemoryLogger.new
-    NewRelic::Agent.logger = @logger
-    NewRelic::Agent::AgentLogger.stubs(:new).with(any_parameters).returns(@logger)
-  end
-
-  def teardown
-    $collector.reset
-
-    # Really clear out our agent instance since we set bad license keys
-    NewRelic::Agent::Agent.instance_variable_set(:@instance, nil)
-  end
-
   # Helpers
-  def running_agent_writes_to_log(options, msg)
-    NewRelic::Agent.manual_start(options)
-    yield if block_given?
-    NewRelic::Agent.shutdown
+  def running_agent_writes_to_log(options, msg, &block)
+    run_agent(options, &block)
     saw?(msg)
   end
 
-  def with_connect_response(status=200, response={})
-    $collector.mock['connect'] = [status, response]
-  end
-
   def saw?(*expected_messages)
-    flattened = @logger.messages.flatten
+    # This is actually our MemoryLogger, so it has messages to check. Woot!
+    logger = NewRelic::Agent.logger
+
+    flattened = logger.messages.flatten
     expected_messages.each do |expected|
       found = flattened.any? {|msg| msg.to_s.include?(expected)}
-      @logger.messages.each {|msg| puts msg.inspect} if !found
+      logger.messages.each {|msg| puts msg.inspect} if !found
       assert(found, "Didn't see message '#{expected}'")
     end
   end

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

@@ -5,41 +5,33 @@
 # https://newrelic.atlassian.net/wiki/display/eng/The+Terror+and+Glory+of+Transaction+Traces
 # https://newrelic.atlassian.net/browse/RUBY-914
 require 'ostruct'
+require 'multiverse_helpers'
 
-class MarshalingTest < Test::Unit::TestCase
-  def setup
-    NewRelic::Agent.manual_start(:'transaction_tracer.transaction_threshold' => 0.0)
-    @agent = NewRelic::Agent.instance
-    @sampler = @agent.transaction_sampler
+class MarshalingTest < MiniTest::Unit::TestCase
+  include MultiverseHelpers
 
-    $collector ||= NewRelic::FakeCollector.new
-    $collector.reset
-    $collector.mock['connect'] = [200, {'return_value' => { 'agent_run_id' => 666 }}]
-    $collector.run
-  end
-
-  def teardown
-    Thread.current[:transaction_sample_builder] = nil
-    $collector.reset
+  setup_and_teardown_agent(:'transaction_tracer.transaction_threshold' => 0.0) do |collector|
+    collector.stub('connect', { 'agent_run_id' => 666 })
   end
 
   def test_transaction_trace_marshaling
     # create fake transaction trace
-    time = Time.now.to_f
-    @sampler.notice_first_scope_push time
-    @sampler.notice_transaction nil, {}
-    @sampler.notice_push_scope "a"
-    @sampler.notice_push_scope "ab"
-    sleep 1
-    @sampler.notice_pop_scope "ab"
-    @sampler.notice_pop_scope "a"
-    @sampler.notice_scope_empty(OpenStruct.new(:name => 'path',
+    time = freeze_time
+    sampler = agent.transaction_sampler
+    sampler.notice_first_scope_push time
+    sampler.notice_transaction nil, {}
+    sampler.notice_push_scope "a"
+    sampler.notice_push_scope "ab"
+    advance_time 1
+    sampler.notice_pop_scope "ab"
+    sampler.notice_pop_scope "a"
+    sampler.notice_scope_empty(OpenStruct.new(:name => 'path',
                                                :custom_parameters => {}))
 
-    expected_sample = @sampler.instance_variable_get(:@slowest_sample)
+    expected_sample = sampler.instance_variable_get(:@slowest_sample)
 
-    @agent.service.connect
-    @agent.send(:harvest_and_send_slowest_sample)
+    agent.service.connect
+    agent.send(:harvest_and_send_slowest_sample)
 
     if NewRelic::Agent::NewRelicService::JsonMarshaller.is_supported?
       marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
@@ -58,8 +50,8 @@ class MarshalingTest < Test::Unit::TestCase
     stats.record_data_point(2.0, 1.0)
     expected = [ 2, 3.0, 2.0, 1.0, 2.0, 5.0 ]
 
-    @agent.service.connect
-    @agent.send(:harvest_and_send_timeslice_data)
+    agent.service.connect
+    agent.send(:harvest_and_send_timeslice_data)
 
     assert_equal('666', $collector.calls_for('metric_data')[0].run_id)
 
@@ -68,9 +60,9 @@ class MarshalingTest < Test::Unit::TestCase
   end
 
   def test_error_data_marshalling
-    @agent.error_collector.notice_error(Exception.new('test error'))
-    @agent.service.connect
-    @agent.send(:harvest_and_send_errors)
+    agent.error_collector.notice_error(Exception.new('test error'))
+    agent.service.connect
+    agent.send(:harvest_and_send_errors)
 
     assert_equal('666', $collector.calls_for('error_data')[0].run_id)
 
@@ -79,24 +71,24 @@ class MarshalingTest < Test::Unit::TestCase
   end
 
   def test_sql_trace_data_marshalling
-    @agent.sql_sampler.notice_first_scope_push(nil)
-    @agent.sql_sampler.notice_sql("select * from test",
+    agent.sql_sampler.notice_first_scope_push(nil)
+    agent.sql_sampler.notice_sql("select * from test",
                                   "Database/test/select",
                                   nil, 1.5)
-    @agent.sql_sampler.notice_scope_empty('txn')
+    agent.sql_sampler.notice_scope_empty('txn')
 
-    @agent.service.connect
-    @agent.send(:harvest_and_send_slowest_sql)
+    agent.service.connect
+    agent.send(:harvest_and_send_slowest_sql)
 
     sql_data = $collector.calls_for('sql_trace_data')[0][0]
     assert_equal('select * from test', sql_data[0][3])
   end
 
   def test_connect_marshalling
-    @agent.service.connect('pid' => 1, 'agent_version' => '9000',
+    agent.service.connect('pid' => 1, 'agent_version' => '9000',
                            'app_name' => 'test')
 
-    connect_data = $collector.calls_for('connect')[0]
+    connect_data = $collector.calls_for('connect').last
     assert_equal '9000', connect_data['agent_version']
   end
 end

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

@@ -4,15 +4,21 @@
 
 # https://newrelic.atlassian.net/browse/RUBY-669
 
-class PipeManagerTest < Test::Unit::TestCase
-  def setup
+require 'multiverse_helpers'
+
+class PipeManagerTest < MiniTest::Unit::TestCase
+  include MultiverseHelpers
+
+  setup_and_teardown_agent
+
+  def after_setup
     @listener = NewRelic::Agent::PipeChannelManager.listener
   end
 
-  def teardown
+  def after_teardown
     @listener.stop
   end
-  
+
   def test_old_pipes_are_cleaned_up_after_timeout
     @listener.timeout = 1
     NewRelic::Agent::PipeChannelManager.register_report_channel(:timeout_test)
@@ -26,11 +32,11 @@ class PipeManagerTest < Test::Unit::TestCase
     @listener.select_timeout = 1
     @listener.timeout = 2
     NewRelic::Agent::PipeChannelManager.register_report_channel(:select_test)
-    
+
     sleep 1.5
     @listener.start
     assert NewRelic::Agent::PipeChannelManager.channels[:select_test]
-    
+
     sleep 1.5
     assert_nil NewRelic::Agent::PipeChannelManager.channels[:select_test]
   end

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

@@ -2,9 +2,23 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
-class RenameRuleTest < Test::Unit::TestCase
+require 'multiverse_helpers'
+
+class RenameRuleTest < MiniTest::Unit::TestCase
+
+  include MultiverseHelpers
+
+  setup_and_teardown_agent do |collector|
+    rules = [ { 'match_expression' => 'RenameRuleTest', 'replacement' => 'Class' } ]
+    collector.stub('connect', {
+      'agent_run_id'           => 666,
+      'transaction_name_rules' => rules,
+      'metric_name_rules'      => rules
+    })
+  end
+
   class TestWidget
-    include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
+    include NewRelic::Agent::Instrumentation::ControllerInstrumentation
 
     def txn
       mthd
@@ -17,48 +31,26 @@ class RenameRuleTest < Test::Unit::TestCase
     add_method_tracer :mthd
   end
 
-  def setup
-    $collector ||= NewRelic::FakeCollector.new
-    $collector.reset
-    txn_rule_specs = [ { 'match_expression' => 'RenameRuleTest',
-                         'replacement' => 'Class' } ]
-    metric_rule_specs = [ { 'match_expression' => 'RenameRuleTest',
-                            'replacement' => 'Class' } ]
-    $collector.mock['connect'] = [200, {'return_value' => {
-                                      "agent_run_id" => 666,
-                            'transaction_name_rules' => txn_rule_specs,
-                                 'metric_name_rules' => metric_rule_specs
-                                    }}]
-    $collector.run
-
-    NewRelic::Agent.manual_start(:sync_startup => true,
-                                 :force_reconnect => true,
-                                 :port => $collector.port)
+  def test_transaction_names_rules
     TestWidget.new.txn
-  end
 
-  def teardown
-    NewRelic::Agent.instance.instance_variable_set(:@transaction_rules,
-                                       NewRelic::Agent::RulesEngine.new)
-    NewRelic::Agent.shutdown
-  end
+    metric_names = NewRelic::Agent.instance.stats_engine.metrics
 
-  def test_transaction_name_rules
-    metric_names = ::NewRelic::Agent.instance.stats_engine.metrics
-    assert(metric_names.include?('Controller/Class::TestWidget/txn'),
-           "'Controller/Class::TestWidget/txn' not found in #{metric_names}")
-    assert(metric_names.include?('Apdex/Class::TestWidget/txn'),
-           "'Apdex/Class::TestWidget/txn' not found in #{metric_names}")
-    assert(!metric_names.include?('Controller/RenameRuleTest::TestWidget/txn'),
-           "'Controller/RenameRuleTest::TestWidget/txn' should not be in #{metric_names}")
+    assert_includes(metric_names, 'Controller/Class::TestWidget/txn')
+    assert_includes(metric_names, 'Apdex/Class::TestWidget/txn')
+
+    assert_not_includes(metric_names, 'Controller/RenameRuleTest::TestWidget/txn')
   end
 
   def test_metric_name_rules
+    TestWidget.new.txn
+
     NewRelic::Agent.instance.send(:harvest_and_send_timeslice_data)
-    metric_names = $collector.calls_for('metric_data')[0].body[3].map{|m| m[0]['name']}
-    assert(metric_names.include?('Custom/Class::TestWidget/mthd'),
-           "'Custom/Class::TestWidget/mthd' not found in #{metric_names}")
-    assert(!metric_names.include?('Custom/RenameRuleTest::TestWidget/mthd'),
-           "'Custom/RenameRuleTest::TestWidget/mthd' should not be in #{metric_names}")
+    metric_names = $collector.calls_for('metric_data').first.metric_names
+
+    assert_includes(metric_names, 'Custom/Class::TestWidget/mthd')
+
+    assert_not_includes(metric_names, 'Custom/RenameRuleTest::TestWidget/mthd')
   end
+
 end

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

@@ -5,46 +5,45 @@
 require 'rack/test'
 require 'new_relic/rack/browser_monitoring'
 require './testing_app'
+require 'multiverse_helpers'
 
-class RumAutoTest < Test::Unit::TestCase
+class RumAutoTest < MiniTest::Unit::TestCase
 
   attr_reader :app
+
   include Rack::Test::Methods
+  include MultiverseHelpers
+
+  setup_and_teardown_agent(:browser_key => 'browserKey', :application_id => 'appId',
+                            :beacon => 'beacon', :episodes_file => 'this_is_my_file')
 
-  def setup
+  def after_setup
     @inner_app = TestingApp.new
     @app = NewRelic::Rack::BrowserMonitoring.new(@inner_app)
-
-    NewRelic::Agent.manual_start(:browser_key => 'browserKey', :application_id => 'appId',
-                                 :beacon => 'beacon', :episodes_file => 'this_is_my_file')
-    NewRelic::Agent.instance.instance_variable_set(
-      :@beacon_configuration, NewRelic::Agent::BeaconConfiguration.new)
   end
 
-  def teardown
-    NewRelic::Agent.shutdown
-  end
-
-  def test_autoinstrumenation_is_active
+  def test_autoinstrumentation_is_active
     @inner_app.response = "<html><head><title>W00t!</title></head><body><p>Hello World</p></body></html>"
     get '/'
     assert(last_response.body =~ %r|<script|, "response body should include RUM auto instrumentation js:\n #{last_response.body}")
     assert(last_response.body =~ %r|NREUMQ|, "response body should include RUM auto instrumentation js:\n #{last_response.body}")
   end
 
-  def test_autoinstrumenation_with_basic_page_puts_header_at_beggining_of_head
+  def test_autoinstrumentation_with_basic_page_puts_header_at_beginning_of_head
     @inner_app.response = "<html><head><title>foo</title></head><body><p>Hello World</p></body></html>"
+    NewRelic::Agent.logger.debug("================================")
     get '/'
+    NewRelic::Agent.logger.debug("================================")
     assert(last_response.body.include?('<html><head><script type="text/javascript">var NREUMQ=NREUMQ||[];NREUMQ.push(["mark","firstbyte",new Date().getTime()]);</script><title>foo</title></head><body>'))
   end
 
-  def test_autoinstrumenation_with_body_only_puts_header_before_body
+  def test_autoinstrumentation_with_body_only_puts_header_before_body
     @inner_app.response = "<html><body><p>Hello World</p></body></html>"
     get '/'
     assert(last_response.body.include?('<html><script type="text/javascript">var NREUMQ=NREUMQ||[];NREUMQ.push(["mark","firstbyte",new Date().getTime()]);</script><body>'))
   end
 
-  def test_autoinstrumenation_with_X_UA_Compatible_puts_header_at_end_of_head
+  def test_autoinstrumentation_with_X_UA_Compatible_puts_header_at_end_of_head
     @inner_app.response = '<html><head><meta http-equiv="X-UA-Compatible" content="IE=8;FF=3;OtherUA=4" /></head><body><p>Hello World</p></body></html>'
     get '/'
     assert(last_response.body.include?(
@@ -53,13 +52,13 @@ class RumAutoTest < Test::Unit::TestCase
   end
 
   # regression
-  def test_autoinstrumenation_fails_gracefully_with_X_UA_Compatible_and_no_close_head_tag_puts_header_before_body_tag
+  def test_autoinstrumentation_fails_gracefully_with_X_UA_Compatible_and_no_close_head_tag_puts_header_before_body_tag
     @inner_app.response = '<html><head><meta http-equiv="X-UA-Compatible" content="IE=8;FF=3;OtherUA=4" /><body><p>Hello World</p></body></html>'
     get '/'
     assert(!last_response.body.include?(%'NREUMQ'))
   end
 
-  def test_autoinstrumenation_doesnt_run_for_crazy_shit_like_this
+  def test_autoinstrumentation_doesnt_run_for_crazy_shit_like_this
     @inner_app.response = '<html><head <body </body>'
     get '/'
     assert_equal('<html><head <body </body>', last_response.body)
@@ -82,4 +81,3 @@ class RumAutoTest < Test::Unit::TestCase
     assert_equal(last_response.body, body)
   end
 end
-

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

@@ -4,12 +4,11 @@
 
 require 'socket'
 
-class ServiceTimeoutTest < Test::Unit::TestCase
-
-  PORT = 10_000 + ($$ % 10_000)
+class ServiceTimeoutTest < MiniTest::Unit::TestCase
 
   def setup
-    hk = TCPServer.new('127.0.0.1',PORT)
+    hk = TCPServer.new('127.0.0.1',0)
+    @port = hk.addr[1]
 
     Thread.new {
       client = hk.accept
@@ -21,12 +20,12 @@ class ServiceTimeoutTest < Test::Unit::TestCase
   end
 
   def test_service_timeout
-    server = NewRelic::Control::Server.new('localhost',PORT,'127.0.0.1')
+    server = NewRelic::Control::Server.new('localhost',@port,'127.0.0.1')
     NewRelic::Agent.config.apply_config(:timeout => 0.1)
 
-    service = NewRelic::Agent::NewRelicService.new('deadbeef', server)	
+    service = NewRelic::Agent::NewRelicService.new('deadbeef', server)
 
-    assert_raise Timeout::Error do
+    assert_raises Timeout::Error do
       service.send('send_request',
                    :uri => '/agent_listener/8/bd0e1d52adade840f7ca727d29a86249e89a6f1c/get_redirect_host',
                    :encoding => 'UTF-8', :collector => server, :data => 'blah')