newrelic_rpm 3.16.0.318 → 3.16.1.320

data/test/multiverse/suites/rails/error_tracing_test.rb

@@ -134,8 +134,8 @@ class ErrorsWithoutSSCTest < RailsMultiverseTest
 
   def test_should_capture_error_raised_in_view
     get '/error/view_error'
-    assert_error_reported_once('this is an uncaught view error',
-                               'Controller/error/view_error')
+    assert_equal 1, errors.size
+    assert_includes ['this is an uncaught view error', 'ActionView::Template::Error'], errors[0].message
   end
 
   def test_should_capture_error_raised_in_controller

data/test/multiverse/suites/sequel/Envfile

@@ -32,3 +32,10 @@ gemfile <<-RB
   gem 'sqlite3', :platform => :ruby
   gem 'sequel', '4.0.0'
 RB
+
+gemfile <<-RB
+  gem 'newrelic_rpm', :require => false, :path => File.expand_path('../../../../')
+  gem 'jdbc-sqlite3', '3.7.2', :platform => :jruby
+  gem 'sqlite3', :platform => :ruby
+  gem 'sequel', '4.35.0'
+RB

data/test/multiverse/suites/sequel/sequel_extension_test.rb

@@ -68,7 +68,7 @@ class SequelExtensionTest < Minitest::Test
 
   def test_doesnt_block_constraint_errors
     first_post = @posts.insert(:title => 'The Thing', :content => 'A wicked short story.')
-    assert_raises(Sequel::DatabaseError) do
+    assert_raises(Sequel::DatabaseError, Sequel::UniqueConstraintViolation) do
       @posts.insert(:id => first_post, :title => 'Copy Cat', :content => 'A wicked short story.')
     end
   end

data/test/new_relic/agent/database_test.rb

@@ -470,6 +470,15 @@ class NewRelic::Agent::DatabaseTest < Minitest::Test
     end
   end
 
+  def test_database_statement_does_not_mutate_sql
+    table_name = 'a' * 17_000
+    sql = "select * from #{table_name}"
+    expected_sql = sql.dup
+    statement = NewRelic::Agent::Database::Statement.new sql, {:adapter => :mysql}
+    refute_equal sql, statement.sql
+    assert_equal expected_sql, sql
+  end
+
   # Ruby 1.8 doesn't have String#encoding
   def encoding_from_string(str)
     if str.respond_to?(:encoding)

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

@@ -56,77 +56,110 @@ module NewRelic
         assert_equal expected, result
       end
 
-      def test_metrics_for_obeys_collection_and_operation_overrides
+      def test_scoped_metric_for_with_collection
+        expected = "Datastore/statement/JonanDB/wiggles/select"
+        result = Datastores::MetricHelper.scoped_metric_for(@product, @operation, @collection)
+        assert_equal expected, result
+      end
+
+      def test_scoped_metric_for_without_collection
+        expected = "Datastore/operation/JonanDB/select"
+        result = Datastores::MetricHelper.scoped_metric_for(@product, @operation)
+        assert_equal expected, result
+      end
+
+      def test_unscoped_metrics_for_in_web_context
+        Transaction.stubs(:recording_web_transaction?).returns(true)
+        expected = [
+          "Datastore/operation/JonanDB/select",
+          "Datastore/JonanDB/allWeb",
+          "Datastore/JonanDB/all",
+          "Datastore/allWeb",
+          "Datastore/all"
+        ]
+
+        result = Datastores::MetricHelper.unscoped_metrics_for(@product, @operation, @collection)
+        assert_equal expected, result
+      end
+
+      def test_unscoped_metrics_for_outside_web_context
+        Transaction.stubs(:recording_web_transaction?).returns(false)
+        expected = [
+          "Datastore/operation/JonanDB/select",
+          "Datastore/JonanDB/allOther",
+          "Datastore/JonanDB/all",
+          "Datastore/allOther",
+          "Datastore/all"
+        ]
+
+        result = Datastores::MetricHelper.unscoped_metrics_for(@product, @operation, @collection)
+        assert_equal expected, result
+      end
+
+      def test_unscoped_metrics_for_without_collection
+        Transaction.stubs(:recording_web_transaction?).returns(false)
+        expected = [
+          "Datastore/JonanDB/allOther",
+          "Datastore/JonanDB/all",
+          "Datastore/allOther",
+          "Datastore/all"
+        ]
+
+        result = Datastores::MetricHelper.unscoped_metrics_for(@product, @operation)
+        assert_equal expected, result
+      end
+
+      def test_product_operation_collection_for_obeys_collection_and_operation_overrides
         in_transaction do
           NewRelic::Agent.with_database_metric_name("Model", "new_method") do
