newrelic_rpm 3.6.5.130 → 3.6.6.147

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

@@ -2,9 +2,16 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
-class SetTransactionNameTest < Test::Unit::TestCase
+require 'multiverse_helpers'
+
+class SetTransactionNameTest < MiniTest::Unit::TestCase
   include NewRelic::Agent::MethodTracer
 
+  include MultiverseHelpers
+
+  setup_and_teardown_agent(:browser_key => 'browserKey', :application_id => 'appId',
+                           :beacon => 'beacon', :episodes_file => 'this_is_my_file')
+
   class TestTransactor
     include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
     def parent_txn
@@ -25,46 +32,33 @@ class SetTransactionNameTest < Test::Unit::TestCase
     end
   end
 
-  def setup
-    NewRelic::Agent.manual_start(:browser_key => 'browserKey', :application_id => 'appId',
-                                 :beacon => 'beacon', :episodes_file => 'this_is_my_file')
-    @transactor = TestTransactor.new
-    @stats_engine = NewRelic::Agent.instance.stats_engine
-  end
-
-  def teardown
-    NewRelic::Agent.shutdown
-  end
-
   def test_apply_to_metric_names
-    @transactor.parent_txn
-    [ 'Controller/TestTransactor/parent',
+    TestTransactor.new.parent_txn
+
+    assert_metrics_recorded([
+      'Controller/TestTransactor/parent',
       'OtherTransaction/Background/TestTransactor/child',
-      [ 'OtherTransaction/Background/TestTransactor/child',
-        'Controller/TestTransactor/parent'],
-      'Apdex/TestTransactor/parent' ].each do |metric|
-      assert(@stats_engine.lookup_stats(*metric),
-             "Expected to find #{metric} in stats hash #{NewRelic::Agent.instance.stats_engine.instance_variable_get(:@stats_hash)}")
-    end
+      [ 'OtherTransaction/Background/TestTransactor/child', 'Controller/TestTransactor/parent'],
+      'Apdex/TestTransactor/parent'])
   end
 
   def test_apply_to_metric_scopes
-    @transactor.parent_txn do
+    TestTransactor.new.parent_txn do
       trace_execution_scoped('Custom/something') {}
     end
-    assert @stats_engine.lookup_stats('Custom/something',
-                                      'Controller/TestTransactor/parent')
+    assert_metrics_recorded(['Custom/something',
+                             'Controller/TestTransactor/parent'])
   end
 
   def test_apply_to_traced_transactions
-    @transactor.parent_txn
+    TestTransactor.new.parent_txn
     assert_equal('Controller/TestTransactor/parent',
                  NewRelic::Agent.instance.transaction_sampler.last_sample \
                    .params[:path])
   end
 
   def test_apply_to_traced_errors
-    @transactor.parent_txn do
+    TestTransactor.new.parent_txn do
       NewRelic::Agent.notice_error(RuntimeError.new('toot'))
     end
     assert_equal('Controller/TestTransactor/parent',
@@ -75,22 +69,22 @@ class SetTransactionNameTest < Test::Unit::TestCase
     rule = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => 'parent',
                                                   'replacement'      => 'dad')
     NewRelic::Agent.instance.transaction_rules << rule
-    @transactor.parent_txn
-    assert @stats_engine.lookup_stats('Controller/TestTransactor/dad')
+    TestTransactor.new.parent_txn
+    assert_metrics_recorded(['Controller/TestTransactor/dad'])
   end
 
   def test_does_not_overwrite_name_when_set_by_RUM
-    @transactor.parent_txn do
+    TestTransactor.new.parent_txn do
       NewRelic::Agent.browser_timing_header
       NewRelic::Agent.browser_timing_footer
       NewRelic::Agent.set_transaction_name('this/should/not/work')
     end
-    assert_nil @stats_engine.lookup_stats('Controller/this/should/not/work')
-    assert @stats_engine.lookup_stats('Controller/TestTransactor/parent')
+    assert_metrics_not_recorded(['Controller/this/should/not/work'])
+    assert_metrics_recorded(['Controller/TestTransactor/parent'])
   end
 
   def test_ignoring_action
-    @transactor.ignored_txn
-    assert_nil @stats_engine.lookup_stats('Controller/Ignore/me')
+    TestTransactor.new.ignored_txn
+    assert_metrics_not_recorded(['Controller/Ignore/me'])
   end
 end

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

@@ -2,25 +2,21 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
-class SSLTest < Test::Unit::TestCase
+require 'multiverse_helpers'
+
+class SSLTest < MiniTest::Unit::TestCase
+
+  include MultiverseHelpers
 
   def setup
