newrelic_rpm 3.9.1.236 → 3.9.2.239

data/test/new_relic/agent_test.rb

@@ -13,6 +13,7 @@ module NewRelic
     include NewRelic::Agent::MethodTracer
 
     def setup
+      NewRelic::Agent.manual_start
       NewRelic::Agent.reset_config
       NewRelic::Agent.instance.stubs(:start_worker_thread)
     end
@@ -45,9 +46,10 @@ module NewRelic
     end
 
     def test_finish_setup_applied_server_side_config
-      with_config({ :'transction_tracer.enabled' => true,
-                    'error_collector.enabled' => true,
-                    :log_level => 'info' }, :level => 2) do
+      with_config_low_priority({
+                    :'transction_tracer.enabled' => true,
+                    :'error_collector.enabled' => true,
+                    :log_level => 'info' }) do
         NewRelic::Agent.instance.finish_setup('log_level' => 'debug',
          'agent_config' => { 'transaction_tracer.enabled' => false },
                                          'collect_errors' => false)
@@ -104,13 +106,17 @@ module NewRelic
       NewRelic::Agent.get_stats_no_scope('Custom/test/metric')
     end
 
-    def test_agent_not_started
-      old_agent = NewRelic::Agent.agent
-      NewRelic::Agent.instance_eval { @agent = nil }
-      assert_raises(RuntimeError) do
+    def test_agent_logs_warning_when_not_started
+      with_unstarted_agent do
+        expects_logging(:warn, includes("hasn't been started"))
         NewRelic::Agent.agent
       end
-      NewRelic::Agent.instance_eval { @agent = old_agent }
+    end
+
+    def test_agent_can_shut_down_when_not_started
+      with_unstarted_agent do
+        NewRelic::Agent.shutdown
+      end
     end
 
     def test_agent_when_started
@@ -176,6 +182,7 @@ module NewRelic
     end
 
     def test_instance
+      NewRelic::Agent.manual_start
       assert_equal(NewRelic::Agent.agent, NewRelic::Agent.instance, "should return the same agent for both identical methods")
     end
 
@@ -371,8 +378,40 @@ module NewRelic
       assert called
     end
 
+    # The assumption is that txn.ignore! works as expected, and is tested elsewhere.
+    def test_ignore_transaction_works
+      in_transaction do |txn|
+        NewRelic::Agent.ignore_transaction
+        assert txn.ignore?
+      end
+    end
+
+    # The assumption is that txn.ignore_apdex! works as expected, and is tested elsewhere.
+    def test_ignore_apdex_works
+      in_transaction do |txn|
+        NewRelic::Agent.ignore_apdex
+        assert txn.ignore_apdex?
+      end
+    end
+
+    # The assumption is that txn.ignore_enduser! works as expected, and is tested elsewhere.
+    def test_ignore_enduser_works
+      in_transaction do |txn|
+        NewRelic::Agent.ignore_enduser
+        assert txn.ignore_enduser?
+      end
+    end
+
     private
 
+    def with_unstarted_agent
+      old_agent = NewRelic::Agent.agent
+      NewRelic::Agent.instance_eval { @agent = nil }
+      yield
+    ensure
+      NewRelic::Agent.instance_eval { @agent = old_agent }
+    end
+
     def mocked_agent
       agent = mock('agent')
       NewRelic::Agent.stubs(:agent).returns(agent)

data/test/new_relic/collection_helper_test.rb

@@ -50,7 +50,7 @@ class NewRelic::CollectionHelperTest < Minitest::Test
     assert_equal String, truncate(s, 2).class
   end
   def test_number
-    np = normalize_params({ 'one' => 1.0, 'two' => '2'})
+    normalize_params({ 'one' => 1.0, 'two' => '2'})
   end
   def test_nil
     np = normalize_params({ nil => 1.0, 'two' => nil})
@@ -83,7 +83,7 @@ class NewRelic::CollectionHelperTest < Minitest::Test
     custom_params = { :one => {:hash => { :a => :b}, :myenum => e }}
     nh = normalize_params(custom_params)
     myenum = nh[:one][:myenum]
-    assert_match /MyEnumerable/, myenum
+    assert_match(/MyEnumerable/, myenum)
   end
 
   def test_stringio
@@ -91,13 +91,13 @@ class NewRelic::CollectionHelperTest < Minitest::Test
     s = StringIO.new "start" + ("foo bar bat " * 1000)
     val = nil
     s.each { | entry | val = entry; break }
-    assert_match /^startfoo bar/, val
+    assert_match(/^startfoo bar/, val)
 
     # make sure stringios aren't affected by calling normalize_params:
     s = StringIO.new "start" + ("foo bar bat " * 1000)