-            expected = [
-              "Datastore/statement/JonanDB/Model/new_method",
-              "Datastore/operation/JonanDB/new_method",
-              "Datastore/JonanDB/allOther",
-              "Datastore/JonanDB/all",
-              "Datastore/allOther",
-              "Datastore/all"
-            ]
-
-            result = Datastores::MetricHelper.metrics_for(@product, "original_method")
+            result = Datastores::MetricHelper.product_operation_collection_for(@product, "original_method")
+            expected = [@product, "new_method", "Model"]
             assert_equal expected, result
           end
         end
       end
 
-      def test_metrics_for_obeys_collection_override
+      def test_product_operation_collection_for_obeys_collection_override
         in_transaction do
           NewRelic::Agent.with_database_metric_name("Model", nil) do
-            expected = [
-              "Datastore/statement/JonanDB/Model/original_method",
-              "Datastore/operation/JonanDB/original_method",
-              "Datastore/JonanDB/allOther",
-              "Datastore/JonanDB/all",
-              "Datastore/allOther",
-              "Datastore/all"
-            ]
-
-            result = Datastores::MetricHelper.metrics_for(@product, "original_method")
+            result = Datastores::MetricHelper.product_operation_collection_for(@product, "original_method")
+            expected = [@product, "original_method", "Model"]
             assert_equal expected, result
           end
         end
       end
 
-      def test_metrics_ignore_overrides_for_other_products
+      def test_product_operation_collection_for_ignore_overrides_for_other_products
         in_transaction do
           NewRelic::Agent.with_database_metric_name("Model", "new_method", "FauxDB") do
-            expected = [
-              "Datastore/operation/JonanDB/original_method",
-              "Datastore/JonanDB/allOther",
-              "Datastore/JonanDB/all",
-              "Datastore/allOther",
-              "Datastore/all"
-            ]
-
-            result = Datastores::MetricHelper.metrics_for(@product, "original_method")
+            result = Datastores::MetricHelper.product_operation_collection_for(@product, "original_method")
+            expected = [@product, "original_method", nil]
             assert_equal expected, result
           end
         end
       end
 
-      def test_metrics_applies_overrides_by_generic_product_name
+      def test_product_operation_collection_for_applies_overrides_by_generic_product_name
         in_transaction do
           NewRelic::Agent.with_database_metric_name("Model", "new_method") do
-            expected = [
-              "Datastore/statement/MoreSpecificDB/Model/new_method",
-              "Datastore/operation/MoreSpecificDB/new_method",
-              "Datastore/MoreSpecificDB/allOther",
-              "Datastore/MoreSpecificDB/all",
-              "Datastore/allOther",
-              "Datastore/all"
-            ]
-
-            result = Datastores::MetricHelper.metrics_for("MoreSpecificDB", "original_method", nil, @product)
+            result = Datastores::MetricHelper.product_operation_collection_for("MoreSpecificDB", "original_method", nil, @product)
+            expected = ["MoreSpecificDB", "new_method", "Model"]
             assert_equal expected, result
           end
         end
       end
 
+      def test_operation_from_sql
+        sql = "SELECT * FROM blogs where id = 5"
+        operation = Datastores::MetricHelper.operation_from_sql sql
+        assert_equal "select", operation
+      end
+
+      def test_operation_from_sql_returns_other_for_unrecognized_operation
+        sql = "DESCRIBE blogs"
+        operation = Datastores::MetricHelper.operation_from_sql sql
+        assert_equal "Other", operation
+      end
     end
   end
 end

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

@@ -13,94 +13,60 @@ class NewRelic::Agent::Datastores::Mongo::MetricTranslatorTest < Minitest::Test
     @collection_name = 'tribbles'
   end
 
