newrelic_rpm 3.6.8.168 → 3.6.9.171

data/test/new_relic/http_client_test_cases.rb

@@ -38,7 +38,10 @@ module HttpClientTestCases
     NewRelic::Agent.instance.events.notify(:finished_configuring)
 
     @nr_header = nil
-    NewRelic::Agent.instance.events.subscribe(:after_call) do |_, (_, headers, _)|
+    # Don't use destructuring on result array with ignores since it fails
+    # on Rubinius: https://github.com/rubinius/rubinius/issues/2678
+    NewRelic::Agent.instance.events.subscribe(:after_call) do |_, result|
+      headers = result[1]
       headers[ NR_APPDATA_HEADER ] = @nr_header unless @nr_header.nil?
     end
 
@@ -258,6 +261,28 @@ module HttpClientTestCases
     ])
   end
 
+  def test_put
+    put_response
+
+    assert_metrics_recorded([
+      "External/all",
+      "External/localhost/#{client_name}/PUT",
+      "External/allOther",
+      "External/localhost/all"
+    ])
+  end
+
+  def test_delete
+    delete_response
+
+    assert_metrics_recorded([
+      "External/all",
+      "External/localhost/#{client_name}/DELETE",
+      "External/allOther",
+      "External/localhost/all"
+    ])
+  end
+
   # When an http call is made, the agent should add a request header named
   # X-NewRelic-ID with a value equal to the encoded cross_app_id.
 

data/test/new_relic/language_support_test.rb

@@ -5,41 +5,22 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
 
 class NewRelic::LanguageSupportTest < Test::Unit::TestCase
-  def test_object_space_enabled_true_without_jruby_with_object_space
-    undefine_constant(:JRuby) do
-      define_constant(:ObjectSpace, mock()) do
-        assert_truthy NewRelic::LanguageSupport.object_space_enabled?
-      end
-    end
-  end
+  include ::NewRelic::TestHelpers::RuntimeDetection
 
-  def test_object_space_enabled_false_without_object_space_without_jruby
-    undefine_constant(:ObjectSpace) do
-      undefine_constant(:JRuby) do
-        assert_falsy NewRelic::LanguageSupport.object_space_enabled?
-      end
-    end
+  def test_object_space_usable_on_jruby_with_object_space_enabled
+    return unless jruby?
+    JRuby.objectspace = true
+    assert_truthy NewRelic::LanguageSupport.object_space_usable?
   end
 
-  def test_object_space_enabled_true_if_enabled_in_jruby_without_object_space
-    fake_runtime = mock(:is_object_space_enabled => true)
-    fake_jruby = mock(:runtime => fake_runtime)
-
-    define_constant(:JRuby, fake_jruby) do
-      undefine_constant(:ObjectSpace) do
-        assert_truthy NewRelic::LanguageSupport.object_space_enabled?
-      end
-    end
+  def test_object_space_not_usable_on_jruby_with_object_space_disabled
+    return unless jruby?
+    JRuby.objectspace = false
+    assert_falsy NewRelic::LanguageSupport.object_space_usable?
   end
 
-  def test_object_space_enabled_false_if_disabled_in_jruby_without_object_space
-    fake_runtime = mock(:is_object_space_enabled => false)
-    fake_jruby = mock(:runtime => fake_runtime)
-
-    define_constant(:JRuby, fake_jruby) do
-      undefine_constant(:ObjectSpace) do
-        assert_falsy NewRelic::LanguageSupport.object_space_enabled?
-      end
-    end
+  def test_object_space_not_usable_on_rubinius
+    return unless rubinius?
+    assert_falsy NewRelic::LanguageSupport.object_space_usable?
   end
 end

data/test/new_relic/local_environment_test.rb

@@ -40,6 +40,8 @@ class NewRelic::LocalEnvironmentTest < Test::Unit::TestCase
   # around that interaction, so we don't run them on JRuby.
   unless defined?(JRuby)
     def test_mongrel_only_checks_once
+      return unless NewRelic::LanguageSupport.object_space_usable?
+
       define_mongrel
 
       # One call from LocalEnvironment's initialize, second from first #mongrel call.
@@ -50,10 +52,12 @@ class NewRelic::LocalEnvironmentTest < Test::Unit::TestCase
       5.times { e.mongrel }
       assert_nil e.mongrel
     ensure
-      Object.send(:remove_const, :Mongrel)
+      Object.send(:remove_const, :Mongrel) if defined?(Mongrel)
     end
 
     def test_check_for_mongrel_allows_one_more_check
