newrelic_rpm 3.18.1.330 → 4.0.0.332

data/test/new_relic/agent/aws_info_test.rb

@@ -52,9 +52,25 @@ module NewRelic::Agent
       if expected_vendors_hash.nil?
         refute aws_info.loaded?
       else
-        actual = HashExtensions.stringify_keys_in_object(aws_info.to_collector_hash)
+        actual = stringify_keys_in_object(aws_info.to_collector_hash)
         assert_equal expected_vendors_hash["aws"], actual
       end
     end
+
+    # recurses through hashes and arrays and stringifies keys
+    def stringify_keys_in_object(object)
+      case object
+      when Hash
+        object.inject({}) do |memo, (k, v)|
+          memo[k.to_s] = stringify_keys_in_object(v)
+          memo
+        end
+      when Array
+        object.map {|o| stringify_keys_in_object(o)}
+      else
+        object
+      end
+    end
+
   end
 end

data/test/new_relic/agent/busy_calculator_test.rb

@@ -3,13 +3,14 @@
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+
 class NewRelic::Agent::BusyCalculatorTest < Minitest::Test
   attr_reader :now
+
   def setup
     @now = Time.now.to_f
     NewRelic::Agent::BusyCalculator.reset
     NewRelic::Agent.agent.stats_engine.clear_stats
-    @instance_busy = NewRelic::Agent.agent.stats_engine.get_stats_no_scope('Instance/Busy')
   end
 
   def test_normal
@@ -21,9 +22,9 @@ class NewRelic::Agent::BusyCalculatorTest < Minitest::Test
     assert_equal 5, NewRelic::Agent::BusyCalculator.accumulator
     NewRelic::Agent::BusyCalculator.harvest_busy
 
-    assert_equal 1, @instance_busy.call_count
-    assert_in_delta 0.50, @instance_busy.total_call_time, 0.05
+    assert_metrics_recorded 'Instance/Busy' => {:call_count => 1, :total_call_time => 0.50}
   end
+
   def test_split
     # start the timewindow 10 seconds ago
     # start a request at 5 seconds, don't finish
@@ -31,9 +32,9 @@ class NewRelic::Agent::BusyCalculatorTest < Minitest::Test
     NewRelic::Agent::BusyCalculator.dispatcher_start(now - 5.0)
     NewRelic::Agent::BusyCalculator.harvest_busy
 
-    assert_equal 1, @instance_busy.call_count, @instance_busy
-    assert_in_delta 0.50, @instance_busy.total_call_time, 0.05
+    assert_metrics_recorded 'Instance/Busy' => {:call_count => 1, :total_call_time => 0.50}
   end
+
   def test_reentrancy
     # start the timewindow 10 seconds ago
     # start a request at 5 seconds, don't finish, but make two more
@@ -48,9 +49,9 @@ class NewRelic::Agent::BusyCalculatorTest < Minitest::Test
     NewRelic::Agent::BusyCalculator.dispatcher_finish(now - 1.0)
     NewRelic::Agent::BusyCalculator.harvest_busy
 
-    assert_equal 1, @instance_busy.call_count
-    assert_in_delta 0.50, @instance_busy.total_call_time, 0.05
+    assert_metrics_recorded 'Instance/Busy' => {:call_count => 1, :total_call_time => 0.50}
   end
+
   def test_concurrency
     # start the timewindow 10 seconds ago
     # start a request at 10 seconds, 5 seconds long
@@ -70,23 +71,21 @@ class NewRelic::Agent::BusyCalculatorTest < Minitest::Test
     NewRelic::Agent::BusyCalculator.stubs(:time_now).returns(now - 1.0)
     NewRelic::Agent::BusyCalculator.harvest_busy
 
-    assert_equal 1, @instance_busy.call_count
-    # 3 + 6 = 9, or 90%
-    assert_in_delta 0.90, @instance_busy.total_call_time, 0.1
-
+    assert_metrics_recorded 'Instance/Busy' => {:call_count => 1, :total_call_time => 1.0}
   end
+
   def test_dont_ignore_zero_counts
-    assert_equal 0, @instance_busy.call_count, "Problem with test--instance busy not starting off at zero."
     NewRelic::Agent::BusyCalculator.harvest_busy
     NewRelic::Agent::BusyCalculator.harvest_busy
     NewRelic::Agent::BusyCalculator.harvest_busy