-  def test_metrics_for_insert
-    metrics = NewRelic::Agent::Datastores::Mongo::MetricTranslator.metrics_for(:insert, { :collection => @collection_name })
-    expected = build_test_metrics(:insert)
-
-    assert_equal expected, metrics
-  end
-
-  def test_build_metrics_includes_web
-    in_web_transaction do
-      metrics = build_test_metrics('test')
-      assert_includes metrics, 'Datastore/allWeb'
-    end
-  end
-
-  def test_build_metrics_includes_other
-    in_background_transaction do
-      metrics = build_test_metrics('test')
-      assert_includes metrics, 'Datastore/allOther'
-    end
-  end
-
-  def test_build_metrics_includes_all_for_web
-    in_web_transaction do
-      metrics = build_test_metrics('test')
-      assert_includes metrics, 'Datastore/all'
-    end
-  end
-
-  def test_build_metrics_includes_all_for_other
-    in_background_transaction do
-      metrics = build_test_metrics('test')
-      assert_includes metrics, 'Datastore/all'
-    end
+  def test_operation_and_collection_for_insert
+    result = NewRelic::Agent::Datastores::Mongo::MetricTranslator.operation_and_collection_for(:insert, { :collection => @collection_name })
+    assert_equal ['insert', @collection_name], result
   end
 
-  def test_build_metrics_is_graceful_if_exceptions_are_raised
-    NewRelic::Agent::Datastores::MetricHelper.stubs(:metrics_for).raises("Boom")
-    metrics = NewRelic::Agent::Datastores::Mongo::MetricTranslator.metrics_for(:find, {})
-    assert_empty metrics
+  def test_operation_and_collection_for_is_graceful_if_exceptions_are_raised
+    NewRelic::Agent::Datastores::Mongo::MetricTranslator.stubs(:find_one?).raises("Boom")
+    result = NewRelic::Agent::Datastores::Mongo::MetricTranslator.operation_and_collection_for(:find, {})
+    assert_nil result
   end
 
-  def test_metrics_for_find
+  def test_operation_and_collection_for_find
     payload = { :database   => @database_name,
                 :collection => @collection_name,
                 :selector   => { "name" => "soterios johnson" } }
 
-    metrics = NewRelic::Agent::Datastores::Mongo::MetricTranslator.metrics_for(:find, payload)
-    expected = build_test_metrics(:find)
+    result = NewRelic::Agent::Datastores::Mongo::MetricTranslator.operation_and_collection_for(:find, payload)
 
-    assert_equal expected, metrics
+    assert_equal ['find', @collection_name], result
   end
 
-  def test_metrics_for_find_one
+  def test_operation_and_collection_for_find_one
     payload = { :database   => @database_name,
                 :collection => @collection_name,
                 :selector   => {},
                 :limit      => -1 }
 
-    metrics = NewRelic::Agent::Datastores::Mongo::MetricTranslator.metrics_for(:find, payload)
-    expected = build_test_metrics(:findOne)
+    result = NewRelic::Agent::Datastores::Mongo::MetricTranslator.operation_and_collection_for(:find, payload)
 
-    assert_equal expected, metrics
+    assert_equal ['findOne' ,@collection_name], result
   end
 
-  def test_metrics_for_remove
+  def test_operation_and_collection_for_remove
     payload = { :database   => @database_name,
                 :collection => @collection_name,
                 :selector   => { "name" => "soterios johnson" } }
 
-    metrics = NewRelic::Agent::Datastores::Mongo::MetricTranslator.metrics_for(:remove, payload)
-    expected = build_test_metrics(:remove)
+    result = NewRelic::Agent::Datastores::Mongo::MetricTranslator.operation_and_collection_for(:remove, payload)
 
-    assert_equal expected, metrics
+    assert_equal ['remove', @collection_name], result
   end
 
-  def test_metrics_for_update
+  def test_operation_and_collection_for_update
     payload = { :database   => @database_name,
                 :collection => @collection_name,
                 :selector   => { "name" => "soterios johnson" },
                 :document   => { "name" => "codemonkey" } }
 
