SERVER-65239 Add debug log observability of ResourceConsumption metrics

11 files changed, 219 insertions, 165 deletions

diff --git a/src/mongo/db/commands/find_and_modify.cpp b/src/mongo/db/commands/find_and_modify.cpp
index 6fc5b84c654..221d053036a 100644
--- a/src/mongo/db/commands/find_and_modify.cpp
+++ b/src/mongo/db/commands/find_and_modify.cpp
@@ -403,7 +403,7 @@ write_ops::FindAndModifyCommandReply CmdFindAndModify::Invocation::writeConflict
         docUnitsReturned.observeOne(docFound->objsize());
 
         auto& metricsCollector = ResourceConsumption::MetricsCollector::get(opCtx);
-        metricsCollector.incrementDocUnitsReturned(docUnitsReturned);
+        metricsCollector.incrementDocUnitsReturned(curOp->getNS(), docUnitsReturned);
     }
 
     return buildResponse(exec.get(), request.getRemove().value_or(false), docFound);
@@ -506,7 +506,7 @@ write_ops::FindAndModifyCommandReply CmdFindAndModify::Invocation::writeConflict
         docUnitsReturned.observeOne(docFound->objsize());
 
         auto& metricsCollector = ResourceConsumption::MetricsCollector::get(opCtx);
-        metricsCollector.incrementDocUnitsReturned(docUnitsReturned);
+        metricsCollector.incrementDocUnitsReturned(curOp->getNS(), docUnitsReturned);
     }
 
     return buildResponse(exec.get(), request.getRemove().value_or(false), docFound);
diff --git a/src/mongo/db/commands/find_cmd.cpp b/src/mongo/db/commands/find_cmd.cpp
index ef292a00ead..b16aa1304f4 100644
--- a/src/mongo/db/commands/find_cmd.cpp
+++ b/src/mongo/db/commands/find_cmd.cpp
@@ -737,7 +737,7 @@ public:
             // Increment this metric once we have generated a response and we know it will return
             // documents.
             auto& metricsCollector = ResourceConsumption::MetricsCollector::get(opCtx);
-            metricsCollector.incrementDocUnitsReturned(docUnitsReturned);
+            metricsCollector.incrementDocUnitsReturned(nss.ns(), docUnitsReturned);
             query_request_helper::validateCursorResponse(result->getBodyBuilder().asTempObj());
         }
 
diff --git a/src/mongo/db/commands/getmore_cmd.cpp b/src/mongo/db/commands/getmore_cmd.cpp
index 6aed4fb7583..eacb27e85ff 100644
--- a/src/mongo/db/commands/getmore_cmd.cpp
+++ b/src/mongo/db/commands/getmore_cmd.cpp
@@ -713,7 +713,7 @@ public:
             // Increment this metric once we have generated a response and we know it will return
             // documents.
             auto& metricsCollector = ResourceConsumption::MetricsCollector::get(opCtx);
-            metricsCollector.incrementDocUnitsReturned(docUnitsReturned);
+            metricsCollector.incrementDocUnitsReturned(curOp->getNS(), docUnitsReturned);
             cursorPin->incNReturnedSoFar(numResults);
             cursorPin->incNBatches();
 
diff --git a/src/mongo/db/commands/run_aggregate.cpp b/src/mongo/db/commands/run_aggregate.cpp
index 576ee9c3d39..6cb0760d139 100644
--- a/src/mongo/db/commands/run_aggregate.cpp
+++ b/src/mongo/db/commands/run_aggregate.cpp
@@ -289,7 +289,7 @@ bool handleCursorCommand(OperationContext* opCtx,
     responseBuilder.done(cursorId, nsForCursor.ns());
 
     auto& metricsCollector = ResourceConsumption::MetricsCollector::get(opCtx);
-    metricsCollector.incrementDocUnitsReturned(docUnitsReturned);
+    metricsCollector.incrementDocUnitsReturned(curOp->getNS(), docUnitsReturned);
 
     return static_cast<bool>(cursor);
 }
diff --git a/src/mongo/db/stats/resource_consumption_metrics.cpp b/src/mongo/db/stats/resource_consumption_metrics.cpp
index 92e7a64c259..24d36012f2c 100644
--- a/src/mongo/db/stats/resource_consumption_metrics.cpp
+++ b/src/mongo/db/stats/resource_consumption_metrics.cpp
@@ -37,7 +37,7 @@
 #include "mongo/db/stats/operation_resource_consumption_gen.h"
 #include "mongo/logv2/log.h"
 
-#define MONGO_LOGV2_DEFAULT_COMPONENT ::mongo::logv2::LogComponent::kControl
+#define MONGO_LOGV2_DEFAULT_COMPONENT ::mongo::logv2::LogComponent::kResourceConsumption
 
 
 namespace mongo {
@@ -239,36 +239,83 @@ inline void ResourceConsumption::MetricsCollector::_doIfCollecting(Func&& func)
     func();
 }
 