-    assert_equal 3, @instance_busy.call_count
+
+    assert_metrics_recorded 'Instance/Busy' => {:call_count => 3}
   end
+
   def test_can_turn_off_recording
     with_config(:report_instance_busy => false) do
-      assert_equal 0, @instance_busy.call_count, "Problem with test--instance busy not starting off at zero."
       NewRelic::Agent::BusyCalculator.harvest_busy
-      assert_equal 0, @instance_busy.call_count
+      assert_metrics_not_recorded 'Instance/Busy'
     end
   end
 
@@ -94,5 +93,4 @@ class NewRelic::Agent::BusyCalculatorTest < Minitest::Test
     NewRelic::Agent::TransactionState.tl_clear_for_testing
     NewRelic::Agent::BusyCalculator.dispatcher_finish
   end
-
 end

data/test/new_relic/agent/configuration/manager_test.rb

@@ -300,7 +300,7 @@ module NewRelic::Agent::Configuration
         assert_equal(testcase["expected"].sort_by { |h| h["label_type"] },
                      @manager.parse_labels_from_string.sort_by { |h| h["label_type"] },
                      "failed on #{testcase["name"]}")
-      end unless RUBY_VERSION < '1.9'
+      end
     end
 
     def test_parse_labels_from_dictionary_with_hard_failure
@@ -441,12 +441,6 @@ module NewRelic::Agent::Configuration
 
     def assert_parsed_labels(expected)
       result = @manager.parsed_labels
-
-      # 1.8.7 hash ordering means we can't directly compare. Lean on the
-      # structure and flattened array sorting to do the comparison we need.
-      result = result.map(&:to_a).sort
-      expected = expected.map(&:to_a).sort
-
       assert_equal expected, result
     end
 

data/test/new_relic/agent/cross_app_monitor_test.rb

@@ -241,7 +241,7 @@ module NewRelic::Agent
 
     def unpacked_response
       return nil unless response_app_data
-      NewRelic::JSONWrapper.load(Base64.decode64(response_app_data))
+      ::JSON.load(Base64.decode64(response_app_data))
     end
 
   end

data/test/new_relic/agent/database_test.rb

@@ -447,11 +447,11 @@ class NewRelic::Agent::DatabaseTest < Minitest::Test
 
   def test_capture_query_mis_encoded
     query = INVALID_UTF8_STRING
-    original_encoding = encoding_from_string(query)
+    original_encoding = query.encoding
     expected_query = INVALID_UTF8_STRING.dup
     expected_query.force_encoding('ASCII-8BIT') if expected_query.respond_to?(:force_encoding)
     captured = NewRelic::Agent::Database.capture_query(query)
-    assert_equal(original_encoding, encoding_from_string(query)) # input query encoding should remain untouched
+    assert_equal(original_encoding, query.encoding) # input query encoding should remain untouched
     assert_equal(expected_query, captured)
   end
 
@@ -479,12 +479,4 @@ class NewRelic::Agent::DatabaseTest < Minitest::Test
     assert_equal expected_sql, sql
   end
 
-  # Ruby 1.8 doesn't have String#encoding
-  def encoding_from_string(str)
-    if str.respond_to?(:encoding)
-      str.encoding
-    else
-      nil
-    end
-  end
 end

data/test/new_relic/agent/datastores/mongo/event_formatter_test.rb

@@ -64,112 +64,109 @@ module NewRelic
             ]
           }
 
-          if RUBY_VERSION > "1.9.3"
+          def test_doesnt_modify_incoming_statement
+            formatted = EventFormatter.format('find', DATABASE, FIND_COMMAND)
+            refute_same FIND_COMMAND, formatted
+          end
 
-            def test_doesnt_modify_incoming_statement
+          def test_can_disable_statement_capturing_queries
+            with_config(:'mongo.capture_queries' => false) do
               formatted = EventFormatter.format('find', DATABASE, FIND_COMMAND)
-              refute_same FIND_COMMAND, formatted
-            end
-
-            def test_can_disable_statement_capturing_queries
-              with_config(:'mongo.capture_queries' => false) do
-                formatted = EventFormatter.format('find', DATABASE, FIND_COMMAND)
-                assert_nil formatted
-              end
+              assert_nil formatted
             end