-    metrics = NewRelic::Agent::Datastores::Mongo::MetricTranslator.metrics_for(:update, payload)
-    expected = build_test_metrics(:update)
+    result = NewRelic::Agent::Datastores::Mongo::MetricTranslator.operation_and_collection_for(:update, payload)
 
-    assert_equal expected, metrics
+    assert_equal ['update', @collection_name], result
   end
 
-  def test_metrics_for_distinct
+  def test_operation_and_collection_for_distinct
     payload = { :database   => @database_name,
                 :collection => "$cmd",
                 :limit      => -1,
@@ -108,13 +74,12 @@ class NewRelic::Agent::Datastores::Mongo::MetricTranslatorTest < Minitest::Test
                                  :key      => "name",
                                  :query    => nil } }
 
-    metrics = NewRelic::Agent::Datastores::Mongo::MetricTranslator.metrics_for(:distinct, payload)
-    expected = build_test_metrics(:distinct)
+    result = NewRelic::Agent::Datastores::Mongo::MetricTranslator.operation_and_collection_for(:distinct, payload)
 
-    assert_equal expected, metrics
+    assert_equal ['distinct', @collection_name], result
   end
 
-  def test_metrics_for_count
+  def test_operation_and_collection_for_count
     payload = { :database   => @database_name,
                 :collection => "$cmd",
                 :limit      => -1,
@@ -122,13 +87,12 @@ class NewRelic::Agent::Datastores::Mongo::MetricTranslatorTest < Minitest::Test
                                  "query"  => {},
                                  "fields" => nil } }
 
-    metrics = NewRelic::Agent::Datastores::Mongo::MetricTranslator.metrics_for(:find, payload)
-    expected = build_test_metrics(:count)
+    result = NewRelic::Agent::Datastores::Mongo::MetricTranslator.operation_and_collection_for(:find, payload)
 
-    assert_equal expected, metrics
+    assert_equal ['count', @collection_name], result
   end
 
-  def test_metrics_for_group
+  def test_operation_and_collection_for_group
     payload = { :database   => @database_name,
                 :collection => "$cmd",
                 :limit      => -1,
@@ -138,26 +102,24 @@ class NewRelic::Agent::Datastores::Mongo::MetricTranslatorTest < Minitest::Test
                                               "initial" => {:count=>0},
                                               "key"     => {"name"=>1}}}}
 
-    metrics = NewRelic::Agent::Datastores::Mongo::MetricTranslator.metrics_for(:find, payload)
-    expected = build_test_metrics(:group)
+    result = NewRelic::Agent::Datastores::Mongo::MetricTranslator.operation_and_collection_for(:find, payload)
 
-    assert_equal expected, metrics
+    assert_equal ['group', @collection_name], result
   end
 
-  def test_metrics_for_aggregate
+  def test_operation_and_collection_for_aggregate
     payload = { :database   => @database_name,
                 :collection => "$cmd",
                 :limit      => -1,
                 :selector   =>  { "aggregate" => @collection_name,
                                   "pipeline" => [{"$group" => {:_id => "$says", :total => {"$sum" => 1}}}]}}
 
-    metrics = NewRelic::Agent::Datastores::Mongo::MetricTranslator.metrics_for(:find, payload)
-    expected = build_test_metrics(:aggregate)
+    result = NewRelic::Agent::Datastores::Mongo::MetricTranslator.operation_and_collection_for(:find, payload)
 
-    assert_equal expected, metrics
+    assert_equal ['aggregate', @collection_name], result
   end
 
-  def test_metrics_for_mapreduce
+  def test_operation_and_collection_for_mapreduce
     payload = { :database   => @database_name,
                 :collection => "$cmd",
                 :limit      => -1,
@@ -166,14 +128,13 @@ class NewRelic::Agent::Datastores::Mongo::MetricTranslatorTest < Minitest::Test
                                   "reduce" => stub("BSON::Code"),
                                   :out => "results"}}
 
-    metrics = NewRelic::Agent::Datastores::Mongo::MetricTranslator.metrics_for(:find, payload)
-    expected = build_test_metrics(:mapreduce)
+    result = NewRelic::Agent::Datastores::Mongo::MetricTranslator.operation_and_collection_for(:find, payload)
 