-    v = normalize_params({ :foo => s.string })
+    normalize_params({ :foo => s.string })
     s.each { | entry | val = entry; break }
-    assert_match /^startfoo bar/, val
+    assert_match(/^startfoo bar/, val)
   end
   class MyEnumerable
     include Enumerable

data/test/new_relic/control/instrumentation_test.rb

@@ -0,0 +1,56 @@
+# 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'))
+require 'new_relic/control/instrumentation'
+
+class InstrumentationTestClass
+  include NewRelic::Control::Instrumentation
+
+  def initialize
+    @instrumentation_files = []
+  end
+end
+
+class NewRelic::Control::InstrumentationTest < Minitest::Test
+  def setup
+    @test_class = InstrumentationTestClass.new
+  end
+
+  def test_load_instrumentation_files_logs_errors_during_require
+    @test_class.stubs(:require).raises('Instrumentation Test Error')
+    expects_logging(:warn, includes("Error loading"), any_parameters)
+    @test_class.load_instrumentation_files '*'
+  end
+
+  def test_add_instrumentation_loads_the_instrumentation_files_if_instrumented
+    pattern = 'Instrumentation test pattern'
+    @test_class.instance_eval { @instrumented = true }
+    @test_class.expects(:load_instrumentation_files).with(pattern).once
+    @test_class.add_instrumentation(pattern)
+  end
+
+  def test_add_instrumentation_adds_pattern_to_instrumentation_files_if_uninstrumented
+    expected_pattern = 'Instrumentation test pattern'
+    @test_class.instance_eval { @instrumented = false }
+    @test_class.add_instrumentation(expected_pattern)
+    result = @test_class.instance_variable_get(:@instrumentation_files)
+    assert_equal [expected_pattern], result
+  end
+
+  def test_install_shim_logs_if_instrumentation_has_already_been_installed
+    @test_class.instance_eval { @instrumented = true }
+    expects_logging(:error, includes('Cannot install'))
+    @test_class.install_shim
+  end
+
+  def test_install_shim_does_not_set_agent_if_already_instrumented
+    fake_shim = "Instrumentation Test Shim Agent"
+    @test_class.instance_eval { @instrumented = true }
+    NewRelic::Agent::ShimAgent.class_eval { @instance = fake_shim }
+
+    @test_class.install_shim
+    refute_equal NewRelic::Agent.agent, fake_shim
+  end
+end

data/test/new_relic/control_test.rb

@@ -31,7 +31,7 @@ class NewRelic::ControlTest < Minitest::Test
   def test_info
     NewRelic::Agent.manual_start
     if defined?(Rails::VERSION)
-      assert_match /jdbc|postgres|mysql|sqlite/, NewRelic::EnvironmentReport.new["Database adapter"]
+      assert_match(/jdbc|postgres|mysql|sqlite/, NewRelic::EnvironmentReport.new["Database adapter"])
     end
   end
 
@@ -151,9 +151,10 @@ class NewRelic::ControlTest < Minitest::Test
   end
 
   def test_sql_tracer_disabled_when_tt_disabled_by_server
-    with_config({:'slow_sql.enabled'           => true,
+    with_config_low_priority({
+                 :'slow_sql.enabled'           => true,
                  :'transaction_tracer.enabled' => true,
-                 :monitor_mode                 => true}, :level => 2) do
+                 :monitor_mode                 => true}) do
       NewRelic::Agent.instance.finish_setup('collect_traces' => false)
 
       refute NewRelic::Agent::Agent.instance.sql_sampler.enabled?,

data/test/new_relic/fake_collector.rb

@@ -104,7 +104,7 @@ module NewRelic
 
       if uri.path =~ /agent_listener\/\d+\/.+\/(\w+)/
         method = $1
-        format = json_format?(uri) && RUBY_VERSION >= '1.9' ? :json : :pruby
+        format = json_format?(uri) ? :json : :pruby
         if @mock.keys.include? method
           status, body = @mock[method].evaluate
           res.status = status
@@ -133,8 +133,13 @@ module NewRelic
             # rely on strings to compare against in fake collector results.
             body = NewRelic::JSONWrapper.normalize(body)
           end
-        rescue => err
+        rescue
           body = "UNABLE TO DECODE BODY: #{raw_body}"