+          end
 
-            def test_event_formatter_obfuscates_by_default
-              expected = {
-                :operation => :find,
-                :database => DATABASE,
-                :collection => "tribbles",
-                "find" => "tribbles",
-                "filter" => { "_id" => { "$gt" => "?" }, "name" => "?" },
-                "sort" => { "_id" => 1 },
-                "limit" => 2,
-                "skip" => 2,
-                "comment" => "test",
-                "hint" => { "_id" => 1 },
-                "max" => { "_id" => 6 },
-                "maxScan" => 5000,
-                "maxTimeMS" => 6000,
-                "min" => { "_id" => 0 },
-                "readPreference" => { "mode" => "secondaryPreferred" },
-                "returnKey" => false,
-                "showRecordId" => false,
-                "snapshot" => false
-              }
+          def test_event_formatter_obfuscates_by_default
+            expected = {
+              :operation => :find,
+              :database => DATABASE,
+              :collection => "tribbles",
+              "find" => "tribbles",
+              "filter" => { "_id" => { "$gt" => "?" }, "name" => "?" },
+              "sort" => { "_id" => 1 },
+              "limit" => 2,
+              "skip" => 2,
+              "comment" => "test",
+              "hint" => { "_id" => 1 },
+              "max" => { "_id" => 6 },
+              "maxScan" => 5000,
+              "maxTimeMS" => 6000,
+              "min" => { "_id" => 0 },
+              "readPreference" => { "mode" => "secondaryPreferred" },
+              "returnKey" => false,
+              "showRecordId" => false,
+              "snapshot" => false
+            }
+
+            formatted = EventFormatter.format(:find, DATABASE, FIND_COMMAND)
+            assert_equal expected, formatted
+          end
 
+          def test_event_formatter_raw_selectors
+            with_config(:'mongo.obfuscate_queries' => false) do
               formatted = EventFormatter.format(:find, DATABASE, FIND_COMMAND)
-              assert_equal expected, formatted
-            end
-
-            def test_event_formatter_raw_selectors
-              with_config(:'mongo.obfuscate_queries' => false) do
-                formatted = EventFormatter.format(:find, DATABASE, FIND_COMMAND)
-                expected = FIND_COMMAND.merge(
-                  :operation => :find,
-                  :database => DATABASE,
-                  :collection => 'tribbles'
-                )
-                assert_equal expected, formatted
-              end
-            end
-
-            def test_event_formatter_blacklists_inserts
-              expected = {
-                :operation => :insert,
-                :database => DATABASE,
-                :collection => "tribbles",
-                "insert" => "tribbles",
-                "ordered" => true
-              }
-
-              formatted = EventFormatter.format(:insert, DATABASE, INSERT_COMMAND)
-              assert_equal expected, formatted
-            end
-
-            def test_event_formatter_blacklists_updates
-              expected = {
-                :operation => :update,
+              expected = FIND_COMMAND.merge(
+                :operation => :find,
                 :database => DATABASE,
-                :collection => "tribbles",
-                "update" => "tribbles",
-                "ordered" => true
-              }
-
-              formatted = EventFormatter.format(:update, DATABASE, UPDATE_COMMAND)
+                :collection => 'tribbles'
+              )
               assert_equal expected, formatted
             end
+          end
 
-            def test_event_formatter_blacklists_deletes
-              expected = {
-                :operation => :delete,
-                :database => DATABASE,
-                :collection => "tribbles",
-                "delete" => "tribbles",
-                "ordered" => true
-              }
+          def test_event_formatter_blacklists_inserts
+            expected = {
+              :operation => :insert,
+              :database => DATABASE,
+              :collection => "tribbles",
+              "insert" => "tribbles",
+              "ordered" => true
+            }
+
+            formatted = EventFormatter.format(:insert, DATABASE, INSERT_COMMAND)
+            assert_equal expected, formatted
+          end
 