+      return unless NewRelic::LanguageSupport.object_space_usable?
+
       define_mongrel
 
       ObjectSpace.expects(:each_object).with(::Mongrel::HttpServer).at_least(2)
@@ -61,7 +65,7 @@ class NewRelic::LocalEnvironmentTest < Test::Unit::TestCase
       e = NewRelic::LocalEnvironment.new
       e.send(:check_for_mongrel)
     ensure
-      Object.send(:remove_const, :Mongrel)
+      Object.send(:remove_const, :Mongrel) if defined?(Mongrel)
     end
   end
 

data/test/new_relic/multiverse_helpers.rb

@@ -53,18 +53,15 @@ module MultiverseHelpers
 
     # Renaming rules don't get cleared on connect--only appended to
     NewRelic::Agent.instance.transaction_rules.rules.clear
-    NewRelic::Agent.instance.metric_rules.rules.clear
+    NewRelic::Agent.instance.stats_engine.metric_rules.rules.clear
 
     # Clear out lingering stats we didn't transmit
     NewRelic::Agent.instance.reset_stats
 
     # Clear out lingering errors in the collector
-    NewRelic::Agent.instance.error_collector.harvest_errors(nil)
+    NewRelic::Agent.instance.error_collector.harvest_errors
     NewRelic::Agent.instance.error_collector.instance_variable_set(:@ignore_filter, nil)
 
-    # Clear out the request sampler!
-    NewRelic::Agent.instance.instance_variable_get(:@request_sampler).reset
-
     # Clean up any thread-local variables starting with 'newrelic'
     Thread.current.keys.select { |k| k.to_s =~ /^newrelic/i }.each do |key|
       Thread.current[key] = nil

data/test/new_relic/transaction_sample_test.rb

@@ -6,7 +6,8 @@ require File.expand_path('../../test_helper.rb', __FILE__)
 
 class NewRelic::TransactionSampleTest < Test::Unit::TestCase
   include TransactionSampleTestHelper
-  ::SQL_STATEMENT = "SELECT * from sandwiches"
+  ::SQL_STATEMENT = "SELECT * from sandwiches WHERE meat='bacon'"
+  ::OBFUSCATED_SQL_STATEMENT = "SELECT * from sandwiches WHERE meat=?"
 
   def setup
     @test_config = { :developer_mode => true }
@@ -32,38 +33,39 @@ class NewRelic::TransactionSampleTest < Test::Unit::TestCase
     assert_not_nil @t
   end
 
-  def test_not_record_sql_when_record_sql_off
-    s = @t.prepare_to_send(:explain_sql => 0.00000001)
+  def test_prepare_to_send_strips_sql_if_record_sql_omitted
+    s = @t.prepare_to_send!(:explain_sql => 0.00000001)
+
     s.each_segment do |segment|
       assert_nil segment.params[:explain_plan]
       assert_nil segment.params[:sql]
     end
   end
 
-  def test_record_raw_sql
-    s = @t.prepare_to_send(:explain_sql => 0.00000001, :record_sql => :raw)
-    got_one = false
+  def test_prepare_to_send_preserves_raw_sql_if_record_sql_set_to_raw
+    s = @t.prepare_to_send!(:record_sql => :raw)
+
+    sql_statements = []
     s.each_segment do |segment|
-      fail if segment.params[:obfuscated_sql]
-      got_one = got_one || segment.params[:explain_plan] || segment.params[:sql]
+      sql_statements << segment.params[:sql] if segment.params[:sql]
     end
-    assert got_one
-  end
 
-  def test_record_obfuscated_sql
+    assert_equal([::SQL_STATEMENT], sql_statements)
+  end
 
-    s = @t.prepare_to_send(:explain_sql => 0.00000001, :record_sql => :obfuscated)
+  def test_prepare_to_send_obfuscates_sql_if_record_sql_set_to_obfuscated
+    s = @t.prepare_to_send!(:record_sql => :obfuscated)
 
-    got_one = false
+    sql_statements = []
     s.each_segment do |segment|
-      got_one = got_one || segment.params[:explain_plan] || segment.params[:sql]
+      sql_statements << segment.params[:sql] if segment.params[:sql]
     end
 
-    assert got_one
+    assert_equal([::OBFUSCATED_SQL_STATEMENT], sql_statements)
   end
 
   def test_have_sql_rows_when_sql_is_recorded
-    s = @t.prepare_to_send(:explain_sql => 0.00000001)
+    s = @t.prepare_to_send!(:explain_sql => 0.00000001)
 
     assert s.sql_segments.empty?
     s.root_segment[:sql] = 'hello'