-    assert_equal expected, metrics
+    assert_equal ['mapreduce', @collection_name], result
   end
 
 
-  def test_metrics_for_find_and_modify
+  def test_operation_and_collection_for_find_and_modify
     payload = { :database   => @database_name,
                 :collection => "$cmd",
                 :limit      => -1,
@@ -181,13 +142,12 @@ class NewRelic::Agent::Datastores::Mongo::MetricTranslatorTest < Minitest::Test
                                  :query         => { "name" => "soterios johnson" },
                                  :update        => {"name" => "codemonkey" } } }
 
-    metrics = NewRelic::Agent::Datastores::Mongo::MetricTranslator.metrics_for(:find, payload)
-    expected = build_test_metrics(:findAndModify)
+    result = NewRelic::Agent::Datastores::Mongo::MetricTranslator.operation_and_collection_for(:find, payload)
 
-    assert_equal expected, metrics
+    assert_equal ['findAndModify', @collection_name], result
   end
 
-  def test_metrics_for_find_and_remove
+  def test_operation_and_collection_for_find_and_remove
     payload = { :database   => @database_name,
                 :collection => "$cmd",
                 :limit      => -1,
@@ -195,89 +155,82 @@ class NewRelic::Agent::Datastores::Mongo::MetricTranslatorTest < Minitest::Test
                                  :query         => { "name" => "soterios johnson" },
                                  :remove        => true } }
 
-    metrics = NewRelic::Agent::Datastores::Mongo::MetricTranslator.metrics_for(:find, payload)
-    expected = build_test_metrics(:findAndRemove)
+    result = NewRelic::Agent::Datastores::Mongo::MetricTranslator.operation_and_collection_for(:find, payload)
 
-    assert_equal expected, metrics
+    assert_equal ['findAndRemove', @collection_name], result
   end
 
-  def test_metrics_for_create_index
+  def test_operation_and_collection_for_create_index
     payload = { :database   => @database_name,
                 :collection => "system.indexes",
                 :documents  => [ { :name => "name_1",
                                     :ns   => "#{@database_name}.#{@collection_name}",
                                     :key  => { "name" => 1 } } ] }
 
-    metrics = NewRelic::Agent::Datastores::Mongo::MetricTranslator.metrics_for(:insert, payload)
-    expected = build_test_metrics(:createIndex)
+    result = NewRelic::Agent::Datastores::Mongo::MetricTranslator.operation_and_collection_for(:insert, payload)
 
-    assert_equal expected, metrics
+    assert_equal ['createIndex', @collection_name], result
   end
 
-  def test_metrics_for_drop_indexes
+  def test_operation_and_collection_for_drop_indexes
     payload = { :database   => @database_name,
                 :collection => "$cmd",
                 :limit      => -1,
                 :selector => { :deleteIndexes => @collection_name,
                                :index         => "*" } }
 
-    metrics = NewRelic::Agent::Datastores::Mongo::MetricTranslator.metrics_for(:find, payload)
-    expected = build_test_metrics(:dropIndexes)
+    result = NewRelic::Agent::Datastores::Mongo::MetricTranslator.operation_and_collection_for(:find, payload)
 
-    assert_equal expected, metrics
+    assert_equal ['dropIndexes', @collection_name], result
   end
 
-  def test_metrics_for_drop_index
+  def test_operation_and_collection_for_drop_index
     payload = { :database => @database_name,
                 :collection => "$cmd",
                 :limit => -1,
                 :selector => { :deleteIndexes => @collection_name,
                                :index => "name_1" } }
 
-    metrics = NewRelic::Agent::Datastores::Mongo::MetricTranslator.metrics_for(:find, payload)
-    expected = build_test_metrics(:dropIndex)
+    result = NewRelic::Agent::Datastores::Mongo::MetricTranslator.operation_and_collection_for(:find, payload)
 
-    assert_equal expected, metrics
+    assert_equal ['dropIndex', @collection_name], result
   end
 
-  def test_metrics_for_reindex
+  def test_operation_and_collection_for_reindex
     payload = { :database => @database_name,
                 :collection => "$cmd",
                 :limit => -1,
                 :selector => { :reIndex=> @collection_name } }
 