-              formatted = EventFormatter.format(:delete, DATABASE, DELETE_COMMAND)
-              assert_equal expected, formatted
-            end
+          def test_event_formatter_blacklists_updates
+            expected = {
+              :operation => :update,
+              :database => DATABASE,
+              :collection => "tribbles",
+              "update" => "tribbles",
+              "ordered" => true
+            }
+
+            formatted = EventFormatter.format(:update, DATABASE, UPDATE_COMMAND)
+            assert_equal expected, formatted
+          end
 
-            def test_event_formatter_obfuscates_pipeline
-              expected = {
-                :operation => :aggregate,
-                :database => DATABASE,
-                :collection => "tribbles",
-                "aggregate" => "tribbles",
-                "pipeline" => [
-                  {"$group" => {"_id" => "?", "max" => {"$max" => "?"}}},
-                  {"$match" => {"max" => {"$gte" => "?"}}}
-                ]
-              }
+          def test_event_formatter_obfuscates_pipeline
+            expected = {
+              :operation => :aggregate,
+              :database => DATABASE,
+              :collection => "tribbles",
+              "aggregate" => "tribbles",
+              "pipeline" => [
+                {"$group" => {"_id" => "?", "max" => {"$max" => "?"}}},
+                {"$match" => {"max" => {"$gte" => "?"}}}
+              ]
+            }
+
+            formatted = EventFormatter.format(:aggregate, DATABASE, AGGREGATE_COMMAND)
+            assert_equal expected, formatted
+          end
 
-              formatted = EventFormatter.format(:aggregate, DATABASE, AGGREGATE_COMMAND)
-              assert_equal expected, formatted
-            end
+          def test_event_formatter_blacklists_deletes
+            expected = {
+              :operation => :delete,
+              :database => DATABASE,
+              :collection => "tribbles",
+              "delete" => "tribbles",
+              "ordered" => true
+            }
+
+            formatted = EventFormatter.format(:delete, DATABASE, DELETE_COMMAND)
+            assert_equal expected, formatted
           end
         end
       end

data/test/new_relic/agent/datastores/redis_test.rb

@@ -104,25 +104,23 @@ class NewRelic::Agent::Datastores::RedisTest < Minitest::Test
     end
   end
 
-  if !NewRelic::LanguageSupport.rubinius? && RUBY_VERSION != "1.8.7"
-    def test_format_command_handles_binary_strings
-      binary_string = (0..255).to_a.pack("c*")
-      expected = 'set "key" <binary data>'
-
-      with_config(:'transaction_tracer.record_redis_arguments' => true) do
-        result = NewRelic::Agent::Datastores::Redis.format_command([:set, 'key', binary_string])
-        assert_equal expected, result
-      end
+  def test_format_command_handles_binary_strings
+    binary_string = (0..255).to_a.pack("c*")
+    expected = 'set "key" <binary data>'
+
+    with_config(:'transaction_tracer.record_redis_arguments' => true) do
+      result = NewRelic::Agent::Datastores::Redis.format_command([:set, 'key', binary_string])
+      assert_equal expected, result
     end
+  end
 
-    def test_format_command_in_pipeline_handles_binary_strings
-      binary_string = (0..255).to_a.pack("c*")
-      expected = 'set "key" <binary data>'
+  def test_format_command_in_pipeline_handles_binary_strings
+    binary_string = (0..255).to_a.pack("c*")
+    expected = 'set "key" <binary data>'
 
-      with_config(:'transaction_tracer.record_redis_arguments' => true) do
-        result = NewRelic::Agent::Datastores::Redis.format_command([:set, 'key', binary_string])
-        assert_equal expected, result
-      end
+    with_config(:'transaction_tracer.record_redis_arguments' => true) do
+      result = NewRelic::Agent::Datastores::Redis.format_command([:set, 'key', binary_string])
+      assert_equal expected, result
     end
   end
 end

data/test/new_relic/agent/encoding_normalizer_test.rb

@@ -23,49 +23,47 @@ class EncodingNormalizerTest < Minitest::Test
     assert_equal({'key' => 1.5}, result)
   end
 
-  if NewRelic::LanguageSupport.supports_string_encodings?
-    def test_normalize_string_returns_input_if_correctly_encoded_utf8
-      string = "i want a pony"
-      result = EncodingNormalizer.normalize_string(string)
-      assert_same(string, result)
-      assert_equal(Encoding.find('UTF-8'), result.encoding)
-    end
+  def test_normalize_string_returns_input_if_correctly_encoded_utf8
+    string = "i want a pony"
+    result = EncodingNormalizer.normalize_string(string)
+    assert_same(string, result)
+    assert_equal(Encoding.find('UTF-8'), result.encoding)
+  end
 