@@ -71,7 +73,7 @@ class NewRelic::TransactionSampleTest < Test::Unit::TestCase
   end
 
   def test_have_sql_rows_when_sql_is_obfuscated
-    s = @t.prepare_to_send(:explain_sql => 0.00000001)
+    s = @t.prepare_to_send!(:explain_sql => 0.00000001)
 
     assert s.sql_segments.empty?
     s.root_segment[:sql_obfuscated] = 'hello'
@@ -79,7 +81,7 @@ class NewRelic::TransactionSampleTest < Test::Unit::TestCase
   end
 
   def test_have_sql_rows_when_recording_non_sql_keys
-    s = @t.prepare_to_send(:explain_sql => 0.00000001)
+    s = @t.prepare_to_send!(:explain_sql => 0.00000001)
 
     assert s.sql_segments.empty?
     s.root_segment[:key] = 'hello'
@@ -89,11 +91,11 @@ class NewRelic::TransactionSampleTest < Test::Unit::TestCase
   def test_catch_exceptions
     @connection_stub.expects(:execute).raises
     # the sql connection will throw
-    @t.prepare_to_send(:record_sql => :obfuscated, :explain_sql => 0.00000001)
+    @t.prepare_to_send!(:record_sql => :obfuscated, :explain_sql => 0.00000001)
   end
 
   def test_have_explains
-    s = @t.prepare_to_send(:record_sql => :obfuscated, :explain_sql => 0.00000001)
+    s = @t.prepare_to_send!(:record_sql => :obfuscated, :explain_sql => 0.00000001)
 
     s.each_segment do |segment|
       if segment.params[:explain_plan]
@@ -111,7 +113,7 @@ class NewRelic::TransactionSampleTest < Test::Unit::TestCase
       t = make_sql_transaction(::SQL_STATEMENT, ::SQL_STATEMENT)
     end
 
-    s = t.prepare_to_send(:explain_sql => 0.00000001)
+    s = t.prepare_to_send!(:explain_sql => 0.00000001)
 
     s.each_segment do |segment|
       assert_nil segment.params[:explain_plan]
@@ -127,7 +129,7 @@ class NewRelic::TransactionSampleTest < Test::Unit::TestCase
   end
 
   def test_path_string
-    s = @t.prepare_to_send(:explain_sql => 0.1)
+    s = @t.prepare_to_send!(:explain_sql => 0.1)
     fake_segment = mock('segment')
     fake_segment.expects(:path_string).returns('a path string')
     s.instance_eval do
@@ -138,7 +140,7 @@ class NewRelic::TransactionSampleTest < Test::Unit::TestCase
   end
 
   def test_params_equals
-    s = @t.prepare_to_send(:explain_sql => 0.1)
+    s = @t.prepare_to_send!(:explain_sql => 0.1)
     s.params = {:params => 'hash' }
     assert_equal({:params => 'hash'}, s.params, "should have the specified hash, but instead was #{s.params}")
   end
@@ -148,7 +150,7 @@ class NewRelic::TransactionSampleTest < Test::Unit::TestCase
   end
 
   def test_to_s_with_bad_object
-    s = @t.prepare_to_send(:explain_sql => 0.1)
+    s = @t.prepare_to_send!(:explain_sql => 0.1)
     s.params[:fake] = Hat.new
     assert_raise(RuntimeError) do
       s.to_s
@@ -156,14 +158,14 @@ class NewRelic::TransactionSampleTest < Test::Unit::TestCase
   end
 
   def test_to_s_includes_keys
-    s = @t.prepare_to_send(:explain_sql => 0.1)
+    s = @t.prepare_to_send!(:explain_sql => 0.1)
     s.params[:fake_key] = 'a fake param'
     assert(s.to_s.include?('fake_key'), "should include 'fake_key' but instead was (#{s.to_s})")
     assert(s.to_s.include?('a fake param'), "should include 'a fake param' but instead was (#{s.to_s})")
   end
 
   def test_find_segment
-    s = @t.prepare_to_send(:explain_sql => 0.1)
+    s = @t.prepare_to_send!(:explain_sql => 0.1)
     fake_segment = mock('segment')
     fake_segment.expects(:find_segment).with(1).returns('a segment')
     s.instance_eval do
@@ -174,23 +176,38 @@ class NewRelic::TransactionSampleTest < Test::Unit::TestCase
   end
 
   def test_timestamp