-    # This is similar to how jruby 1.6.8 behaves when jruby-openssl isn't
-    # installed
-    @original_ssl_config = NewRelic::Agent.config[:ssl]
-    NewRelic::Agent.config.apply_config(:ssl => true)
-    NewRelic::Agent.agent = NewRelic::Agent::Agent.new
+    # Similar to how jruby 1.6.8 behaves when jruby-openssl isn't installed
     Net::HTTPSession.any_instance.stubs('use_ssl=').raises(LoadError)
   end
 
-  def teardown
-    NewRelic::Agent.config.apply_config(:ssl => @original_ssl_config)
-  end
-
   def test_agent_shuts_down_when_ssl_is_on_but_unavailable
-    ::NewRelic::Agent.agent.expects(:shutdown)
-    ::NewRelic::Agent.expects(:finish_setup).never
-    ::NewRelic::Agent.agent.connect_in_foreground
-  ensure
+    NewRelic::Agent.agent.expects(:shutdown).at_least_once
+    NewRelic::Agent.expects(:finish_setup).never
+
+    run_agent(:ssl => true)
   end
 end

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

@@ -5,7 +5,7 @@
 # RUBY-839 make sure there is no STDOUT chatter
 require 'open3'
 
-class StartUpTest < Test::Unit::TestCase
+class StartUpTest < MiniTest::Unit::TestCase
   def test_should_not_print_to_stdout_when_logging_available
     ruby = 'require "newrelic_rpm"; NewRelic::Agent.manual_start; NewRelic::Agent.shutdown'
     cmd = "bundle exec ruby -e '#{ruby}'"

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

@@ -2,6 +2,8 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
+require 'new_relic/agent/instrumentation/rack'
+
 class TestingApp
 
   attr_accessor :response, :headers

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

@@ -6,28 +6,28 @@
 # https://newrelic.atlassian.net/browse/RUBY-917
 
 if RUBY_VERSION >= '1.9'
-class ThreadProfilingTest < Test::Unit::TestCase
-  def setup
-    $collector ||= NewRelic::FakeCollector.new
-    $collector.reset
-    $collector.mock['connect'] = [200, {'return_value' => {"agent_run_id" => 666 }}]
-    $collector.mock['get_agent_commands'] = [200, {'return_value' => START_COMMAND}]
-    $collector.mock['agent_command_results'] = [200, {'return_value' => []}]
-    $collector.run
-
-    NewRelic::Agent::Agent.instance_variable_set(:@instance, nil)
-    NewRelic::Agent.manual_start(:'thread_profiler.enabled' => true, :force_send => true)
-    NewRelic::Agent.instance.service.request_timeout = 0.5
-    NewRelic::Agent.instance.service.agent_id = 666
-
-    @agent = NewRelic::Agent.instance
-    @thread_profiler = @agent.thread_profiler
-    @threads = []
+
+require 'multiverse_helpers'
+
+class ThreadProfilingTest < MiniTest::Unit::TestCase
+
+  include MultiverseHelpers
+
+  setup_and_teardown_agent(:'thread_profiler.enabled' => true, :force_send => true) do |collector|
+    collector.stub('connect', {"agent_run_id" => 666 })
+    collector.stub('get_agent_commands', START_COMMAND)
+    collector.stub('agent_command_results', [])
   end
 
-  def teardown
-    $collector.reset
+  def after_setup
+    agent.service.request_timeout = 0.5
+    agent.service.agent_id = 666
 
+    @thread_profiler = agent.thread_profiler
+    @threads = []
+  end
+
+  def after_teardown
     @threads.each { |t| t.kill }
     @threads = nil
   end
@@ -60,7 +60,7 @@ class ThreadProfilingTest < Test::Unit::TestCase
   # go only let a few cycles through, so we check less than 10
 
   def test_thread_profiling
-    @agent.send(:check_for_agent_commands)
+    agent.send(:check_for_agent_commands)
 
     run_thread { NewRelic::Agent::Transaction.start(:controller, :request => stub) }
     run_thread { NewRelic::Agent::Transaction.start(:task) }
@@ -78,10 +78,10 @@ class ThreadProfilingTest < Test::Unit::TestCase
   end
 
   def test_thread_profiling_can_stop
-    @agent.send(:check_for_agent_commands)
+    agent.send(:check_for_agent_commands)
 
     $collector.mock['get_agent_commands'] = [200, {'return_value' => STOP_COMMAND}]
