newrelic_rpm 3.17.0.325 → 3.17.1.326

data/lib/new_relic/agent/instrumentation/redis.rb

@@ -5,6 +5,32 @@
 require 'new_relic/agent/datastores'
 require 'new_relic/agent/datastores/redis'
 
+module NewRelic
+  module Agent
+    module Instrumentation
+      module Redis
+        extend self
+
+        UNKNOWN = "unknown".freeze
+
+        def host_for(client)
+          client.path ? NewRelic::Agent::Hostname.get : NewRelic::Agent::Hostname.get_external(client.host)
+        rescue => e
+          NewRelic::Agent.logger.debug "Failed to retrieve Redis host: #{e}"
+          UNKNOWN
+        end
+
+        def port_path_or_id_for(client)
+          client.path || client.port
+        rescue => e
+          NewRelic::Agent.logger.debug "Failed to retrieve Redis port_path_or_id: #{e}"
+          UNKNOWN
+        end
+      end
+    end
+  end
+end
+
 DependencyDetection.defer do
   # Why not :redis? newrelic-redis used that name, so avoid conflicting
   named :redis_instrumentation
@@ -32,14 +58,16 @@ DependencyDetection.defer do
         operation = args[0][0]
         statement = ::NewRelic::Agent::Datastores::Redis.format_command(args[0])
 
-        if statement
-          callback = Proc.new do |result, _, elapsed|
-            NewRelic::Agent::Datastores.notice_statement(statement, elapsed)
-          end
-        end
+        hostname = NewRelic::Agent::Instrumentation::Redis.host_for(self)
+        port_path_or_id = NewRelic::Agent::Instrumentation::Redis.port_path_or_id_for(self)
 
-        NewRelic::Agent::Datastores.wrap(NewRelic::Agent::Datastores::Redis::PRODUCT_NAME, operation, nil, callback) do
+        segment = NewRelic::Agent::Transaction.start_datastore_segment(NewRelic::Agent::Datastores::Redis::PRODUCT_NAME,
+          operation, nil, hostname, port_path_or_id, db)
+        begin
+          segment.notice_nosql_statement(statement) if statement
           call_without_new_relic(*args, &block)
+        ensure
+          segment.finish
         end
       end
 
@@ -50,20 +78,32 @@ DependencyDetection.defer do
         operation = pipeline.is_a?(::Redis::Pipeline::Multi) ? NewRelic::Agent::Datastores::Redis::MULTI_OPERATION : NewRelic::Agent::Datastores::Redis::PIPELINE_OPERATION
         statement = ::NewRelic::Agent::Datastores::Redis.format_pipeline_commands(pipeline.commands)
 
-        callback = Proc.new do |result, _, elapsed|
-          NewRelic::Agent::Datastores.notice_statement(statement, elapsed)
-        end
+        hostname = NewRelic::Agent::Instrumentation::Redis.host_for(self)
+        port_path_or_id = NewRelic::Agent::Instrumentation::Redis.port_path_or_id_for(self)
 
-        NewRelic::Agent::Datastores.wrap(NewRelic::Agent::Datastores::Redis::PRODUCT_NAME, operation, nil, callback) do
+        segment = NewRelic::Agent::Transaction.start_datastore_segment(NewRelic::Agent::Datastores::Redis::PRODUCT_NAME,
+          operation, nil, hostname, port_path_or_id, db)
+        begin
+          segment.notice_nosql_statement(statement)
           call_pipeline_without_new_relic(*args, &block)
+        ensure
+          segment.finish
         end
       end
 
       alias_method :connect_without_new_relic, :connect
 
       def connect(*args, &block)
-        NewRelic::Agent::Datastores.wrap(NewRelic::Agent::Datastores::Redis::PRODUCT_NAME, NewRelic::Agent::Datastores::Redis::CONNECT) do
+        hostname = NewRelic::Agent::Instrumentation::Redis.host_for(self)
+        port_path_or_id = NewRelic::Agent::Instrumentation::Redis.port_path_or_id_for(self)
+
+        segment = NewRelic::Agent::Transaction.start_datastore_segment(NewRelic::Agent::Datastores::Redis::PRODUCT_NAME,
+          NewRelic::Agent::Datastores::Redis::CONNECT, nil, hostname, port_path_or_id, db)
+
+        begin
           connect_without_new_relic(*args, &block)
+        ensure
+          segment.finish
         end
       end
     end