-    metrics = NewRelic::Agent::Datastores::Mongo::MetricTranslator.metrics_for(:find, payload)
-    expected = build_test_metrics(:reIndex)
+    result = NewRelic::Agent::Datastores::Mongo::MetricTranslator.operation_and_collection_for(:find, payload)
 
-    assert_equal expected, metrics
+    assert_equal ['reIndex', @collection_name], result
   end
 
-  def test_metrics_for_drop_collection
+  def test_operation_and_collection_for_drop_collection
     payload = { :database   => @database_name,
                 :collection =>"$cmd",
                 :limit      => -1,
                 :selector   => { :drop => @collection_name } }
 
-    metrics = NewRelic::Agent::Datastores::Mongo::MetricTranslator.metrics_for(:find, payload)
-    expected = build_test_metrics(:drop)
+    result = NewRelic::Agent::Datastores::Mongo::MetricTranslator.operation_and_collection_for(:find, payload)
 
-    assert_equal expected, metrics
+    assert_equal ['drop', @collection_name], result
   end
 
-  def test_metrics_for_rename_collection
+  def test_operation_and_collection_for_rename_collection
     payload = { :database   => @database_name,
                 :collection => "$cmd",
                 :limit      => -1,
                 :selector   => { :renameCollection => "#{@database_name}.#{@collection_name}",
                                  :to=>"#{@database_name}.renamed_#{@collection_name}" } }
 
-    metrics = NewRelic::Agent::Datastores::Mongo::MetricTranslator.metrics_for(:find, payload)
-    expected = build_test_metrics(:renameCollection)
+    result = NewRelic::Agent::Datastores::Mongo::MetricTranslator.operation_and_collection_for(:find, payload)
 
-    assert_equal expected, metrics
+    assert_equal ['renameCollection', @collection_name], result
   end
 
-  def test_metrics_for_ismaster
+  def test_operation_and_collection_for_ismaster
     payload = { :database   => @database_name,
                 :collection => "$cmd",
                 :limit      => -1,
@@ -285,25 +238,23 @@ class NewRelic::Agent::Datastores::Mongo::MetricTranslatorTest < Minitest::Test
 
     @collection_name = "$cmd"
 
-    metrics = NewRelic::Agent::Datastores::Mongo::MetricTranslator.metrics_for(:find, payload)
-    expected = build_test_metrics(:ismaster)
+    result = NewRelic::Agent::Datastores::Mongo::MetricTranslator.operation_and_collection_for(:find, payload)
 
-    assert_equal expected, metrics
+    assert_equal ['ismaster', @collection_name], result
   end
 
-  def test_metrics_for_collstats
+  def test_operation_and_collection_for_collstats
     payload = { :database   => @database_name,
                 :collection =>"$cmd",
                 :limit      => -1,
                 :selector   => { :collstats => @collection_name } }
 
-    metrics = NewRelic::Agent::Datastores::Mongo::MetricTranslator.metrics_for(:find, payload)
-    expected = build_test_metrics(:collstats)
+    result = NewRelic::Agent::Datastores::Mongo::MetricTranslator.operation_and_collection_for(:find, payload)
 
-    assert_equal expected, metrics
+    assert_equal ['collstats', @collection_name], result
   end
 
-  def test_metrics_for_unknown_command
+  def test_operation_and_collection_for_unknown_command
     payload = { :database => @database_name,
                 :collection => "$cmd",
                 :limit => -1,
@@ -311,10 +262,9 @@ class NewRelic::Agent::Datastores::Mongo::MetricTranslatorTest < Minitest::Test
 
     @collection_name = "$cmd"
 
-    metrics = NewRelic::Agent::Datastores::Mongo::MetricTranslator.metrics_for(:find, payload)
-    expected = build_test_metrics(:mongomongomongo)
+    result = NewRelic::Agent::Datastores::Mongo::MetricTranslator.operation_and_collection_for(:find, payload)
 
-    assert_equal expected, metrics
+    assert_equal ['mongomongomongo', @collection_name], result
     assert_metrics_recorded(["Supportability/Mongo/UnknownCollection"])
   end
 end