-    s = @t.prepare_to_send(:explain_sql => 0.1)
+    s = @t.prepare_to_send!(:explain_sql => 0.1)
     assert(s.timestamp.instance_of?(Float), "s.timestamp should be a Float, but is #{s.timestamp.class.inspect}")
   end
 
   def test_xray_session_id
     @t.xray_session_id = 123
-    s = @t.prepare_to_send
+    s = @t.prepare_to_send!
     assert_equal(123, s.xray_session_id)
   end
 
-  def test_threshold
+  def test_prepare_to_send_marks_returned_sample_as_prepared
+    assert(!@t.prepared?)
+    prepared_sample = @t.prepare_to_send!
+    assert(prepared_sample.prepared?)
+  end
+
+  def test_prepare_to_send_does_not_re_prepare
+    opts = { :record_sql => :raw, :explain_sql => 0.00001 }
+    @t.prepare_to_send!(opts)
+
+    @t.expects(:collect_explain_plans!).never
+    @t.expects(:prepare_sql_for_transmission!).never
+
+    @t.prepare_to_send!(opts)
+  end
+
+  def test_threshold_preserved_by_prepare_to_send
     @t.threshold = 4.2
-    s = @t.prepare_to_send
+    s = @t.prepare_to_send!
     assert_equal(4.2, s.threshold)
   end
 
-
   def test_count_segments
     transaction = run_sample_trace_on(NewRelic::Agent::TransactionSampler.new) do |sampler|
       sampler.notice_push_scope "level0"
@@ -205,11 +222,15 @@ class NewRelic::TransactionSampleTest < Test::Unit::TestCase
   end
 
   def test_to_array
-    expected_array = [@t.start_time.to_f,
-                      @t.params[:request_params],
-                      @t.params[:custom_params],
-                      @t.root_segment.to_array]
-    assert_equal expected_array, @t.to_array
+    # Round-trip through Time.at makes minor rounding diffs in Rubinius
+    # Check each element separately so we can reconcile the delta
+    result = @t.to_array
+    assert_equal 4, result.length
+
+    assert_in_delta(@t.start_time.to_f, result[0], 0.000001)
+    assert_equal @t.params[:request_params], result[1]
+    assert_equal @t.params[:custom_params], result[2]
+    assert_equal @t.root_segment.to_array, result[3]
   end
 
 

data/test/performance/suites/config.rb

@@ -0,0 +1,76 @@
+# 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.
+
+class ConfigPerfTests < Performance::TestCase
+  def setup
+    @config = NewRelic::Agent::Configuration::Manager.new
+    @config.apply_config(:my_value => "boo")
+  end
+
+  def test_raw_access
+    iterations.times do
+      v = @config[:my_value]
+    end
+  end
+
+  def test_defaulting_access
+    iterations.times do
+      v = @config[:log_level]
+    end
+  end
+
+  def test_missing_key
+    iterations.times do
+      v = @config[:nope]
+    end
+  end
+
+  def test_blowing_cache
+    iterations.times do
+      @config.reset_cache
+      v = @config[:my_value]
+    end
+  end
+
+  def test_deep_config_stack_raw_access(timer)
+    with_deep_config_stack
+
+    timer.measure do
+      iterations.times do
+        v = @config[:my_value]
+      end
+    end
+  end
+
+  def test_deep_config_stack_defaulting_access(timer)
+    with_deep_config_stack
+
+    timer.measure do
+      iterations.times do
+        v = @config[:log_level]
+      end
+    end
+  end
+
+  def test_deep_config_stack_across_all_levels(timer)
+    keys = with_deep_config_stack
+
+    timer.measure do
+      iterations.times do
+        keys.each do |key|
+          v = @config[key]
+        end
+      end
+    end
+  end
+
+
+  def with_deep_config_stack
+    keys = (0..100).map {|i| "my_value_#{i}".to_sym}
+    keys.each do |key|
+      @config.apply_config(key => key)
+    end
+    keys
+  end
+end

data/test/rum/no_html_and_no_header.result.html

@@ -0,0 +1,3 @@
+|||I AM THE RUM HEADER|||<body>
+  This isn't great HTML but it's what we've got.
+|||I AM THE RUM FOOTER|||</body>

data/test/rum/no_html_and_no_header.source.html

@@ -0,0 +1,3 @@
+<body>
+  This isn't great HTML but it's what we've got.
+</body>

data/test/script/ci.sh

@@ -66,8 +66,6 @@ echo `which ruby`
 ruby -v
 gem --version
 
-rake -h > /dev/null || gem install rake
-
 # make sure that we're in the project root
 script_dirname=`dirname $0`
 cd "$script_dirname/../../"