data/lib/new_relic/agent/traced_method_stack.rb

@@ -100,6 +100,10 @@ module NewRelic
       def empty?
         @stack.empty?
       end
+
+      def last
+        @stack.last
+      end
     end
   end
 end

data/lib/new_relic/agent/transaction/datastore_segment.rb

@@ -10,18 +10,23 @@ module NewRelic
   module Agent
     class Transaction
       class DatastoreSegment < Segment
-        attr_reader :product, :operation, :collection, :sql_statement, :host, :port_path_or_id, :database_name
+        attr_reader :product, :operation, :collection, :sql_statement, :nosql_statement, :port_path_or_id
+        attr_accessor :host, :database_name
 
         def initialize product, operation, collection = nil, host = nil, port_path_or_id = nil, database_name=nil
           @product = product
           @operation = operation
           @collection = collection
           @sql_statement = nil
+          @nosql_statement = nil
           @host = host
-          @port_path_or_id = port_path_or_id
-          @database_name = database_name
-          super Datastores::MetricHelper.scoped_metric_for(product, operation, collection),
-                Datastores::MetricHelper.unscoped_metrics_for(product, operation, collection, host, port_path_or_id)
+          self.port_path_or_id = port_path_or_id
+          @database_name = database_name ? database_name.to_s : nil
+          super Datastores::MetricHelper.scoped_metric_for(product, operation, collection)
+        end
+
+        def port_path_or_id= ppi
+          @port_path_or_id = ppi ? ppi.to_s : nil
         end
 
         def notice_sql sql
@@ -34,11 +39,22 @@ module NewRelic
           @sql_statement = Database::Statement.new sql, config, explainer, binds, name, host, port_path_or_id, database_name
         end
 
+        def notice_nosql_statement nosql_statement
+          return unless record_sql?
+          @nosql_statement = nosql_statement
+        end
+
         private
 
+        def record_metrics
+          @unscoped_metrics = Datastores::MetricHelper.unscoped_metrics_for(product, operation, collection, host, port_path_or_id)
+          super
+        end
+
         def segment_complete
           add_segment_parameters
           notice_sql_statement if sql_statement
+          notice_statement if nosql_statement
         end
 
         def add_segment_parameters
@@ -65,6 +81,12 @@ module NewRelic
         def notice_sql_statement
           NewRelic::Agent.instance.transaction_sampler.notice_sql_statement(sql_statement, duration)
           NewRelic::Agent.instance.sql_sampler.notice_sql_statement(sql_statement.dup, name, duration)
+          nil
+        end
+
+        def notice_statement
+          NewRelic::Agent.instance.transaction_sampler.notice_nosql_statement(nosql_statement, duration)
+          nil
         end
 
         def record_sql?

data/lib/new_relic/agent/transaction/tracing.rb

@@ -47,6 +47,10 @@ module NewRelic
         def segment_complete segment
           state.traced_method_stack.pop_frame(state, segment, segment.name, segment.end_time, segment.record_metrics?)
         end
+
+        def current_segment
+          state.traced_method_stack.last
+        end
       end
     end
   end

data/lib/new_relic/version.rb

@@ -12,7 +12,7 @@ module NewRelic
 
     MAJOR = 3
     MINOR = 17
-    TINY  = 0
+    TINY  = 1
 
     begin
       require File.join(File.dirname(__FILE__), 'build')

data/lib/tasks/config.rake

@@ -23,9 +23,10 @@ namespace :newrelic do
 
     def output(format)
       config_hash = build_config_hash
-      flatten_config_hash(config_hash)
+      sections = flatten_config_hash(config_hash)
 
       puts build_erb(format).result(binding)
+      sections # silences unused warning to return this
     end
 
     def build_config_hash

data/test/helpers/mongo_metric_builder.rb

@@ -7,10 +7,17 @@ require 'new_relic/agent/datastores/mongo/metric_translator'
 module NewRelic
   module TestHelpers
     module MongoMetricBuilder
-      def build_test_metrics(name)
-        NewRelic::Agent::Datastores::MetricHelper.metrics_for("MongoDB",
-                                                              name,
-                                                              @collection_name)
+      def build_test_metrics(name, instance_metrics=false)
+        host = nil
+        port = nil
+
+        if instance_metrics
+          host = NewRelic::Agent::Hostname.get
+          port = 27017
+        end
+
+        NewRelic::Agent::Datastores::MetricHelper.metrics_for(
+          "MongoDB", name, @collection_name, host, port)
       end
 
       def metrics_with_attributes(metrics, attributes = { :call_count => 1 })