+
+          # Since this is for testing, output failure at this point. If we
+          # don't your only evidence of a problem is in obscure test failures
+          # from not receiving the data you expect.
+          puts body
         end
 
         @agent_data << AgentPost.create(:action       => method,

data/test/new_relic/http_client_test_cases.rb

@@ -183,7 +183,7 @@ module HttpClientTestCases
 
   def test_transactional_traces_nodes
     perform_action_with_newrelic_trace(:name => "task") do
-      res = get_response
+      get_response
 
       last_segment = find_last_transaction_segment()
       assert_equal "External/localhost/#{client_name}/GET", last_segment.metric_name
@@ -193,7 +193,7 @@ module HttpClientTestCases
   def test_ignore
     in_transaction do
       NewRelic::Agent.disable_all_tracing do
-        res = post_response
+        post_response
       end
     end
 
@@ -201,7 +201,7 @@ module HttpClientTestCases
   end
 
   def test_head
-    res = head_response
+    head_response
     assert_externals_recorded_for("localhost", "HEAD")
   end
 
@@ -466,7 +466,7 @@ module HttpClientTestCases
       in_transaction do
         begin
           get_response("http://localhost:#{evil_server.port}")
-        rescue => e
+        rescue
           # it's expected that this will raise for some HTTP libraries (e.g.
           # Net::HTTP). we unfortunately don't know the exact exception class
           # across all libraries

data/test/new_relic/latest_changes_test.rb

@@ -20,13 +20,13 @@ module NewRelic
 
     def test_read_default_changelog
       result = NewRelic::LatestChanges.read
-      assert_match /# New Relic Ruby Agent Release Notes #/, result
-      assert_match /## v\d\.\d\.\d ##/, result
+      assert_match(/# New Relic Ruby Agent Release Notes #/, result)
+      assert_match(/## v\d\.\d\.\d ##/, result)
     end
 
     def test_latest_changes_from_fakechangelog
       result = NewRelic::LatestChanges.read(File.join(File.dirname(__FILE__), 'FAKECHANGELOG'))
-      assert_match /3.7.2/, result
+      assert_match(/3.7.2/, result)
     end
 
     def test_patch_latest_changes_from_fakechangelog

data/test/new_relic/transaction_sample/segment_test.rb

@@ -319,7 +319,6 @@ class NewRelic::TransactionSample::SegmentTest < Minitest::Test
     statement.config = config
     statement.explainer = NewRelic::Agent::Instrumentation::ActiveRecord::EXPLAINER
     s.params = {:sql => statement}
-    connection = mock('connection')
     NewRelic::Agent::Database.expects(:get_connection).with(config).raises(RuntimeError.new("whee"))
     s.explain_sql
   end

data/test/new_relic/transaction_sample_test.rb

@@ -270,7 +270,15 @@ class NewRelic::TransactionSampleTest < Minitest::Test
                       trace_tree,
                       @t.guid, nil, !!@t.force_persist, @t.xray_session_id]
 
-    assert_equal expected_array, @t.to_collector_array(@marshaller.default_encoder)
+    assert_collector_arrays_match expected_array, @t.to_collector_array(@marshaller.default_encoder)
+
+  end
+
+  def assert_collector_arrays_match(expected_array, actual_array)
+    expected_array[4] = expand_trace_tree(expected_array[4])
+    actual_array[4]   = expand_trace_tree(actual_array[4])
+
+    assert_equal expected_array, actual_array
   end
 
   FORCE_PERSIST_POSITION = 7
@@ -294,7 +302,8 @@ class NewRelic::TransactionSampleTest < Minitest::Test
       transaction.guid,
       nil, false, nil]
 
-    assert_equal expected, transaction.to_collector_array(@marshaller.default_encoder)
+    actual = transaction.to_collector_array(@marshaller.default_encoder)
+    assert_collector_arrays_match expected, actual
   end
 
   INVALID_UTF8_STRING = (''.respond_to?(:force_encoding) ? "\x80".force_encoding('UTF-8') : "\x80")
@@ -324,6 +333,14 @@ class NewRelic::TransactionSampleTest < Minitest::Test
     Base64.encode64(Zlib::Deflate.deflate(string, Zlib::DEFAULT_COMPRESSION))
   end
 
+  def expand_trace_tree(encoded_tree)
+    if NewRelic::Agent::NewRelicService::JsonMarshaller.is_supported?
+      JSON.load(Zlib::Inflate.inflate(Base64.decode64(encoded_tree)))
+    else
+      encoded_tree
+    end
+  end
+
   def extract_captured_sql(trace)
     sqls = []
     trace.each_segment do |s|

data/test/performance/lib/performance/runner.rb

@@ -52,10 +52,10 @@ module Performance
     end
 
     def add_progress_callbacks(test_case)
-      test_case.on(:before_each) do |test_case, name|
+      test_case.on(:before_each) do |_test_case, name|
         print "#{name}: "
       end
-      test_case.on(:after_each) do |test_case, name, result|
+      test_case.on(:after_each) do |_test_case, name, result|
         print "#{result.elapsed} s\n"
       end
     end
@@ -104,7 +104,7 @@ module Performance
         filter = Regexp.new(@options[:name])
         methods = methods.select { |m| m.match(filter) }
       elsif @options[:identifier]
-        suite, method = @options[:identifier].split('#')
+        _suite, method = @options[:identifier].split('#')
         methods = methods.select { |m| m == method }
       end
       methods
@@ -174,7 +174,7 @@ module Performance
 
     def suites_to_run
       if @options[:identifier]
-        suite, method = @options[:identifier].split('#')
+        suite, _method = @options[:identifier].split('#')
         TestCase.subclasses.select { |cls| cls.name == suite }
       elsif @options[:suite]
         TestCase.subclasses.select { |cls| cls.name == @options[:suite] }

data/test/performance/suites/marshalling.rb

@@ -2,56 +2,64 @@
 # 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')
+
 class Marshalling < Performance::TestCase
   def setup
     @payload = build_analytics_events_payload
     @tt_payload = build_transaction_trace_payload
   end
 
-  skip_test :test_basic_marshalling_json, :platforms => :mri_18
-
   def test_basic_marshalling_json(timer)
-    marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
-    timer.measure do
-      (iterations / 100).times do
-        marshaller.dump(@payload)
-        marshaller.dump(@tt_payload)
+    with_config(:normalize_json_string_encodings => true) do
+      marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
+      timer.measure do
+        (iterations / 100).times do
+          marshaller.dump(@payload)
+          marshaller.dump(@tt_payload)
+        end
       end
     end
   end
 
   def test_json_marshalling_binary_strings(timer)
-    marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
-    convert_strings_to_binary(@payload)
-    convert_strings_to_binary(@tt_payload)
-    timer.measure do
-      (iterations / 100).times do
-        marshaller.dump(@payload)
-        marshaller.dump(@tt_payload)
+    with_config(:normalize_json_string_encodings => true) do
+      marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
+      convert_strings_to_binary(@payload)
+      convert_strings_to_binary(@tt_payload)
+      timer.measure do
+        (iterations / 100).times do
+          marshaller.dump(@payload)
+          marshaller.dump(@tt_payload)
+        end
       end
     end
   end
 
   def test_json_marshalling_utf16_strings(timer)
-    marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
-    convert_strings_to_utf16(@payload)
-    convert_strings_to_utf16(@tt_payload)
-    timer.measure do
-      (iterations / 100).times do
-        marshaller.dump(@payload)
-        marshaller.dump(@tt_payload)
+    with_config(:normalize_json_string_encodings => true) do
+      marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
+      convert_strings_to_utf16(@payload)
+      convert_strings_to_utf16(@tt_payload)
+      timer.measure do
+        (iterations / 100).times do
+          marshaller.dump(@payload)
+          marshaller.dump(@tt_payload)
+        end
       end
     end
   end
 
   def test_json_marshalling_latin1_strings(timer)
-    marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
-    convert_strings_to_latin1(@payload)
-    convert_strings_to_latin1(@tt_payload)
-    timer.measure do
-      (iterations / 100).times do
-        marshaller.dump(@payload)
-        marshaller.dump(@tt_payload)
+    with_config(:normalize_json_string_encodings => true) do
+      marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
+      convert_strings_to_latin1(@payload)
+      convert_strings_to_latin1(@tt_payload)
+      timer.measure do
+        (iterations / 100).times do
+          marshaller.dump(@payload)
+          marshaller.dump(@tt_payload)
+        end
       end
     end
   end
@@ -84,7 +92,8 @@ class Marshalling < Performance::TestCase
 
   def generate_random_string(length)
     bytes = []
-    length.times { bytes << BYTE_ALPHABET.sample }
+    meth = BYTE_ALPHABET.respond_to?(:sample) ? :sample : :choice
+    length.times { bytes << BYTE_ALPHABET.send(meth) }
     bytes.pack("C*")
   end
 
@@ -96,11 +105,18 @@ class Marshalling < Performance::TestCase
 
   def convert_strings_to_utf16(object)
     each_string(object) do |s|
-      s.encode!('UTF-16')
+      if s.respond_to?(:encode!)
+        s.encode!('UTF-16')
+      else
+        require 'iconv'
+        s.replace(Iconv.conv('UTF-16', 'UTF-8', s))
+      end
     end
   end
 
   def convert_strings_to_latin1(object)
+    return object unless "".respond_to?(:force_encoding)
+
     each_string(object) do |s|
       s.replace(generate_random_string(s.bytesize)).force_encoding('ISO-8859-1')
     end