-    @agent.send(:check_for_agent_commands)
+    agent.send(:check_for_agent_commands)
 
     let_it_finish
 
@@ -105,7 +105,7 @@ class ThreadProfilingTest < Test::Unit::TestCase
       end
     end
 
-    @agent.send(:transmit_data, true)
+    agent.send(:transmit_data, true)
   end
 
   def assert_saw_traces(profile_data, type)
@@ -114,4 +114,3 @@ class ThreadProfilingTest < Test::Unit::TestCase
 
 end
 end
-

data/test/multiverse/suites/config_file_loading/Envfile

@@ -1,9 +1,13 @@
-# don't start the agent
-self.newrelic_gemfile_options=(':require => false')
+omit_collector!
+
 gemfile <<-RB
   # stub file system so we can test that newrelic.yml can be loaded from
   # various places.
   gem 'fakefs', :require => 'fakefs/safe'
 
+  # Because we delay the agent, order of jruby-openssl matters
   gem 'jruby-openssl', :platforms => [:jruby]
+
+  # don't start the agent
+  gem 'newrelic_rpm', :require => false, :path => File.expand_path('../../../../')
 RB

data/test/multiverse/suites/config_file_loading/config_file_loading_test.rb

@@ -13,7 +13,11 @@
 #
 # If this fails the agent will attempt to dial Lew Cirne's cell phone and ask
 # that he verbally describe how it should be configured.
-class ConfigFileLoadingTest < Test::Unit::TestCase
+
+require 'multiverse_helpers'
+
+class ConfigFileLoadingTest < MiniTest::Unit::TestCase
+  include MultiverseHelpers
 
   def setup
     # While FakeFS stubs out all the File system related libraries (i.e. File,
@@ -45,7 +49,8 @@ class ConfigFileLoadingTest < Test::Unit::TestCase
   end
 
   def setup_config(path, manual_config_options = {})
-    NewRelic::Agent.shutdown
+    teardown_agent
+
     FileUtils.mkdir_p(File.dirname(path))
     Dir.chdir @cwd
     File.open(path, 'w') do |f|
@@ -58,8 +63,7 @@ bazbangbarn:
   i_am: "bazbangbarn"
       YAML
     end
-    NewRelic::Agent.reset_config
-    NewRelic::Agent.manual_start(manual_config_options)
+    setup_agent(manual_config_options)
   end
 
   def assert_config_read_from(path)

data/test/multiverse/suites/curb/Envfile

@@ -0,0 +1,19 @@
+suite_condition("Curb is not useful on JRuby") do
+  RUBY_PLATFORM != 'java'
+end
+
+gemfile <<-RB
+  gem 'curb', '0.8.1'
+  gem 'rack'
+  if RUBY_VERSION < '1.9.0'
+    gem 'json'
+  end
+RB
+
+gemfile <<-RB
+  gem 'curb', '~> 0.8.4'
+  gem 'rack'
+  if RUBY_VERSION < '1.9.0'
+    gem 'json'
+  end
+RB

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

@@ -0,0 +1,19 @@
+---
+development:
+  error_collector:
+    capture_source: true
+    enabled: true
+  apdex_t: 0.5
+  ssl: false
+  monitor_mode: true
+  license_key: bootstrap_newrelic_admin_license_key_000
+  developer_mode: false
+  app_name: test
+  host: 127.0.0.1
+  api_host: 127.0.0.1
+  transaction_tracer:
+    record_sql: obfuscated
+    enabled: true
+    stack_trace_threshold: 0.5
+    transaction_threshold: 1.0
+  capture_params: false

data/test/multiverse/suites/curb/curb_test.rb