data/test/multiverse/suites/memcached/dalli_test.rb

@@ -8,9 +8,91 @@ if defined?(Dalli)
   class DalliTest < Minitest::Test
     include MemcacheTestCases
 
+    MULTI_OPERATIONS = [:get_multi, :get_multi_cas]
+
     def setup
       @cache = Dalli::Client.new("127.0.0.1:11211", :socket_timeout => 2.0)
     end
+
+    if ::NewRelic::Agent::Instrumentation::Memcache::Dalli.supports_datastore_instances?
+
+      def test_get_multi_in_web_with_capture_memcache_keys
+        with_config(:capture_memcache_keys => true) do
+          key = set_key_for_testcase
+          in_web_transaction("Controller/#{self.class}/action") do
+            @cache.get_multi(key)
+          end
+          trace = last_transaction_trace
+          segment = find_node_with_name trace, 'Datastore/operation/Memcached/get_multi_request'
+          assert_equal "get_multi_request [\"#{key}\"]", segment[:statement]
+        end
+      end
+
+      def test_assign_instance_to_with_ip_and_port
+        NewRelic::Agent::Hostname.stubs(:get).returns("jonan.pizza_cube")
+        segment = mock('datastore_segment')
+        segment.expects(:host=).with('jonan.pizza_cube')
+        segment.expects(:port_path_or_id=).with(11211)
+        server = ::Dalli::Server.new '127.0.0.1:11211'
+        ::NewRelic::Agent::Instrumentation::Memcache::Dalli.assign_instance_to(segment, server)
+      end
+
+      def test_assign_instance_to_with_name_and_port
+        NewRelic::Agent::Hostname.stubs(:get).returns("jonan.pizza_cube")
+        segment = mock('datastore_segment')
+        segment.expects(:host=).with('jonan.gummy_planet')
+        segment.expects(:port_path_or_id=).with(11211)
+        server = ::Dalli::Server.new 'jonan.gummy_planet:11211'
+        ::NewRelic::Agent::Instrumentation::Memcache::Dalli.assign_instance_to(segment, server)
+      end
+
+      def test_assign_instance_to_with_unix_domain_socket
+        NewRelic::Agent::Hostname.stubs(:get).returns("jonan.pizza_cube")
+        segment = mock('datastore_segment')
+        segment.expects(:host=).with('jonan.pizza_cube')
+        segment.expects(:port_path_or_id=).with('/tmp/jonanfs.sock')
+        server = ::Dalli::Server.new '/tmp/jonanfs.sock'
+        ::NewRelic::Agent::Instrumentation::Memcache::Dalli.assign_instance_to(segment, server)
+      end
+
+      def test_assign_instance_to_when_exception_raised
+        NewRelic::Agent::Hostname.stubs(:get).raises("oops")
+        segment = mock('datastore_segment')
+        segment.expects(:host=).with('unknown')
+        segment.expects(:port_path_or_id=).with('unknown')
+        server = ::Dalli::Server.new '/tmp/jonanfs.sock'
+        ::NewRelic::Agent::Instrumentation::Memcache::Dalli.assign_instance_to(segment, server)
+      end
+
+    end
+
+    def instance_metric
+      "Datastore/instance/Memcached/#{NewRelic::Agent::Hostname.get}/11211"
+    end
+
+    def expected_web_metrics(command)
+      if ::NewRelic::Agent::Instrumentation::Memcache::Dalli.supports_datastore_instances?
+        datastore_command = MULTI_OPERATIONS.include?(command) ? :get_multi_request : command
+        metrics = super(datastore_command)
+        metrics.unshift instance_metric
+        metrics.unshift "Ruby/Memcached/Dalli/#{command}" if command != datastore_command
+        metrics
+      else
+        super
+      end
+    end
+
+    def expected_bg_metrics(command)
+      if ::NewRelic::Agent::Instrumentation::Memcache::Dalli.supports_datastore_instances?
+        datastore_command = MULTI_OPERATIONS.include?(command) ? :get_multi_request : command
+        metrics = super(datastore_command)
+        metrics.unshift instance_metric
+        metrics.unshift "Ruby/Memcached/Dalli/#{command}" if command != datastore_command
+        metrics
+      else
+        super
+      end
+    end
   end
 
   if Dalli::VERSION >= '2.7'