-void ResourceConsumption::MetricsCollector::incrementOneDocRead(size_t docBytesRead) {
-    _doIfCollecting([&]() { _metrics.readMetrics.docsRead.observeOne(docBytesRead); });
+void ResourceConsumption::MetricsCollector::incrementOneDocRead(std::string uri,
+                                                                size_t docBytesRead) {
+    _doIfCollecting([&]() {
+        LOGV2_DEBUG(6523900,
+                    1,
+                    "ResourceConsumption::MetricsCollector::incrementOneDocRead",
+                    "uri"_attr = uri,
+                    "bytes"_attr = docBytesRead);
+        _metrics.readMetrics.docsRead.observeOne(docBytesRead);
+    });
 }
 
-void ResourceConsumption::MetricsCollector::incrementOneIdxEntryRead(size_t bytesRead) {
-    _doIfCollecting([&]() { _metrics.readMetrics.idxEntriesRead.observeOne(bytesRead); });
+void ResourceConsumption::MetricsCollector::incrementOneIdxEntryRead(std::string uri,
+                                                                     size_t bytesRead) {
+    _doIfCollecting([&]() {
+        LOGV2_DEBUG(6523901,
+                    1,
+                    "ResourceConsumption::MetricsCollector::incrementOneIdxEntryRead",
+                    "uri"_attr = uri,
+                    "bytes"_attr = bytesRead);
+        _metrics.readMetrics.idxEntriesRead.observeOne(bytesRead);
+    });
 }
 
 void ResourceConsumption::MetricsCollector::incrementKeysSorted(size_t keysSorted) {
-    _doIfCollecting([&]() { _metrics.readMetrics.keysSorted += keysSorted; });
+    _doIfCollecting([&]() {
+        LOGV2_DEBUG(6523902,
+                    1,
+                    "ResourceConsumption::MetricsCollector::incrementKeysSorted",
+                    "keysSorted"_attr = keysSorted);
+        _metrics.readMetrics.keysSorted += keysSorted;
+    });
 }
 
 void ResourceConsumption::MetricsCollector::incrementSorterSpills(size_t spills) {
-    _doIfCollecting([&]() { _metrics.readMetrics.sorterSpills += spills; });
+    _doIfCollecting([&]() {
+        LOGV2_DEBUG(6523903,
+                    1,
+                    "ResourceConsumption::MetricsCollector::incrementSorterSpills",
+                    "spills"_attr = spills);
+        _metrics.readMetrics.sorterSpills += spills;
+    });
 }
 
 void ResourceConsumption::MetricsCollector::incrementDocUnitsReturned(
-    DocumentUnitCounter docUnits) {
-    _doIfCollecting([&]() { _metrics.readMetrics.docsReturned += docUnits; });
+    std::string ns, DocumentUnitCounter docUnits) {
+    _doIfCollecting([&]() {
+        LOGV2_DEBUG(6523904,
+                    1,
+                    "ResourceConsumption::MetricsCollector::incrementDocUnitsReturned",
+                    "ns"_attr = ns,
+                    "docUnits"_attr = docUnits.units());
+        _metrics.readMetrics.docsReturned += docUnits;
+    });
 }
 
-void ResourceConsumption::MetricsCollector::incrementOneDocWritten(size_t bytesWritten) {
+void ResourceConsumption::MetricsCollector::incrementOneDocWritten(std::string uri,
+                                                                   size_t bytesWritten) {
     _doIfCollecting([&] {
+        LOGV2_DEBUG(6523905,
+                    1,
+                    "ResourceConsumption::MetricsCollector::incrementOneDocWritten",
+                    "uri"_attr = uri,
+                    "bytesWritten"_attr = bytesWritten);
         _metrics.writeMetrics.docsWritten.observeOne(bytesWritten);
         _metrics.writeMetrics.totalWritten.observeOneDocument(bytesWritten);
     });
 }
 
-void ResourceConsumption::MetricsCollector::incrementOneIdxEntryWritten(size_t bytesWritten) {
+void ResourceConsumption::MetricsCollector::incrementOneIdxEntryWritten(std::string uri,
+                                                                        size_t bytesWritten) {
     _doIfCollecting([&] {
+        LOGV2_DEBUG(6523906,
+                    1,
+                    "ResourceConsumption::MetricsCollector::incrementOneIdxEntryWritten",
+                    "uri"_attr = uri,
+                    "bytesWritten"_attr = bytesWritten);
         _metrics.writeMetrics.idxEntriesWritten.observeOne(bytesWritten);
         _metrics.writeMetrics.totalWritten.observeOneIndexEntry(bytesWritten);
     });
@@ -297,8 +344,14 @@ bool ResourceConsumption::MetricsCollector::endScopedCollecting() {
     return wasCollecting;
 }
 
-void ResourceConsumption::MetricsCollector::incrementOneCursorSeek() {
-    _doIfCollecting([&] { _metrics.readMetrics.cursorSeeks++; });
+void ResourceConsumption::MetricsCollector::incrementOneCursorSeek(std::string uri) {
+    _doIfCollecting([&] {
+        LOGV2_DEBUG(6523907,
+                    1,
+                    "ResourceConsumption::MetricsCollector::incrementOneCursorSeek",
+                    "uri"_attr = uri);
+        _metrics.readMetrics.cursorSeeks++;
+    });
 }
 
 ResourceConsumption::ScopedMetricsCollector::ScopedMetricsCollector(OperationContext* opCtx,
diff --git a/src/mongo/db/stats/resource_consumption_metrics.h b/src/mongo/db/stats/resource_consumption_metrics.h
index 4aef396e6b6..bd132dcaf26 100644
--- a/src/mongo/db/stats/resource_consumption_metrics.h
+++ b/src/mongo/db/stats/resource_consumption_metrics.h
@@ -344,13 +344,13 @@ public:
          * This should be called once per document read with the number of bytes read for that
          * document.  This is a no-op when metrics collection is disabled on this operation.
          */
-        void incrementOneDocRead(size_t docBytesRead);
+        void incrementOneDocRead(std::string uri, size_t docBytesRead);
 
         /**
          * This should be called once per index entry read with the number of bytes read for that
          * entry. This is a no-op when metrics collection is disabled on this operation.
          */
-        void incrementOneIdxEntryRead(size_t idxEntryBytesRead);
+        void incrementOneIdxEntryRead(std::string uri, size_t idxEntryBytesRead);
 
         /**
          * Increments the number of keys sorted for a query operation. This is a no-op when metrics
@@ -367,7 +367,7 @@ public:
         /**
          * Increments the number of document units returned in the command response.
          */
-        void incrementDocUnitsReturned(DocumentUnitCounter docUnitsReturned);
+        void incrementDocUnitsReturned(std::string ns, DocumentUnitCounter docUnitsReturned);
 
         /**
          * This should be called once per document written with the number of bytes written for that
@@ -375,13 +375,13 @@ public:
          * function should not be called when the operation is a write to the oplog. The metrics are
          * only for operations that are not oplog writes.
          */
-        void incrementOneDocWritten(size_t docBytesWritten);
+        void incrementOneDocWritten(std::string uri, size_t docBytesWritten);
 
         /**
          * This should be called once per index entry written with the number of bytes written for
          * that entry. This is a no-op when metrics collection is disabled on this operation.
          */
-        void incrementOneIdxEntryWritten(size_t idxEntryBytesWritten);
+        void incrementOneIdxEntryWritten(std::string uri, size_t idxEntryBytesWritten);
 
         /**
          * This should be called once every time the storage engine successfully does a cursor seek.
@@ -389,7 +389,7 @@ public:
          * only be called once. If the seek does not find anything, this function should not be
          * called.
          */
-        void incrementOneCursorSeek();
+        void incrementOneCursorSeek(std::string uri);
 
     private:
         // Privatize copy constructors to prevent callers from accidentally copying when this is
diff --git a/src/mongo/db/stats/resource_consumption_metrics_test.cpp b/src/mongo/db/stats/resource_consumption_metrics_test.cpp
index a4398f8fada..25b30274e23 100644
--- a/src/mongo/db/stats/resource_consumption_metrics_test.cpp
+++ b/src/mongo/db/stats/resource_consumption_metrics_test.cpp
@@ -222,12 +222,12 @@ TEST_F(ResourceConsumptionMetricsTest, IncrementReadMetrics) {
     {
         ResourceConsumption::ScopedMetricsCollector scope(_opCtx.get(), "db1");
 
-        operationMetrics.incrementOneDocRead(2);
-        operationMetrics.incrementOneIdxEntryRead(8);
+        operationMetrics.incrementOneDocRead("", 2);
+        operationMetrics.incrementOneIdxEntryRead("", 8);
         operationMetrics.incrementKeysSorted(16);
         operationMetrics.incrementSorterSpills(32);
-        operationMetrics.incrementDocUnitsReturned(makeDocUnits(64));
-        operationMetrics.incrementOneCursorSeek();
+        operationMetrics.incrementDocUnitsReturned("", makeDocUnits(64));
+        operationMetrics.incrementOneCursorSeek("");
     }
 
     ASSERT(operationMetrics.hasCollectedMetrics());
@@ -249,12 +249,12 @@ TEST_F(ResourceConsumptionMetricsTest, IncrementReadMetrics) {
     {
         ResourceConsumption::ScopedMetricsCollector scope(_opCtx.get(), "db1");
 
-        operationMetrics.incrementOneDocRead(32);
-        operationMetrics.incrementOneIdxEntryRead(128);
+        operationMetrics.incrementOneDocRead("", 32);
+        operationMetrics.incrementOneIdxEntryRead("", 128);
         operationMetrics.incrementKeysSorted(256);
         operationMetrics.incrementSorterSpills(512);
-        operationMetrics.incrementDocUnitsReturned(makeDocUnits(1024));
-        operationMetrics.incrementOneCursorSeek();
+        operationMetrics.incrementDocUnitsReturned("", makeDocUnits(1024));
+        operationMetrics.incrementOneCursorSeek("");
     }
 
     metricsCopy = globalResourceConsumption.getDbMetrics();
@@ -279,12 +279,12 @@ TEST_F(ResourceConsumptionMetricsTest, IncrementReadMetricsSecondary) {
     {
         ResourceConsumption::ScopedMetricsCollector scope(_opCtx.get(), "db1");
 
-        operationMetrics.incrementOneDocRead(2);
-        operationMetrics.incrementOneIdxEntryRead(8);
+        operationMetrics.incrementOneDocRead("", 2);
+        operationMetrics.incrementOneIdxEntryRead("", 8);
         operationMetrics.incrementKeysSorted(16);
         operationMetrics.incrementSorterSpills(32);
-        operationMetrics.incrementDocUnitsReturned(makeDocUnits(64));
-        operationMetrics.incrementOneCursorSeek();
+        operationMetrics.incrementDocUnitsReturned("", makeDocUnits(64));
+        operationMetrics.incrementOneCursorSeek("");
     }
 
     auto metricsCopy = globalResourceConsumption.getDbMetrics();
@@ -304,12 +304,12 @@ TEST_F(ResourceConsumptionMetricsTest, IncrementReadMetricsSecondary) {
     {
         ResourceConsumption::ScopedMetricsCollector scope(_opCtx.get(), "db1");
 
-        operationMetrics.incrementOneDocRead(32);
-        operationMetrics.incrementOneIdxEntryRead(128);
+        operationMetrics.incrementOneDocRead("", 32);
+        operationMetrics.incrementOneIdxEntryRead("", 128);
         operationMetrics.incrementKeysSorted(256);
         operationMetrics.incrementSorterSpills(512);
-        operationMetrics.incrementDocUnitsReturned(makeDocUnits(1024));
-        operationMetrics.incrementOneCursorSeek();
+        operationMetrics.incrementDocUnitsReturned("", makeDocUnits(1024));
+        operationMetrics.incrementOneCursorSeek("");
     }
 
     metricsCopy = globalResourceConsumption.getDbMetrics();
@@ -333,22 +333,22 @@ TEST_F(ResourceConsumptionMetricsTest, IncrementReadMetricsAcrossStates) {
     {
         ResourceConsumption::ScopedMetricsCollector scope(_opCtx.get(), "db1");
 
-        operationMetrics.incrementOneDocRead(2);
-        operationMetrics.incrementOneIdxEntryRead(8);
+        operationMetrics.incrementOneDocRead("", 2);
+        operationMetrics.incrementOneIdxEntryRead("", 8);
         operationMetrics.incrementKeysSorted(16);
         operationMetrics.incrementSorterSpills(32);
-        operationMetrics.incrementDocUnitsReturned(makeDocUnits(64));
-        operationMetrics.incrementOneCursorSeek();
+        operationMetrics.incrementDocUnitsReturned("", makeDocUnits(64));
+        operationMetrics.incrementOneCursorSeek("");
 
         ASSERT_OK(repl::ReplicationCoordinator::get(_opCtx.get())
                       ->setFollowerMode(repl::MemberState::RS_SECONDARY));
 
-        operationMetrics.incrementOneDocRead(32);
-        operationMetrics.incrementOneIdxEntryRead(128);
+        operationMetrics.incrementOneDocRead("", 32);
+        operationMetrics.incrementOneIdxEntryRead("", 128);
         operationMetrics.incrementKeysSorted(256);
         operationMetrics.incrementSorterSpills(512);
-        operationMetrics.incrementDocUnitsReturned(makeDocUnits(1024));
-        operationMetrics.incrementOneCursorSeek();
+        operationMetrics.incrementDocUnitsReturned("", makeDocUnits(1024));
+        operationMetrics.incrementOneCursorSeek("");
     }
 
     auto metricsCopy = globalResourceConsumption.getAndClearDbMetrics();
@@ -377,22 +377,22 @@ TEST_F(ResourceConsumptionMetricsTest, IncrementReadMetricsAcrossStates) {
     {
         ResourceConsumption::ScopedMetricsCollector scope(_opCtx.get(), "db1");
 
-        operationMetrics.incrementOneDocRead(2);
-        operationMetrics.incrementOneIdxEntryRead(8);
+        operationMetrics.incrementOneDocRead("", 2);
+        operationMetrics.incrementOneIdxEntryRead("", 8);
         operationMetrics.incrementKeysSorted(16);
         operationMetrics.incrementSorterSpills(32);
-        operationMetrics.incrementDocUnitsReturned(makeDocUnits(64));
-        operationMetrics.incrementOneCursorSeek();
+        operationMetrics.incrementDocUnitsReturned("", makeDocUnits(64));
+        operationMetrics.incrementOneCursorSeek("");
 
         ASSERT_OK(repl::ReplicationCoordinator::get(_opCtx.get())
                       ->setFollowerMode(repl::MemberState::RS_PRIMARY));
 
-        operationMetrics.incrementOneDocRead(32);
-        operationMetrics.incrementOneIdxEntryRead(128);
+        operationMetrics.incrementOneDocRead("", 32);
+        operationMetrics.incrementOneIdxEntryRead("", 128);
         operationMetrics.incrementKeysSorted(256);
         operationMetrics.incrementSorterSpills(512);
-        operationMetrics.incrementDocUnitsReturned(makeDocUnits(1024));
-        operationMetrics.incrementOneCursorSeek();
+        operationMetrics.incrementDocUnitsReturned("", makeDocUnits(1024));
+        operationMetrics.incrementOneCursorSeek("");
     }
 
     metricsCopy = globalResourceConsumption.getAndClearDbMetrics();
@@ -427,21 +427,21 @@ TEST_F(ResourceConsumptionMetricsTest, DocumentUnitsRead) {
         ResourceConsumption::ScopedMetricsCollector scope(_opCtx.get(), "db1");
 
         // Each of these should be counted as 1 document unit (unit size = 128).
-        operationMetrics.incrementOneDocRead(2);
-        operationMetrics.incrementOneDocRead(4);
-        operationMetrics.incrementOneDocRead(8);
-        operationMetrics.incrementOneDocRead(16);
-        operationMetrics.incrementOneDocRead(32);
-        operationMetrics.incrementOneDocRead(64);
-        operationMetrics.incrementOneDocRead(128);
+        operationMetrics.incrementOneDocRead("", 2);
+        operationMetrics.incrementOneDocRead("", 4);
+        operationMetrics.incrementOneDocRead("", 8);
+        operationMetrics.incrementOneDocRead("", 16);
+        operationMetrics.incrementOneDocRead("", 32);
+        operationMetrics.incrementOneDocRead("", 64);
+        operationMetrics.incrementOneDocRead("", 128);
         expectedBytes += 2 + 4 + 8 + 16 + 32 + 64 + 128;
         expectedUnits += 7;
 
         // Each of these should be counted as 2 document units (unit size = 128).
-        operationMetrics.incrementOneDocRead(129);
-        operationMetrics.incrementOneDocRead(200);
-        operationMetrics.incrementOneDocRead(255);
-        operationMetrics.incrementOneDocRead(256);
+        operationMetrics.incrementOneDocRead("", 129);
+        operationMetrics.incrementOneDocRead("", 200);
+        operationMetrics.incrementOneDocRead("", 255);
+        operationMetrics.incrementOneDocRead("", 256);
         expectedBytes += 129 + 200 + 255 + 256;
         expectedUnits += 8;
     }
@@ -462,21 +462,21 @@ TEST_F(ResourceConsumptionMetricsTest, DocumentUnitsWritten) {
         ResourceConsumption::ScopedMetricsCollector scope(_opCtx.get(), "db1");
 
         // Each of these should be counted as 1 document unit (unit size = 128).
-        operationMetrics.incrementOneDocWritten(2);
-        operationMetrics.incrementOneDocWritten(4);
-        operationMetrics.incrementOneDocWritten(8);
-        operationMetrics.incrementOneDocWritten(16);
-        operationMetrics.incrementOneDocWritten(32);
-        operationMetrics.incrementOneDocWritten(64);
-        operationMetrics.incrementOneDocWritten(128);
+        operationMetrics.incrementOneDocWritten("", 2);
+        operationMetrics.incrementOneDocWritten("", 4);
+        operationMetrics.incrementOneDocWritten("", 8);
+        operationMetrics.incrementOneDocWritten("", 16);
+        operationMetrics.incrementOneDocWritten("", 32);
+        operationMetrics.incrementOneDocWritten("", 64);
+        operationMetrics.incrementOneDocWritten("", 128);
         expectedBytes += 2 + 4 + 8 + 16 + 32 + 64 + 128;
         expectedUnits += 7;
 
         // Each of these should be counted as 2 document units (unit size = 128).
-        operationMetrics.incrementOneDocWritten(129);
-        operationMetrics.incrementOneDocWritten(200);
-        operationMetrics.incrementOneDocWritten(255);
-        operationMetrics.incrementOneDocWritten(256);
+        operationMetrics.incrementOneDocWritten("", 129);
+        operationMetrics.incrementOneDocWritten("", 200);
+        operationMetrics.incrementOneDocWritten("", 255);
+        operationMetrics.incrementOneDocWritten("", 256);
         expectedBytes += 129 + 200 + 255 + 256;
         expectedUnits += 8;
     }
@@ -496,50 +496,50 @@ TEST_F(ResourceConsumptionMetricsTest, TotalUnitsWritten) {
         ResourceConsumption::ScopedMetricsCollector scope(_opCtx.get(), "db1");
 
         // Each of these should be counted as 1 total unit (unit size = 128).
-        operationMetrics.incrementOneDocWritten(2);
-        operationMetrics.incrementOneDocWritten(4);
-        operationMetrics.incrementOneDocWritten(8);
-        operationMetrics.incrementOneDocWritten(16);
-        operationMetrics.incrementOneDocWritten(32);
-        operationMetrics.incrementOneDocWritten(64);
-        operationMetrics.incrementOneDocWritten(128);
+        operationMetrics.incrementOneDocWritten("", 2);
+        operationMetrics.incrementOneDocWritten("", 4);
+        operationMetrics.incrementOneDocWritten("", 8);
+        operationMetrics.incrementOneDocWritten("", 16);
+        operationMetrics.incrementOneDocWritten("", 32);
+        operationMetrics.incrementOneDocWritten("", 64);
+        operationMetrics.incrementOneDocWritten("", 128);
         expectedUnits += 7;
 
         // Each of these should be counted as 2 total units (unit size = 128).
-        operationMetrics.incrementOneDocWritten(129);
-        operationMetrics.incrementOneDocWritten(200);
-        operationMetrics.incrementOneDocWritten(255);
-        operationMetrics.incrementOneDocWritten(256);
+        operationMetrics.incrementOneDocWritten("", 129);
+        operationMetrics.incrementOneDocWritten("", 200);
+        operationMetrics.incrementOneDocWritten("", 255);
+        operationMetrics.incrementOneDocWritten("", 256);
         expectedUnits += 8;
 
         // Each of these groups should be counted as 1 total unit, combining documents with index
         // bytes written.
 
         // Index writes prior to document write.
-        operationMetrics.incrementOneDocWritten(0);
-        operationMetrics.incrementOneIdxEntryWritten(2);
-        operationMetrics.incrementOneDocWritten(5);
+        operationMetrics.incrementOneDocWritten("", 0);
+        operationMetrics.incrementOneIdxEntryWritten("", 2);
+        operationMetrics.incrementOneDocWritten("", 5);
         expectedUnits += 1;
 
         // Index writes after document write.
-        operationMetrics.incrementOneDocWritten(2);
-        operationMetrics.incrementOneIdxEntryWritten(126);
+        operationMetrics.incrementOneDocWritten("", 2);
+        operationMetrics.incrementOneIdxEntryWritten("", 126);
         expectedUnits += 1;
 
         // No index writes.
-        operationMetrics.incrementOneDocWritten(129);
+        operationMetrics.incrementOneDocWritten("", 129);
         expectedUnits += 2;
 
-        operationMetrics.incrementOneDocWritten(127);
-        operationMetrics.incrementOneIdxEntryWritten(1);
+        operationMetrics.incrementOneDocWritten("", 127);
+        operationMetrics.incrementOneIdxEntryWritten("", 1);
         expectedUnits += 1;
 
         // Exceeds unit size and thus counts as 2 units.
-        operationMetrics.incrementOneDocWritten(1);
-        operationMetrics.incrementOneIdxEntryWritten(1);
-        operationMetrics.incrementOneIdxEntryWritten(1);
-        operationMetrics.incrementOneIdxEntryWritten(1);
-        operationMetrics.incrementOneIdxEntryWritten(128);
+        operationMetrics.incrementOneDocWritten("", 1);
+        operationMetrics.incrementOneIdxEntryWritten("", 1);
+        operationMetrics.incrementOneIdxEntryWritten("", 1);
+        operationMetrics.incrementOneIdxEntryWritten("", 1);
+        operationMetrics.incrementOneIdxEntryWritten("", 128);
         expectedUnits += 2;
     }
 
@@ -560,33 +560,33 @@ TEST_F(ResourceConsumptionMetricsTest, IdxEntryUnitsRead) {
         gIndexEntryUnitSizeBytes = 16;
 
         // Each of these should be counted as 1 document unit.
-        operationMetrics.incrementOneIdxEntryRead(2);
-        operationMetrics.incrementOneIdxEntryRead(4);
-        operationMetrics.incrementOneIdxEntryRead(8);
-        operationMetrics.incrementOneIdxEntryRead(16);
+        operationMetrics.incrementOneIdxEntryRead("", 2);
+        operationMetrics.incrementOneIdxEntryRead("", 4);
+        operationMetrics.incrementOneIdxEntryRead("", 8);
+        operationMetrics.incrementOneIdxEntryRead("", 16);
         expectedBytes += 2 + 4 + 8 + 16;
         expectedUnits += 4;
 
         // Each of these should be counted as 2 document unit.
-        operationMetrics.incrementOneIdxEntryRead(17);
-        operationMetrics.incrementOneIdxEntryRead(31);
-        operationMetrics.incrementOneIdxEntryRead(32);
+        operationMetrics.incrementOneIdxEntryRead("", 17);
+        operationMetrics.incrementOneIdxEntryRead("", 31);
+        operationMetrics.incrementOneIdxEntryRead("", 32);
         expectedBytes += 17 + 31 + 32;
         expectedUnits += 6;
 
         gIndexEntryUnitSizeBytes = 32;
 
         // Each of these should be counted as 1 document unit.
-        operationMetrics.incrementOneIdxEntryRead(17);
-        operationMetrics.incrementOneIdxEntryRead(31);
-        operationMetrics.incrementOneIdxEntryRead(32);
+        operationMetrics.incrementOneIdxEntryRead("", 17);
+        operationMetrics.incrementOneIdxEntryRead("", 31);
+        operationMetrics.incrementOneIdxEntryRead("", 32);
         expectedBytes += 17 + 31 + 32;
         expectedUnits += 3;
 
         // Each of these should be counted as 2 document units.
-        operationMetrics.incrementOneIdxEntryRead(33);
-        operationMetrics.incrementOneIdxEntryRead(63);
-        operationMetrics.incrementOneIdxEntryRead(64);
+        operationMetrics.incrementOneIdxEntryRead("", 33);
+        operationMetrics.incrementOneIdxEntryRead("", 63);
+        operationMetrics.incrementOneIdxEntryRead("", 64);
         expectedBytes += 33 + 63 + 64;
         expectedUnits += 6;
     }
@@ -609,33 +609,33 @@ TEST_F(ResourceConsumptionMetricsTest, IdxEntryUnitsWritten) {
         gIndexEntryUnitSizeBytes = 16;
 
         // Each of these should be counted as 1 document unit.
-        operationMetrics.incrementOneIdxEntryWritten(2);
-        operationMetrics.incrementOneIdxEntryWritten(4);
-        operationMetrics.incrementOneIdxEntryWritten(8);
-        operationMetrics.incrementOneIdxEntryWritten(16);
+        operationMetrics.incrementOneIdxEntryWritten("", 2);
+        operationMetrics.incrementOneIdxEntryWritten("", 4);
+        operationMetrics.incrementOneIdxEntryWritten("", 8);
+        operationMetrics.incrementOneIdxEntryWritten("", 16);
         expectedBytes += 2 + 4 + 8 + 16;
         expectedUnits += 4;
 
         // Each of these should be counted as 2 document units.
-        operationMetrics.incrementOneIdxEntryWritten(17);
-        operationMetrics.incrementOneIdxEntryWritten(31);
-        operationMetrics.incrementOneIdxEntryWritten(32);
+        operationMetrics.incrementOneIdxEntryWritten("", 17);
+        operationMetrics.incrementOneIdxEntryWritten("", 31);
+        operationMetrics.incrementOneIdxEntryWritten("", 32);
         expectedBytes += 17 + 31 + 32;
         expectedUnits += 6;
 
         gIndexEntryUnitSizeBytes = 32;
 
         // Each of these should be counted as 1 document unit.
-        operationMetrics.incrementOneIdxEntryWritten(17);
-        operationMetrics.incrementOneIdxEntryWritten(31);
-        operationMetrics.incrementOneIdxEntryWritten(32);
+        operationMetrics.incrementOneIdxEntryWritten("", 17);
+        operationMetrics.incrementOneIdxEntryWritten("", 31);
+        operationMetrics.incrementOneIdxEntryWritten("", 32);
         expectedBytes += 17 + 31 + 32;
         expectedUnits += 3;
 
         // Each of these should be counted as 2 document units.
-        operationMetrics.incrementOneIdxEntryWritten(33);
-        operationMetrics.incrementOneIdxEntryWritten(63);
-        operationMetrics.incrementOneIdxEntryWritten(64);
+        operationMetrics.incrementOneIdxEntryWritten("", 33);
+        operationMetrics.incrementOneIdxEntryWritten("", 63);
+        operationMetrics.incrementOneIdxEntryWritten("", 64);
         expectedBytes += 33 + 63 + 64;
         expectedUnits += 6;
     }
@@ -712,9 +712,9 @@ TEST_F(ResourceConsumptionMetricsTest, CursorSeeks) {
 
     {
         ResourceConsumption::ScopedMetricsCollector scope(_opCtx.get(), "db1");
-        operationMetrics.incrementOneCursorSeek();
-        operationMetrics.incrementOneCursorSeek();
-        operationMetrics.incrementOneCursorSeek();
+        operationMetrics.incrementOneCursorSeek("");
+        operationMetrics.incrementOneCursorSeek("");
+        operationMetrics.incrementOneCursorSeek("");
 
         expectedSeeks += 3;
     }
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_column_store.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_column_store.cpp
index a86f715ad61..e9bc642dfb8 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_column_store.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_column_store.cpp
@@ -181,7 +181,7 @@ void WiredTigerColumnStore::WriteCursor::insert(PathView path, const RecordId& r
     int ret = WT_OP_CHECK(wiredTigerCursorInsert(_opCtx, c()));
 
     auto& metricsCollector = ResourceConsumption::MetricsCollector::get(_opCtx);
-    metricsCollector.incrementOneIdxEntryWritten(keyItem.size);
+    metricsCollector.incrementOneIdxEntryWritten(std::string(c()->uri), keyItem.size);
 
     // TODO: SERVER-65978, we may have to specially handle WT_DUPLICATE_KEY error here.
     if (ret) {
@@ -205,7 +205,7 @@ void WiredTigerColumnStore::WriteCursor::remove(PathView path, const RecordId& r
     invariantWTOK(ret, c()->session);
 
     auto& metricsCollector = ResourceConsumption::MetricsCollector::get(_opCtx);
-    metricsCollector.incrementOneIdxEntryWritten(keyItem.size);
+    metricsCollector.incrementOneIdxEntryWritten(std::string(c()->uri), keyItem.size);
 }
 void WiredTigerColumnStore::update(OperationContext* opCtx,
                                    PathView path,
@@ -225,7 +225,7 @@ void WiredTigerColumnStore::WriteCursor::update(PathView path, const RecordId& r
     int ret = WT_OP_CHECK(wiredTigerCursorUpdate(_opCtx, c()));
 
     auto& metricsCollector = ResourceConsumption::MetricsCollector::get(_opCtx);
-    metricsCollector.incrementOneIdxEntryWritten(keyItem.size);
+    metricsCollector.incrementOneIdxEntryWritten(std::string(c()->uri), keyItem.size);
 
     // TODO: SERVER-65978, may want to handle WT_NOTFOUND specially.
     if (ret != 0)
@@ -329,7 +329,7 @@ private:
         invariantWTOK(ret, c->session);
 
         auto& metricsCollector = ResourceConsumption::MetricsCollector::get(_opCtx);
-        metricsCollector.incrementOneCursorSeek();
+        metricsCollector.incrementOneCursorSeek(std::string(c->uri));
 
         _eof = false;
 
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_index.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_index.cpp
index 7f572360979..69c422c27d5 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_index.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_index.cpp
@@ -97,7 +97,7 @@ void WiredTigerIndex::getKey(OperationContext* opCtx, WT_CURSOR* cursor, WT_ITEM
     invariantWTOK(cursor->get_key(cursor, key), cursor->session);
 
     auto& metricsCollector = ResourceConsumption::MetricsCollector::get(opCtx);
-    metricsCollector.incrementOneIdxEntryRead(key->size);
+    metricsCollector.incrementOneIdxEntryRead(_uri, key->size);
 }
 
 // static
@@ -530,7 +530,7 @@ boost::optional<RecordId> WiredTigerIndex::_keyExists(OperationContext* opCtx,
     int ret = wiredTigerPrepareConflictRetry(opCtx, [&] { return c->search_near(c, &cmp); });
 
     auto& metricsCollector = ResourceConsumption::MetricsCollector::get(opCtx);
-    metricsCollector.incrementOneCursorSeek();
+    metricsCollector.incrementOneCursorSeek(uri());
 
     if (ret == WT_NOTFOUND)
         return boost::none;
@@ -768,7 +768,7 @@ public:
         invariantWTOK(wiredTigerCursorInsert(_opCtx, _cursor), _cursor->session);
 
         auto& metricsCollector = ResourceConsumption::MetricsCollector::get(_opCtx);
-        metricsCollector.incrementOneIdxEntryWritten(item.size);
+        metricsCollector.incrementOneIdxEntryWritten(std::string(_cursor->uri), item.size);
 
         return Status::OK();
     }
@@ -836,7 +836,7 @@ public:
         invariantWTOK(wiredTigerCursorInsert(_opCtx, _cursor), _cursor->session);
 
         auto& metricsCollector = ResourceConsumption::MetricsCollector::get(_opCtx);
-        metricsCollector.incrementOneIdxEntryWritten(keyItem.size);
+        metricsCollector.incrementOneIdxEntryWritten(std::string(_cursor->uri), keyItem.size);
 
         // Don't copy the key again if dups are allowed.
         if (!_dupsAllowed)
@@ -888,7 +888,7 @@ public:
         invariantWTOK(wiredTigerCursorInsert(_opCtx, _cursor), _cursor->session);
 
         auto& metricsCollector = ResourceConsumption::MetricsCollector::get(_opCtx);
-        metricsCollector.incrementOneIdxEntryWritten(keyItem.size);
+        metricsCollector.incrementOneIdxEntryWritten(std::string(_cursor->uri), keyItem.size);
 
         _previousKeyString.resetFromBuffer(newKeyString.getBuffer(), newKeyString.getSize());
         return Status::OK();
@@ -1110,7 +1110,7 @@ protected:
         invariantWTOK(ret, c->session);
 
         auto& metricsCollector = ResourceConsumption::MetricsCollector::get(_opCtx);
-        metricsCollector.incrementOneCursorSeek();
+        metricsCollector.incrementOneCursorSeek(std::string(c->uri));
 
         _cursorAtEof = false;
 
@@ -1569,7 +1569,7 @@ Status WiredTigerIdIndex::_insert(OperationContext* opCtx,
     int ret = WT_OP_CHECK(wiredTigerCursorInsert(opCtx, c));
 
     auto& metricsCollector = ResourceConsumption::MetricsCollector::get(opCtx);
-    metricsCollector.incrementOneIdxEntryWritten(keyItem.size);
+    metricsCollector.incrementOneIdxEntryWritten(std::string(c->uri), keyItem.size);
 
     if (ret != WT_DUPLICATE_KEY) {
         return wtRCToStatus(ret, c->session, [this]() {
@@ -1628,7 +1628,7 @@ Status WiredTigerIndexUnique::_insert(OperationContext* opCtx,
     // Account for the actual key insertion, but do not attempt account for the complexity of any
     // previous duplicate key detection, which may perform writes.
     auto& metricsCollector = ResourceConsumption::MetricsCollector::get(opCtx);
-    metricsCollector.incrementOneIdxEntryWritten(keyItem.size);
+    metricsCollector.incrementOneIdxEntryWritten(std::string(c->uri), keyItem.size);
 
     // It is possible that this key is already present during a concurrent background index build.
     if (ret != WT_DUPLICATE_KEY) {
@@ -1666,7 +1666,7 @@ void WiredTigerIdIndex::_unindex(OperationContext* opCtx,
         invariantWTOK(ret, c->session);
 
         auto& metricsCollector = ResourceConsumption::MetricsCollector::get(opCtx);
-        metricsCollector.incrementOneIdxEntryWritten(keyItem.size);
+        metricsCollector.incrementOneIdxEntryWritten(std::string(c->uri), keyItem.size);
         return;
     }
 
@@ -1680,7 +1680,7 @@ void WiredTigerIdIndex::_unindex(OperationContext* opCtx,
     invariantWTOK(ret, c->session);
 
     auto& metricsCollector = ResourceConsumption::MetricsCollector::get(opCtx);
-    metricsCollector.incrementOneCursorSeek();
+    metricsCollector.incrementOneCursorSeek(std::string(c->uri));
 
     WT_ITEM old;
     invariantWTOK(c->get_value(c, &old), c->session);
@@ -1703,7 +1703,7 @@ void WiredTigerIdIndex::_unindex(OperationContext* opCtx,
     // The RecordId matches, so remove the entry.
     if (id == idInIndex) {
         invariantWTOK(WT_OP_CHECK(wiredTigerCursorRemove(opCtx, c)), c->session);
-        metricsCollector.incrementOneIdxEntryWritten(keyItem.size);
+        metricsCollector.incrementOneIdxEntryWritten(std::string(c->uri), keyItem.size);
         return;
     }
 
@@ -1730,7 +1730,7 @@ void WiredTigerIndexUnique::_unindex(OperationContext* opCtx,
     // Account for the first removal attempt, but do not attempt to account for the complexity of
     // any subsequent removals and insertions when the index's keys are not fully-upgraded.
     auto& metricsCollector = ResourceConsumption::MetricsCollector::get(opCtx);
-    metricsCollector.incrementOneIdxEntryWritten(item.size);
+    metricsCollector.incrementOneIdxEntryWritten(std::string(c->uri), item.size);
 
     if (ret != WT_NOTFOUND) {
         invariantWTOK(ret, c->session);
@@ -1808,7 +1808,7 @@ Status WiredTigerIndexStandard::_insert(OperationContext* opCtx,
     ret = WT_OP_CHECK(wiredTigerCursorInsert(opCtx, c));
 
     auto& metricsCollector = ResourceConsumption::MetricsCollector::get(opCtx);
-    metricsCollector.incrementOneIdxEntryWritten(keyItem.size);
+    metricsCollector.incrementOneIdxEntryWritten(std::string(c->uri), keyItem.size);
 
     // If the record was already in the index, we return OK. This can happen, for example, when
     // building a background index while documents are being written and reindexed.
@@ -1837,7 +1837,7 @@ void WiredTigerIndexStandard::_unindex(OperationContext* opCtx,
     invariantWTOK(ret, c->session);
 
     auto& metricsCollector = ResourceConsumption::MetricsCollector::get(opCtx);
-    metricsCollector.incrementOneIdxEntryWritten(item.size);
+    metricsCollector.incrementOneIdxEntryWritten(std::string(c->uri), item.size);
 }
 
 }  // namespace mongo
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_index_cursor_generic.h b/src/mongo/db/storage/wiredtiger/wiredtiger_index_cursor_generic.h
index 1de6e5c73c2..87862974b38 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_index_cursor_generic.h
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_index_cursor_generic.h
@@ -90,7 +90,7 @@ protected:
         invariantWTOK(cursor->get_key(cursor, key), cursor->session);
 
         auto& metricsCollector = ResourceConsumption::MetricsCollector::get(_opCtx);
-        metricsCollector.incrementOneIdxEntryRead(key->size);
+        metricsCollector.incrementOneIdxEntryRead(std::string(cursor->internal_uri), key->size);
     }
 
     OperationContext* _opCtx;
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_record_store.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_record_store.cpp
index cf9436eab55..337ee7e76b2 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_record_store.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_record_store.cpp
@@ -706,7 +706,8 @@ public:
         auto& metricsCollector = ResourceConsumption::MetricsCollector::get(_opCtx);
 
         auto keyLength = computeRecordIdSize(id);
-        metricsCollector.incrementOneDocRead(value.size + keyLength);
+        metricsCollector.incrementOneDocRead(_rs->getURI(), value.size + keyLength);
+
 
         return {
             {std::move(id), {static_cast<const char*>(value.data), static_cast<int>(value.size)}}};
@@ -1109,12 +1110,12 @@ bool WiredTigerRecordStore::findRecord(OperationContext* opCtx,
     invariantWTOK(ret, c->session);
 
     auto& metricsCollector = ResourceConsumption::MetricsCollector::get(opCtx);
-    metricsCollector.incrementOneCursorSeek();
+    metricsCollector.incrementOneCursorSeek(_uri);
 
     *out = _getData(curwrap);
 
     auto keyLength = computeRecordIdSize(id);
-    metricsCollector.incrementOneDocRead(out->size() + keyLength);
+    metricsCollector.incrementOneDocRead(_uri, out->size() + keyLength);
 
     return true;
 }
@@ -1138,7 +1139,7 @@ void WiredTigerRecordStore::doDeleteRecord(OperationContext* opCtx, const Record
     invariantWTOK(ret, c->session);
 
     auto& metricsCollector = ResourceConsumption::MetricsCollector::get(opCtx);
-    metricsCollector.incrementOneCursorSeek();
+    metricsCollector.incrementOneCursorSeek(_uri);
 
     WT_ITEM old_value;
     ret = c->get_value(c, &old_value);
@@ -1150,7 +1151,7 @@ void WiredTigerRecordStore::doDeleteRecord(OperationContext* opCtx, const Record
     invariantWTOK(ret, c->session);
 
     auto keyLength = computeRecordIdSize(id);
-    metricsCollector.incrementOneDocWritten(old_length + keyLength);
+    metricsCollector.incrementOneDocWritten(_uri, old_length + keyLength);
 
     _changeNumRecords(opCtx, -1);
     _increaseDataSize(opCtx, -old_length);
@@ -1419,7 +1420,7 @@ Status WiredTigerRecordStore::_insertRecords(OperationContext* opCtx,
             auto& metricsCollector = ResourceConsumption::MetricsCollector::get(opCtx);
 
             auto keyLength = computeRecordIdSize(record.id);
-            metricsCollector.incrementOneDocWritten(value.size + keyLength);
+            metricsCollector.incrementOneDocWritten(_uri, value.size + keyLength);
         }
     }
 
@@ -1531,7 +1532,7 @@ Status WiredTigerRecordStore::doUpdateRecord(OperationContext* opCtx,
                                        .toString());
 
     auto& metricsCollector = ResourceConsumption::MetricsCollector::get(opCtx);
-    metricsCollector.incrementOneCursorSeek();
+    metricsCollector.incrementOneCursorSeek(_uri);
 
     WT_ITEM old_value;
     ret = c->get_value(c, &old_value);
@@ -1578,7 +1579,7 @@ Status WiredTigerRecordStore::doUpdateRecord(OperationContext* opCtx,
             }
 
             auto keyLength = computeRecordIdSize(id);
-            metricsCollector.incrementOneDocWritten(modifiedDataSize + keyLength);
+            metricsCollector.incrementOneDocWritten(_uri, modifiedDataSize + keyLength);
 
             WT_ITEM new_value;
             dassert(nentries == 0 ||
@@ -1595,7 +1596,7 @@ Status WiredTigerRecordStore::doUpdateRecord(OperationContext* opCtx,
         ret = WT_OP_CHECK(wiredTigerCursorInsert(opCtx, c));
 
         auto keyLength = computeRecordIdSize(id);
-        metricsCollector.incrementOneDocWritten(value.size + keyLength);
+        metricsCollector.incrementOneDocWritten(_uri, value.size + keyLength);
     }
     invariantWTOK(ret, c->session);
 
@@ -1647,7 +1648,7 @@ StatusWith<RecordData> WiredTigerRecordStore::doUpdateWithDamages(
     auto& metricsCollector = ResourceConsumption::MetricsCollector::get(opCtx);
 
     auto keyLength = computeRecordIdSize(id);
-    metricsCollector.incrementOneDocWritten(modifiedDataSize + keyLength);
+    metricsCollector.incrementOneDocWritten(_uri, modifiedDataSize + keyLength);
 
     WT_ITEM value;
     invariantWTOK(c->get_value(c, &value), c->session);
@@ -2240,7 +2241,7 @@ boost::optional<Record> WiredTigerRecordStoreCursorBase::next() {
     auto& metricsCollector = ResourceConsumption::MetricsCollector::get(_opCtx);
 
     auto keyLength = computeRecordIdSize(id);
-    metricsCollector.incrementOneDocRead(value.size + keyLength);
+    metricsCollector.incrementOneDocRead(_rs.getURI(), value.size + keyLength);
 
     _lastReturnedId = id;
     return {{std::move(id), {static_cast<const char*>(value.data), static_cast<int>(value.size)}}};
@@ -2276,13 +2277,13 @@ boost::optional<Record> WiredTigerRecordStoreCursorBase::seekExact(const RecordI
     invariantWTOK(seekRet, c->session);
 
     auto& metricsCollector = ResourceConsumption::MetricsCollector::get(_opCtx);
-    metricsCollector.incrementOneCursorSeek();
+    metricsCollector.incrementOneCursorSeek(std::string(c->uri));
 
     WT_ITEM value;
     invariantWTOK(c->get_value(c, &value), c->session);
 
     auto keyLength = computeRecordIdSize(id);
-    metricsCollector.incrementOneDocRead(value.size + keyLength);
+    metricsCollector.incrementOneDocRead(_rs.getURI(), value.size + keyLength);
 
     _lastReturnedId = id;
     _eof = false;
@@ -2319,7 +2320,7 @@ boost::optional<Record> WiredTigerRecordStoreCursorBase::seekNear(const RecordId
     invariantWTOK(ret, c->session);
 
     auto& metricsCollector = ResourceConsumption::MetricsCollector::get(_opCtx);
-    metricsCollector.incrementOneCursorSeek();
+    metricsCollector.incrementOneCursorSeek(std::string(c->uri));
 
     RecordId curId = getKey(c);
 
@@ -2361,7 +2362,7 @@ boost::optional<Record> WiredTigerRecordStoreCursorBase::seekNear(const RecordId
     invariantWTOK(c->get_value(c, &value), c->session);
 
     auto keyLength = computeRecordIdSize(id);
-    metricsCollector.incrementOneDocRead(value.size + keyLength);
+    metricsCollector.incrementOneDocRead(_rs.getURI(), value.size + keyLength);
 
     _lastReturnedId = curId;
     _eof = false;