-    def test_normalize_string_returns_munged_copy_if_ascii_8bit
-      string = (0..255).to_a.pack("C*")
-      result = EncodingNormalizer.normalize_string(string)
-      refute_same(string, result)
-      assert_equal(Encoding.find('ISO-8859-1'), result.encoding)
-      assert_equal(string, result.dup.force_encoding('ASCII-8BIT'))
-    end
+  def test_normalize_string_returns_munged_copy_if_ascii_8bit
+    string = (0..255).to_a.pack("C*")
+    result = EncodingNormalizer.normalize_string(string)
+    refute_same(string, result)
+    assert_equal(Encoding.find('ISO-8859-1'), result.encoding)
+    assert_equal(string, result.dup.force_encoding('ASCII-8BIT'))
+  end
 
-    def test_normalize_string_returns_munged_copy_if_invalid_utf8
-      string = (0..255).to_a.pack("C*").force_encoding('UTF-8')
-      result = EncodingNormalizer.normalize_string(string)
-      refute_same(result, string)
-      assert_equal(Encoding.find('ISO-8859-1'), result.encoding)
-      assert_equal(string, result.dup.force_encoding('UTF-8'))
-    end
+  def test_normalize_string_returns_munged_copy_if_invalid_utf8
+    string = (0..255).to_a.pack("C*").force_encoding('UTF-8')
+    result = EncodingNormalizer.normalize_string(string)
+    refute_same(result, string)
+    assert_equal(Encoding.find('ISO-8859-1'), result.encoding)
+    assert_equal(string, result.dup.force_encoding('UTF-8'))
+  end
 
-    def test_normalize_string_returns_munged_copy_if_other_convertible_encoding
-      string = "i want a pony".encode('UTF-16LE')
-      result = EncodingNormalizer.normalize_string(string)
-      refute_same(result, string)
-      assert_equal(Encoding.find('UTF-8'), result.encoding)
-      assert_equal(string, result.encode('UTF-16LE'))
-    end
+  def test_normalize_string_returns_munged_copy_if_other_convertible_encoding
+    string = "i want a pony".encode('UTF-16LE')
+    result = EncodingNormalizer.normalize_string(string)
+    refute_same(result, string)
+    assert_equal(Encoding.find('UTF-8'), result.encoding)
+    assert_equal(string, result.encode('UTF-16LE'))
+  end
 
-    def test_normalize_string_returns_munged_copy_if_other_non_convertible_enocding
-      # Attempting to convert from UTF-7 to UTF-8 in Ruby will raise an
-      # Encoding::ConverterNotFoundError, which is what we're trying to
-      # replicate for this test case.
-      # The following UTF-7 string decodes to 'Jyväskylä', a city in Finland
-      string = "Jyv+AOQ-skyl+AOQ-".force_encoding("UTF-7")
-      assert string.valid_encoding?
-      result = EncodingNormalizer.normalize_string(string)
-      refute_same(result, string)
-      assert_equal(Encoding.find('ISO-8859-1'), result.encoding)
-      assert_equal('Jyv+AOQ-skyl+AOQ-'.force_encoding('ISO-8859-1'), result)
-    end
+  def test_normalize_string_returns_munged_copy_if_other_non_convertible_enocding
+    # Attempting to convert from UTF-7 to UTF-8 in Ruby will raise an
+    # Encoding::ConverterNotFoundError, which is what we're trying to
+    # replicate for this test case.
+    # The following UTF-7 string decodes to 'Jyväskylä', a city in Finland
+    string = "Jyv+AOQ-skyl+AOQ-".force_encoding("UTF-7")
+    assert string.valid_encoding?
+    result = EncodingNormalizer.normalize_string(string)
+    refute_same(result, string)
+    assert_equal(Encoding.find('ISO-8859-1'), result.encoding)
+    assert_equal('Jyv+AOQ-skyl+AOQ-'.force_encoding('ISO-8859-1'), result)
   end
 end