@@ -50,7 +132,6 @@ if defined?(Dalli)
         assert_equal value.values.first.first, @cache.get(@cas_key)
       end
 
-
       def test_set_cas
         expected_metrics = expected_web_metrics(:set_cas)
 

data/test/multiverse/suites/memcached/memcache_test_cases.rb

@@ -48,7 +48,7 @@ module MemcacheTestCases
   end
 
   def assert_memcache_metrics_recorded(expected_metrics)
-    assert_metrics_recorded_exclusive expected_metrics, :filter => /^memcache.*/i
+    assert_metrics_recorded_exclusive expected_metrics, :filter => /^datastore.*/i
   end
 
   def test_get_in_web
@@ -289,14 +289,27 @@ module MemcacheTestCases
   end
 
   def test_cas_in_background
-      key = set_key_for_testcase(1)
-      expected_metrics = expected_bg_metrics(:cas)
+    key = set_key_for_testcase(1)
+    expected_metrics = expected_bg_metrics(:cas)
 
-      in_background_transaction("OtherTransaction/Background/#{self.class}/bg_task") do
-        @cache.cas(key) {|val| val += 2}
-      end
+    in_background_transaction("OtherTransaction/Background/#{self.class}/bg_task") do
+      @cache.cas(key) {|val| val += 2}
+    end
+
+    assert_memcache_metrics_recorded expected_metrics
+    assert_equal 3, @cache.get(key)
+  end
 
-      assert_memcache_metrics_recorded expected_metrics
-      assert_equal 3, @cache.get(key)
+  def test_get_in_web_with_capture_memcache_keys
+    with_config(:capture_memcache_keys => true) do
+      key = set_key_for_testcase
+      in_web_transaction("Controller/#{self.class}/action") do
+        @cache.get(key)
+      end
+      trace = last_transaction_trace
+      segment = find_node_with_name trace, 'Datastore/operation/Memcached/get'
+      assert_equal "get \"#{key}\"", segment[:statement]
     end
+  end
+
 end

data/test/multiverse/suites/memcached/memcached_test.rb

@@ -12,11 +12,26 @@ if defined?(Memcached)
       @cache = Memcached.new('localhost', :support_cas => true)
     end
 
+    def additional_web_metrics_for command
+      [
+        "Datastore/operation/Memcached/#{command}",
+        ["Datastore/operation/Memcached/#{command}", "Controller/#{self.class}/action"]
+      ]
+    end
+
+    def additional_bg_metrics_for command
+      [
+        "Datastore/operation/Memcached/#{command}",
+        ["Datastore/operation/Memcached/#{command}", "OtherTransaction/Background/#{self.class}/bg_task"]
+      ]
+    end
+
     def test_get_in_web
       if Memcached::VERSION >= '1.8.0'
         key = set_key_for_testcase
 
         expected_metrics = expected_web_metrics(:single_get)
+        expected_metrics += additional_web_metrics_for(:get)
 
         in_web_transaction("Controller/#{self.class}/action") do
           @cache.get(key)
@@ -33,6 +48,7 @@ if defined?(Memcached)
       key = set_key_for_testcase
 
       expected_metrics = expected_web_metrics(:multi_get)
+      expected_metrics += additional_web_metrics_for(:get)
 
       in_web_transaction("Controller/#{self.class}/action") do
         @cache.get([key])
@@ -72,6 +88,7 @@ if defined?(Memcached)
 
       if Memcached::VERSION >= '1.8.0'
         expected_metrics = (expected_web_metrics(:single_get) + expected_web_metrics(:single_cas)).uniq
+        expected_metrics += additional_web_metrics_for(:cas)
       else
         expected_metrics = expected_web_metrics(:cas)
       end
@@ -89,6 +106,7 @@ if defined?(Memcached)
         key = set_key_for_testcase
 
         expected_metrics = expected_bg_metrics(:single_get)
+        expected_metrics += additional_bg_metrics_for(:get)
 
         in_background_transaction("OtherTransaction/Background/#{self.class}/bg_task") do
           @cache.get(key)
@@ -106,6 +124,7 @@ if defined?(Memcached)
       key = set_key_for_testcase
 
       expected_metrics = expected_bg_metrics(:multi_get)