@@ -0,0 +1,195 @@
+# 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 'curb'
+
+require 'newrelic_rpm'
+require 'test/unit'
+require 'http_client_test_cases'
+require 'new_relic/agent/http_clients/curb_wrappers'
+
+require File.join(File.dirname(__FILE__), "..", "..", "..", "agent_helper")
+
+class CurbTest < MiniTest::Unit::TestCase
+
+  #
+  # Tests
+  #
+
+  include HttpClientTestCases
+
+
+  def test_shouldnt_clobber_existing_header_callback
+    headers = []
+    Curl::Easy.http_get( default_url ) do |handle|
+      handle.on_header do |header|
+        headers << header
+        header.length
+      end
+    end
+
+    assert !headers.empty?
+  end
+
+  def test_shouldnt_clobber_existing_completion_callback
+    completed = false
+    Curl::Easy.http_get( default_url ) do |handle|
+      handle.on_complete do
+        completed = true
+      end
+    end
+
+    assert completed, "completion block was never run"
+  end
+
+  def test_get_works_with_the_shortcut_api
+    # Override the mechanism for getting a response and run the test_get test
+    # again
+    @get_response_proc = Proc.new do |url|
+      Curl.get( url || default_url )
+    end
+    test_get
+  ensure
+    @get_response_proc = nil
+  end
+
+  def test_background_works_with_the_shortcut_api
+    # Override the mechanism for getting a response and run test_background again
+    @get_response_proc = Proc.new do |url|
+      Curl.get( url || default_url )
+    end
+    test_background
+  ensure
+    @get_response_proc = nil
+  end
+
+  def test_get_via_shortcut_api_preserves_header_str
+    rsp = Curl.get( default_url )
+    header_str = rsp.header_str
+
+    # Make sure that we got something that looks like a header string
+    assert_match(/^HTTP\/1\.1 200 OK\s+$/, header_str)
+    assert_match(/^Content-Length: \d+\s+$/, header_str)
+
+    # Make sure there are no lines that appear multiple times, which would
+    # happen if we installed callbacks repeatedly on one request.
+    header_lines = header_str.split
+    assert_equal(header_lines.uniq.size, header_lines.size,
+      "Found some header lines appearing multiple times in header_str:\n#{header_str}")
+  end
+
+  def test_get_doesnt_destroy_ability_to_call_status
+    status_code = Curl.get( default_url ).status.to_i
+    assert_equal(200, status_code)
+  end
+
+
+  # Curl.head is broken in 0.8.4 (https://github.com/taf2/curb/pull/148), but if
+  # it ever gets fixed, then this test should be uncommented.
+
+  # def test_head_works_with_the_shortcut_api
+  #   # Override the mechanism for getting a response and run the test_get test
+  #   # again
+  #   def self.head_response
+  #     Curl.head( default_url )
+  #   end
+  # 
+  #   test_head
+  # end
+
+  def test_doesnt_propagate_errors_in_instrumentation
+    NewRelic::Agent::CrossAppTracing.stubs( :start_trace ).
+      raises( StandardError, "something bad happened" )
+
+    res = Curl::Easy.http_get( default_url )
+
+    assert_kind_of Curl::Easy, res
+  end
+
+
+  def test_works_with_parallel_fetches
+    results = []
+    other_url = "http://localhost:#{$fake_server.port}/"
+
+    in_transaction("test") do
+      Curl::Multi.get( [default_url,other_url] ) do |easy|
+        results << easy.body_str
+      end
+
+      results.each do |res|
+        assert_match %r/<head>/i, res
+      end
+
+      last_segment = find_last_transaction_segment()
+      assert_equal "External/Multiple/Curb::Multi/perform", last_segment.metric_name
+    end
+  end
+
+  def test_block_passed_to_multi_perform_should_be_called
+    successes = 0
+    num_requests = 2
+    perform_block_called = false
+
+    in_transaction("test") do
+      multi = Curl::Multi.new
+
+      num_requests.times do |i|
+        req = Curl::Easy.new(default_url) do |easy|
+          easy.on_success { |curl| successes += 1 }
+        end
+        multi.add(req)
+      end
+
+      multi.perform { perform_block_called = true }
+
+      assert_equal(num_requests, successes)
+      assert(perform_block_called, "Block passed to Curl::Multi.perform should have been called")
+      last_segment = find_last_transaction_segment()
+      assert_equal "External/Multiple/Curb::Multi/perform", last_segment.metric_name
+    end
+  end
+
+  #
+  # Helper functions
+  #
+
+  def client_name
+    "Curb"
+  end
+
+  def get_response(url=nil)
+    if @get_response_proc
+      @get_response_proc.call(url)
+    else
+      Curl::Easy.http_get( url || default_url )
+    end
+  end
+
+  def head_response
+    Curl::Easy.http_head( default_url )
+  end
+
+  def post_response
+    Curl::Easy.http_post( default_url, '' )
+  end
+
+  def body(res)
+    res.body_str
+  end
+
+  def request_instance
+    NewRelic::Agent::HTTPClients::CurbRequest.new(Curl::Easy.new)
+  end
+
+  def response_instance( headers={} )
+    res = NewRelic::Agent::HTTPClients::CurbResponse.new(Curl::Easy.new)
+    headers.each do |hdr, val|
+      res.append_header_data( "#{hdr}: #{val}")
+    end
+
+    return res
+  end
+
+end
+