+      expected_metrics += additional_bg_metrics_for(:get)
 
       in_background_transaction("OtherTransaction/Background/#{self.class}/bg_task") do
         @cache.get([key])
@@ -144,6 +163,7 @@ if defined?(Memcached)
       key = set_key_for_testcase(1)
       if Memcached::VERSION >= '1.8.0'
         expected_metrics = (expected_bg_metrics(:single_get) + expected_bg_metrics(:single_cas)).uniq
+        expected_metrics += additional_bg_metrics_for(:cas)
       else
         expected_metrics = expected_bg_metrics(:cas)
       end
@@ -156,4 +176,4 @@ if defined?(Memcached)
       assert_equal 3, @cache.get(key)
     end
   end
-end
+end

data/test/multiverse/suites/mongo/mongo2_instrumentation_test.rb

@@ -38,7 +38,7 @@ if NewRelic::Agent::Datastores::Mongo.is_supported_version? &&
           def test_records_metrics_for_insert_one
             @collection.insert_one(@tribbles.first)
 
-            metrics = build_test_metrics(:insert)
+            metrics = build_test_metrics(:insert, true)
             expected = metrics_with_attributes(metrics)
 
             assert_metrics_recorded(expected)
@@ -47,7 +47,7 @@ if NewRelic::Agent::Datastores::Mongo.is_supported_version? &&
           def test_records_metrics_for_insert_many
             @collection.insert_many(@tribbles)
 
-            metrics = build_test_metrics(:insert)
+            metrics = build_test_metrics(:insert, true)
             expected = metrics_with_attributes(metrics)
 
             assert_metrics_recorded(expected)
@@ -59,7 +59,7 @@ if NewRelic::Agent::Datastores::Mongo.is_supported_version? &&
 
             @collection.delete_one(@tribbles.first)
 
-            metrics = build_test_metrics(:delete)
+            metrics = build_test_metrics(:delete, true)
             expected = metrics_with_attributes(metrics)
 
             assert_metrics_recorded(expected)
@@ -71,7 +71,7 @@ if NewRelic::Agent::Datastores::Mongo.is_supported_version? &&
 
             @collection.delete_many(@tribbles.first)
 
-            metrics = build_test_metrics(:delete)
+            metrics = build_test_metrics(:delete, true)
             expected = metrics_with_attributes(metrics)
 
             assert_metrics_recorded(expected)
@@ -83,7 +83,7 @@ if NewRelic::Agent::Datastores::Mongo.is_supported_version? &&
 
             @collection.replace_one(@tribbles[0], @tribbles[1])
 
-            metrics = build_test_metrics(:update)
+            metrics = build_test_metrics(:update, true)
             expected = metrics_with_attributes(metrics)
 
             assert_metrics_recorded(expected)
@@ -95,7 +95,7 @@ if NewRelic::Agent::Datastores::Mongo.is_supported_version? &&
 
             @collection.update_one(@tribbles[0], "$set" => @tribbles[1])
 
-            metrics = build_test_metrics(:update)
+            metrics = build_test_metrics(:update, true)
             expected = metrics_with_attributes(metrics)
 
             assert_metrics_recorded(expected)
@@ -107,7 +107,7 @@ if NewRelic::Agent::Datastores::Mongo.is_supported_version? &&
 
             @collection.update_many(@tribbles[0], "$set" => @tribbles[1])
 
-            metrics = build_test_metrics(:update)
+            metrics = build_test_metrics(:update, true)
             expected = metrics_with_attributes(metrics)
 
             assert_metrics_recorded(expected)
@@ -119,7 +119,7 @@ if NewRelic::Agent::Datastores::Mongo.is_supported_version? &&
 
             @collection.find(@tribbles.first).to_a
 
-            metrics = build_test_metrics(:find)
+            metrics = build_test_metrics(:find, true)
             expected = metrics_with_attributes(metrics)
 
             assert_metrics_recorded(expected)
@@ -131,7 +131,7 @@ if NewRelic::Agent::Datastores::Mongo.is_supported_version? &&
 
             @collection.find_one_and_delete(@tribbles.first)
 
-            metrics = build_test_metrics(:findandmodify)
+            metrics = build_test_metrics(:findandmodify, true)
             expected = metrics_with_attributes(metrics)
 
             assert_metrics_recorded(expected)
@@ -143,7 +143,7 @@ if NewRelic::Agent::Datastores::Mongo.is_supported_version? &&
 
             @collection.find_one_and_replace(@tribbles[0], @tribbles[1])
 
-            metrics = build_test_metrics(:findandmodify)
+            metrics = build_test_metrics(:findandmodify, true)
             expected = metrics_with_attributes(metrics)
 
             assert_metrics_recorded(expected)
@@ -155,7 +155,7 @@ if NewRelic::Agent::Datastores::Mongo.is_supported_version? &&
 
             @collection.find_one_and_update(@tribbles[0], "$set" => @tribbles[1])
 
-            metrics = build_test_metrics(:findandmodify)
+            metrics = build_test_metrics(:findandmodify, true)
             expected = metrics_with_attributes(metrics)
 
             assert_metrics_recorded(expected)
@@ -164,7 +164,7 @@ if NewRelic::Agent::Datastores::Mongo.is_supported_version? &&
           def test_records_metrics_for_distinct
             @collection.distinct('name')
 
-            metrics = build_test_metrics(:distinct)
+            metrics = build_test_metrics(:distinct, true)
             expected = metrics_with_attributes(metrics)
 
             assert_metrics_recorded(expected)
@@ -173,7 +173,7 @@ if NewRelic::Agent::Datastores::Mongo.is_supported_version? &&
           def test_records_metrics_for_count
             @collection.count
 
-            metrics = build_test_metrics(:count)
+            metrics = build_test_metrics(:count, true)
             expected = metrics_with_attributes(metrics)
 
             assert_metrics_recorded(expected)
@@ -192,6 +192,7 @@ if NewRelic::Agent::Datastores::Mongo.is_supported_version? &&
               "Datastore/statement/MongoDB/#{@collection_name}/getMore" => {:call_count=>2},
               "Datastore/operation/MongoDB/find" => {:call_count=>1},
               "Datastore/operation/MongoDB/getMore" => {:call_count=>2},
+              "Datastore/instance/MongoDB/#{NewRelic::Agent::Hostname.get}/27017" => {:call_count=>3},
               "Datastore/MongoDB/allWeb" => {:call_count=>3},
               "Datastore/MongoDB/all" => {:call_count=>3},
               "Datastore/allWeb" => { :call_count=>3},
@@ -224,10 +225,25 @@ if NewRelic::Agent::Datastores::Mongo.is_supported_version? &&
             assert_equal expected, actual
           end
 
+          def test_trace_nodes_have_instance_attributes
+            @collection.insert_one :name => "test", :active => true
+            NewRelic::Agent.drop_buffered_data
+            in_transaction "webby" do
+              @collection.find(:active => true).to_a
+            end
+
+            trace = last_transaction_trace
+            node = find_node_with_name_matching trace, /^Datastore\//
+
+            assert_equal NewRelic::Agent::Hostname.get, node[:host]
+            assert_equal '27017', node[:port_path_or_id]
+            assert_equal @database_name, node[:database_name]
+          end
+
           def test_drop_collection
             @collection.drop
 
-            metrics = build_test_metrics(:drop)
+            metrics = build_test_metrics(:drop, true)
             expected = metrics_with_attributes(metrics)
 
             assert_metrics_recorded(expected)
@@ -243,7 +259,7 @@ if NewRelic::Agent::Datastores::Mongo.is_supported_version? &&
           end
 
           def statement_metric(action)
-            metrics = build_test_metrics(action)
+            metrics = build_test_metrics(action, true)
             metrics.select { |m| m.start_with?("Datastore/statement") }.first
           end
 
@@ -354,7 +370,7 @@ if NewRelic::Agent::Datastores::Mongo.is_supported_version? &&
             NewRelic::Agent::Transaction.stubs(:recording_web_transaction?).returns(true)
             @collection.insert_one(@tribbles.first)
 
-            metrics = build_test_metrics(:insert)
+            metrics = build_test_metrics(:insert, true)
             expected = metrics_with_attributes(metrics)
 
             assert_metrics_recorded(expected)
@@ -371,7 +387,7 @@ if NewRelic::Agent::Datastores::Mongo.is_supported_version? &&
             NewRelic::Agent::Transaction.stubs(:recording_web_transaction?).returns(false)
             @collection.insert_one(@tribbles.first)
 
-            metrics = build_test_metrics(:insert)
+            metrics = build_test_metrics(:insert, true)
             expected = metrics_with_attributes(metrics)
 
             assert_metrics_recorded(expected)