SERVER-69352 Rename GlobalIndexUsageTracker -> AggregatedIndexUsageTracker

7 files changed, 113 insertions, 110 deletions

diff --git a/src/mongo/db/SConscript b/src/mongo/db/SConscript
index b11c8f6b247..e6305930896 100644
--- a/src/mongo/db/SConscript
+++ b/src/mongo/db/SConscript
@@ -260,8 +260,8 @@ env.Library(
 env.Library(
     target='collection_index_usage_tracker',
     source=[
+        'aggregated_index_usage_tracker.cpp',
         'collection_index_usage_tracker.cpp',
-        'global_index_usage_tracker.cpp',
     ],
     LIBDEPS_PRIVATE=[
         '$BUILD_DIR/mongo/db/commands/server_status_core',
diff --git a/src/mongo/db/global_index_usage_tracker.cpp b/src/mongo/db/aggregated_index_usage_tracker.cpp
index 3b456e124b9..77266e25705 100644
--- a/src/mongo/db/global_index_usage_tracker.cpp
+++ b/src/mongo/db/aggregated_index_usage_tracker.cpp
@@ -27,7 +27,7 @@
  *    it in the license file.
  */
 
-#include "mongo/db/global_index_usage_tracker.h"
+#include "mongo/db/aggregated_index_usage_tracker.h"
 
 #include "mongo/db/commands/server_status.h"
 #include "mongo/db/service_context.h"
@@ -73,8 +73,8 @@ std::map<std::string, IndexFeatureStats> makeFeatureMap() {
     return map;
 };
 
-const auto getGlobalIndexUsageTracker =
-    ServiceContext::declareDecoration<GlobalIndexUsageTracker>();
+const auto getAggregatedIndexUsageTracker =
+    ServiceContext::declareDecoration<AggregatedIndexUsageTracker>();
 }  // namespace
 
 
@@ -101,34 +101,35 @@ IndexFeatures IndexFeatures::make(const IndexDescriptor* desc, bool internal) {
     return features;
 }
 
-GlobalIndexUsageTracker::GlobalIndexUsageTracker() : _indexFeatureToStats(makeFeatureMap()) {}
+AggregatedIndexUsageTracker::AggregatedIndexUsageTracker()
+    : _indexFeatureToStats(makeFeatureMap()) {}
 
-GlobalIndexUsageTracker* GlobalIndexUsageTracker::get(ServiceContext* svcCtx) {
-    return &getGlobalIndexUsageTracker(svcCtx);
+AggregatedIndexUsageTracker* AggregatedIndexUsageTracker::get(ServiceContext* svcCtx) {
+    return &getAggregatedIndexUsageTracker(svcCtx);
 }
 
-void GlobalIndexUsageTracker::onAccess(const IndexFeatures& features) const {
+void AggregatedIndexUsageTracker::onAccess(const IndexFeatures& features) const {
     if (!features.internal) {
         _updateStatsForEachFeature(features, [](auto stats) { stats->accesses.fetchAndAdd(1); });
     }
 }
 
-void GlobalIndexUsageTracker::onRegister(const IndexFeatures& features) const {
+void AggregatedIndexUsageTracker::onRegister(const IndexFeatures& features) const {
     if (!features.internal) {
         _updateStatsForEachFeature(features, [](auto stats) { stats->count.fetchAndAdd(1); });
         _count.fetchAndAdd(1);
     }
 }
 
-void GlobalIndexUsageTracker::onUnregister(const IndexFeatures& features) const {
+void AggregatedIndexUsageTracker::onUnregister(const IndexFeatures& features) const {
     if (!features.internal) {
         _updateStatsForEachFeature(features, [](auto stats) { stats->count.fetchAndAdd(-1); });
         _count.fetchAndAdd(-1);
     }
 }
 
-void GlobalIndexUsageTracker::_updateStatsForEachFeature(const IndexFeatures& features,
-                                                         UpdateFn&& update) const {
+void AggregatedIndexUsageTracker::_updateStatsForEachFeature(const IndexFeatures& features,
+                                                             UpdateFn&& update) const {
     // Aggregate _id indexes separately so they do not get included with the other features.
     if (features.id) {
         update(&_indexFeatureToStats.at(kId));
@@ -190,13 +191,13 @@ void GlobalIndexUsageTracker::_updateStatsForEachFeature(const IndexFeatures& fe
     }
 }
 
-void GlobalIndexUsageTracker::forEachFeature(OnFeatureFn&& onFeature) const {
+void AggregatedIndexUsageTracker::forEachFeature(OnFeatureFn&& onFeature) const {
     for (auto& [key, value] : _indexFeatureToStats) {
         onFeature(key, value);
     }
 }
 
-long long GlobalIndexUsageTracker::getCount() const {
+long long AggregatedIndexUsageTracker::getCount() const {
     return _count.load();
 }
 
@@ -212,7 +213,7 @@ public:
 
     BSONObj generateSection(OperationContext* opCtx,
                             const BSONElement& configElement) const override {
-        auto globalFeatures = GlobalIndexUsageTracker::get(opCtx->getServiceContext());
+        auto globalFeatures = AggregatedIndexUsageTracker::get(opCtx->getServiceContext());
 
         BSONObjBuilder builder;
         builder.append("count", globalFeatures->getCount());
diff --git a/src/mongo/db/global_index_usage_tracker.h b/src/mongo/db/aggregated_index_usage_tracker.h
index c4711667787..96a08cd3b35 100644
--- a/src/mongo/db/global_index_usage_tracker.h
+++ b/src/mongo/db/aggregated_index_usage_tracker.h
@@ -41,12 +41,12 @@ class ServiceContext;
 /**
  * IndexFeatures describes an anonymized set of features about a single index. For example, an index
  * can be both compound and unique, and this set of flags would be used to track that information so
- * that we can provide aggregated details in the GlobalIndexUsageTracker.
+ * that we can provide aggregated details in the AggregatedIndexUsageTracker.
  */
 struct IndexFeatures {
     /**
      * Create an IndexFeatures structure. If 'internal' is true, the statistics for this index and
-     * its features should not be tracked and aggregated by the GlobalIndexUsageTracker.
+     * its features should not be tracked and aggregated by the AggregatedIndexUsageTracker.
      */
     static IndexFeatures make(const IndexDescriptor* desc, bool internal);
 
@@ -74,14 +74,14 @@ struct IndexFeatureStats {
 };
 
 /**
- * GlobalIndexUsageTracker aggregates usage metrics about features used by indexes. Ignores indexes
- * on internal databases.
+ * AggregatedIndexUsageTracker aggregates usage metrics about features used by indexes. Ignores
+ * indexes on internal databases.
  */
-class GlobalIndexUsageTracker {
+class AggregatedIndexUsageTracker {
 public:
-    static GlobalIndexUsageTracker* get(ServiceContext* svcCtx);
+    static AggregatedIndexUsageTracker* get(ServiceContext* svcCtx);
 
-    GlobalIndexUsageTracker();
+    AggregatedIndexUsageTracker();
 
     /**
      * Updates counters for features used by an index when the index has been accessed.
diff --git a/src/mongo/db/collection_index_usage_tracker.cpp b/src/mongo/db/collection_index_usage_tracker.cpp
index f0fc7873732..d10f728ad16 100644
--- a/src/mongo/db/collection_index_usage_tracker.cpp
+++ b/src/mongo/db/collection_index_usage_tracker.cpp
@@ -47,10 +47,10 @@ CounterMetric collectionScansNonTailableCounter("queryExecutor.collectionScans.n
 }  // namespace
 
 CollectionIndexUsageTracker::CollectionIndexUsageTracker(
-    GlobalIndexUsageTracker* globalIndexUsageTracker, ClockSource* clockSource)
+    AggregatedIndexUsageTracker* aggregatedIndexUsageTracker, ClockSource* clockSource)
     : _indexUsageStatsMap(std::make_shared<CollectionIndexUsageMap>()),
       _clockSource(clockSource),
-      _globalIndexUsageTracker(globalIndexUsageTracker) {
+      _aggregatedIndexUsageTracker(aggregatedIndexUsageTracker) {
     invariant(_clockSource);
 }
 
@@ -67,7 +67,7 @@ void CollectionIndexUsageTracker::recordIndexAccess(StringData indexName) {
         return;
     }
 
-    _globalIndexUsageTracker->onAccess(it->second->features);
+    _aggregatedIndexUsageTracker->onAccess(it->second->features);
 
     // Increment the index usage atomic counter.
     it->second->accesses.fetchAndAdd(1);
@@ -100,7 +100,7 @@ void CollectionIndexUsageTracker::registerIndex(StringData indexName,
         indexName, make_intrusive<IndexUsageStats>(_clockSource->now(), indexKey, features));
     invariant(inserted.second);
 
-    _globalIndexUsageTracker->onRegister(inserted.first->second->features);
+    _aggregatedIndexUsageTracker->onRegister(inserted.first->second->features);
 
     // Swap the modified map into place atomically.
     atomic_store(&_indexUsageStatsMap, std::move(mapCopy));
@@ -115,7 +115,7 @@ void CollectionIndexUsageTracker::unregisterIndex(StringData indexName) {
 
     auto it = mapCopy->find(indexName);
     if (it != mapCopy->end()) {
-        _globalIndexUsageTracker->onUnregister(it->second->features);
+        _aggregatedIndexUsageTracker->onUnregister(it->second->features);
 
         // Remove the map entry.
         mapCopy->erase(it);
diff --git a/src/mongo/db/collection_index_usage_tracker.h b/src/mongo/db/collection_index_usage_tracker.h
index 84ee2230f4f..aa69ce8b638 100644
--- a/src/mongo/db/collection_index_usage_tracker.h
+++ b/src/mongo/db/collection_index_usage_tracker.h
@@ -33,7 +33,7 @@
 
 #include "mongo/base/string_data.h"
 #include "mongo/bson/bsonobj.h"
-#include "mongo/db/global_index_usage_tracker.h"
+#include "mongo/db/aggregated_index_usage_tracker.h"
 #include "mongo/platform/atomic_word.h"
 #include "mongo/util/intrusive_counter.h"
 #include "mongo/util/string_map.h"
@@ -114,7 +114,7 @@ public:
      * Does not take ownership of 'clockSource'. 'clockSource' must refer to a non-null clock
      * source that is valid for the lifetime of the constructed CollectionIndexUsageTracker.
      */
-    explicit CollectionIndexUsageTracker(GlobalIndexUsageTracker* globalTracker,
+    explicit CollectionIndexUsageTracker(AggregatedIndexUsageTracker* aggregatedIndexUsageTracker,
                                          ClockSource* clockSource);
 
     /**
@@ -177,9 +177,9 @@ private:
     // be set.
     ClockSource* _clockSource;
 
-    // All CollectionIndexUsageTrackers also update the GlobalIndexUsageTracker to report global
-    // index statistics for the server.
-    GlobalIndexUsageTracker* _globalIndexUsageTracker;
+    // All CollectionIndexUsageTrackers also update the AggregatedIndexUsageTracker to report
+    // globally aggregated index statistics for the server.
+    AggregatedIndexUsageTracker* _aggregatedIndexUsageTracker;
 
     AtomicWord<unsigned long long> _collectionScans{0};
     AtomicWord<unsigned long long> _collectionScansNonTailable{0};
diff --git a/src/mongo/db/collection_index_usage_tracker_test.cpp b/src/mongo/db/collection_index_usage_tracker_test.cpp
index a532e91a152..fb4252588f7 100644
--- a/src/mongo/db/collection_index_usage_tracker_test.cpp
+++ b/src/mongo/db/collection_index_usage_tracker_test.cpp
@@ -40,7 +40,7 @@ namespace {
 
 class CollectionIndexUsageTrackerTest : public unittest::Test {
 protected:
-    CollectionIndexUsageTrackerTest() : _tracker(&_globalIndexUsage, &_clockSource) {}
+    CollectionIndexUsageTrackerTest() : _tracker(&_aggregatedIndexUsage, &_clockSource) {}
 
     /**
      * Returns an unowned pointer to the tracker owned by this test fixture.
@@ -56,12 +56,12 @@ protected:
         return &_clockSource;
     }
 
-    GlobalIndexUsageTracker* getGlobalIndexUsage() {
-        return &_globalIndexUsage;
+    AggregatedIndexUsageTracker* getAggregatedIndexUsage() {
+        return &_aggregatedIndexUsage;
     }
 
 private:
-    GlobalIndexUsageTracker _globalIndexUsage;
+    AggregatedIndexUsageTracker _aggregatedIndexUsage;
     ClockSourceMock _clockSource;
     CollectionIndexUsageTracker _tracker;
 };
@@ -207,9 +207,10 @@ TEST_F(CollectionIndexUsageTrackerTest, StaleUsageStatsMapEntryIsNotUpdatedAfter
 }
 
 namespace {
-int getFeatureUseCount(GlobalIndexUsageTracker* globalIndexUsage, std::string featureSearch) {
+int getFeatureUseCount(AggregatedIndexUsageTracker* aggregatedIndexUsage,
+                       std::string featureSearch) {
     int count = 0;
-    globalIndexUsage->forEachFeature([&](auto feature, auto& stats) {
+    aggregatedIndexUsage->forEachFeature([&](auto feature, auto& stats) {
         if (featureSearch == feature) {
             count += stats.count.load();
         }
@@ -217,9 +218,10 @@ int getFeatureUseCount(GlobalIndexUsageTracker* globalIndexUsage, std::string fe
     return count;
 }
 
-int getFeatureAccessCount(GlobalIndexUsageTracker* globalIndexUsage, std::string featureSearch) {
+int getFeatureAccessCount(AggregatedIndexUsageTracker* aggregatedIndexUsage,
+                          std::string featureSearch) {
     int accesses = 0;
-    globalIndexUsage->forEachFeature([&](auto feature, auto& stats) {
+    aggregatedIndexUsage->forEachFeature([&](auto feature, auto& stats) {
         if (featureSearch == feature) {
             accesses += stats.accesses.load();
         }
@@ -234,94 +236,94 @@ TEST_F(CollectionIndexUsageTrackerTest, GlobalFeatureUsageBasic) {
     getTracker()->registerIndex("_id_", idSpec, IndexFeatures::make(&idDesc, false /* internal */));
     getTracker()->recordIndexAccess("_id_");
 
-    ASSERT_EQ(1, getGlobalIndexUsage()->getCount());
-    ASSERT_EQ(1, getFeatureUseCount(getGlobalIndexUsage(), "id"));
-    ASSERT_EQ(0, getFeatureUseCount(getGlobalIndexUsage(), "normal"));
-    ASSERT_EQ(0, getFeatureUseCount(getGlobalIndexUsage(), "single"));
-    ASSERT_EQ(0, getFeatureUseCount(getGlobalIndexUsage(), "sparse"));
-    ASSERT_EQ(0, getFeatureUseCount(getGlobalIndexUsage(), "unique"));
+    ASSERT_EQ(1, getAggregatedIndexUsage()->getCount());
+    ASSERT_EQ(1, getFeatureUseCount(getAggregatedIndexUsage(), "id"));
+    ASSERT_EQ(0, getFeatureUseCount(getAggregatedIndexUsage(), "normal"));
+    ASSERT_EQ(0, getFeatureUseCount(getAggregatedIndexUsage(), "single"));
+    ASSERT_EQ(0, getFeatureUseCount(getAggregatedIndexUsage(), "sparse"));
+    ASSERT_EQ(0, getFeatureUseCount(getAggregatedIndexUsage(), "unique"));
 
-    ASSERT_EQ(1, getFeatureAccessCount(getGlobalIndexUsage(), "id"));
-    ASSERT_EQ(0, getFeatureAccessCount(getGlobalIndexUsage(), "normal"));
-    ASSERT_EQ(0, getFeatureAccessCount(getGlobalIndexUsage(), "single"));
-    ASSERT_EQ(0, getFeatureAccessCount(getGlobalIndexUsage(), "sparse"));
-    ASSERT_EQ(0, getFeatureAccessCount(getGlobalIndexUsage(), "unique"));
+    ASSERT_EQ(1, getFeatureAccessCount(getAggregatedIndexUsage(), "id"));
+    ASSERT_EQ(0, getFeatureAccessCount(getAggregatedIndexUsage(), "normal"));
+    ASSERT_EQ(0, getFeatureAccessCount(getAggregatedIndexUsage(), "single"));
+    ASSERT_EQ(0, getFeatureAccessCount(getAggregatedIndexUsage(), "sparse"));
+    ASSERT_EQ(0, getFeatureAccessCount(getAggregatedIndexUsage(), "unique"));
 
     auto spec = BSON("key" << BSON("foo" << 1) << "unique" << true << "sparse" << true << "v" << 2);
     auto desc = IndexDescriptor("", spec);
     getTracker()->registerIndex("foo", spec, IndexFeatures::make(&desc, false /* internal */));
     getTracker()->recordIndexAccess("foo");
 
-    ASSERT_EQ(2, getGlobalIndexUsage()->getCount());
-    ASSERT_EQ(1, getFeatureUseCount(getGlobalIndexUsage(), "id"));
-    ASSERT_EQ(1, getFeatureUseCount(getGlobalIndexUsage(), "normal"));
-    ASSERT_EQ(1, getFeatureUseCount(getGlobalIndexUsage(), "single"));
-    ASSERT_EQ(1, getFeatureUseCount(getGlobalIndexUsage(), "sparse"));
-    ASSERT_EQ(1, getFeatureUseCount(getGlobalIndexUsage(), "unique"));
+    ASSERT_EQ(2, getAggregatedIndexUsage()->getCount());
+    ASSERT_EQ(1, getFeatureUseCount(getAggregatedIndexUsage(), "id"));
+    ASSERT_EQ(1, getFeatureUseCount(getAggregatedIndexUsage(), "normal"));
+    ASSERT_EQ(1, getFeatureUseCount(getAggregatedIndexUsage(), "single"));
+    ASSERT_EQ(1, getFeatureUseCount(getAggregatedIndexUsage(), "sparse"));
+    ASSERT_EQ(1, getFeatureUseCount(getAggregatedIndexUsage(), "unique"));
 
-    ASSERT_EQ(1, getFeatureAccessCount(getGlobalIndexUsage(), "id"));
-    ASSERT_EQ(1, getFeatureAccessCount(getGlobalIndexUsage(), "normal"));
-    ASSERT_EQ(1, getFeatureAccessCount(getGlobalIndexUsage(), "single"));
-    ASSERT_EQ(1, getFeatureAccessCount(getGlobalIndexUsage(), "sparse"));
-    ASSERT_EQ(1, getFeatureAccessCount(getGlobalIndexUsage(), "unique"));
+    ASSERT_EQ(1, getFeatureAccessCount(getAggregatedIndexUsage(), "id"));
+    ASSERT_EQ(1, getFeatureAccessCount(getAggregatedIndexUsage(), "normal"));
+    ASSERT_EQ(1, getFeatureAccessCount(getAggregatedIndexUsage(), "single"));
+    ASSERT_EQ(1, getFeatureAccessCount(getAggregatedIndexUsage(), "sparse"));
+    ASSERT_EQ(1, getFeatureAccessCount(getAggregatedIndexUsage(), "unique"));
 
     // Register an internal index and expect nothing to change.
     getTracker()->registerIndex("foo2", spec, IndexFeatures::make(&desc, true /* internal */));
 
-    ASSERT_EQ(2, getGlobalIndexUsage()->getCount());
-    ASSERT_EQ(1, getFeatureUseCount(getGlobalIndexUsage(), "id"));
-    ASSERT_EQ(1, getFeatureUseCount(getGlobalIndexUsage(), "normal"));
-    ASSERT_EQ(1, getFeatureUseCount(getGlobalIndexUsage(), "single"));
-    ASSERT_EQ(1, getFeatureUseCount(getGlobalIndexUsage(), "sparse"));
-    ASSERT_EQ(1, getFeatureUseCount(getGlobalIndexUsage(), "unique"));
+    ASSERT_EQ(2, getAggregatedIndexUsage()->getCount());
+    ASSERT_EQ(1, getFeatureUseCount(getAggregatedIndexUsage(), "id"));
+    ASSERT_EQ(1, getFeatureUseCount(getAggregatedIndexUsage(), "normal"));
+    ASSERT_EQ(1, getFeatureUseCount(getAggregatedIndexUsage(), "single"));
+    ASSERT_EQ(1, getFeatureUseCount(getAggregatedIndexUsage(), "sparse"));
+    ASSERT_EQ(1, getFeatureUseCount(getAggregatedIndexUsage(), "unique"));
 
-    ASSERT_EQ(1, getFeatureAccessCount(getGlobalIndexUsage(), "id"));
-    ASSERT_EQ(1, getFeatureAccessCount(getGlobalIndexUsage(), "normal"));
-    ASSERT_EQ(1, getFeatureAccessCount(getGlobalIndexUsage(), "single"));
-    ASSERT_EQ(1, getFeatureAccessCount(getGlobalIndexUsage(), "sparse"));
-    ASSERT_EQ(1, getFeatureAccessCount(getGlobalIndexUsage(), "unique"));
+    ASSERT_EQ(1, getFeatureAccessCount(getAggregatedIndexUsage(), "id"));
+    ASSERT_EQ(1, getFeatureAccessCount(getAggregatedIndexUsage(), "normal"));
+    ASSERT_EQ(1, getFeatureAccessCount(getAggregatedIndexUsage(), "single"));
+    ASSERT_EQ(1, getFeatureAccessCount(getAggregatedIndexUsage(), "sparse"));
+    ASSERT_EQ(1, getFeatureAccessCount(getAggregatedIndexUsage(), "unique"));
 
     getTracker()->unregisterIndex("foo2");
-    ASSERT_EQ(2, getGlobalIndexUsage()->getCount());
-    ASSERT_EQ(1, getFeatureUseCount(getGlobalIndexUsage(), "id"));
-    ASSERT_EQ(1, getFeatureUseCount(getGlobalIndexUsage(), "normal"));
-    ASSERT_EQ(1, getFeatureUseCount(getGlobalIndexUsage(), "single"));
-    ASSERT_EQ(1, getFeatureUseCount(getGlobalIndexUsage(), "sparse"));
-    ASSERT_EQ(1, getFeatureUseCount(getGlobalIndexUsage(), "unique"));
-
-    ASSERT_EQ(1, getFeatureAccessCount(getGlobalIndexUsage(), "id"));
-    ASSERT_EQ(1, getFeatureAccessCount(getGlobalIndexUsage(), "normal"));
-    ASSERT_EQ(1, getFeatureAccessCount(getGlobalIndexUsage(), "single"));
-    ASSERT_EQ(1, getFeatureAccessCount(getGlobalIndexUsage(), "sparse"));
-    ASSERT_EQ(1, getFeatureAccessCount(getGlobalIndexUsage(), "unique"));
+    ASSERT_EQ(2, getAggregatedIndexUsage()->getCount());
+    ASSERT_EQ(1, getFeatureUseCount(getAggregatedIndexUsage(), "id"));
+    ASSERT_EQ(1, getFeatureUseCount(getAggregatedIndexUsage(), "normal"));
+    ASSERT_EQ(1, getFeatureUseCount(getAggregatedIndexUsage(), "single"));
+    ASSERT_EQ(1, getFeatureUseCount(getAggregatedIndexUsage(), "sparse"));
+    ASSERT_EQ(1, getFeatureUseCount(getAggregatedIndexUsage(), "unique"));
+
+    ASSERT_EQ(1, getFeatureAccessCount(getAggregatedIndexUsage(), "id"));
+    ASSERT_EQ(1, getFeatureAccessCount(getAggregatedIndexUsage(), "normal"));
+    ASSERT_EQ(1, getFeatureAccessCount(getAggregatedIndexUsage(), "single"));
+    ASSERT_EQ(1, getFeatureAccessCount(getAggregatedIndexUsage(), "sparse"));
+    ASSERT_EQ(1, getFeatureAccessCount(getAggregatedIndexUsage(), "unique"));
 
     getTracker()->unregisterIndex("foo");
-    ASSERT_EQ(1, getGlobalIndexUsage()->getCount());
-    ASSERT_EQ(1, getFeatureUseCount(getGlobalIndexUsage(), "id"));
-    ASSERT_EQ(0, getFeatureUseCount(getGlobalIndexUsage(), "normal"));
-    ASSERT_EQ(0, getFeatureUseCount(getGlobalIndexUsage(), "single"));
-    ASSERT_EQ(0, getFeatureUseCount(getGlobalIndexUsage(), "sparse"));
-    ASSERT_EQ(0, getFeatureUseCount(getGlobalIndexUsage(), "unique"));
-
-    ASSERT_EQ(1, getFeatureAccessCount(getGlobalIndexUsage(), "id"));
-    ASSERT_EQ(1, getFeatureAccessCount(getGlobalIndexUsage(), "normal"));
-    ASSERT_EQ(1, getFeatureAccessCount(getGlobalIndexUsage(), "single"));
-    ASSERT_EQ(1, getFeatureAccessCount(getGlobalIndexUsage(), "sparse"));
-    ASSERT_EQ(1, getFeatureAccessCount(getGlobalIndexUsage(), "unique"));
+    ASSERT_EQ(1, getAggregatedIndexUsage()->getCount());
+    ASSERT_EQ(1, getFeatureUseCount(getAggregatedIndexUsage(), "id"));
+    ASSERT_EQ(0, getFeatureUseCount(getAggregatedIndexUsage(), "normal"));
+    ASSERT_EQ(0, getFeatureUseCount(getAggregatedIndexUsage(), "single"));
+    ASSERT_EQ(0, getFeatureUseCount(getAggregatedIndexUsage(), "sparse"));
+    ASSERT_EQ(0, getFeatureUseCount(getAggregatedIndexUsage(), "unique"));
+
+    ASSERT_EQ(1, getFeatureAccessCount(getAggregatedIndexUsage(), "id"));
+    ASSERT_EQ(1, getFeatureAccessCount(getAggregatedIndexUsage(), "normal"));
+    ASSERT_EQ(1, getFeatureAccessCount(getAggregatedIndexUsage(), "single"));
+    ASSERT_EQ(1, getFeatureAccessCount(getAggregatedIndexUsage(), "sparse"));
+    ASSERT_EQ(1, getFeatureAccessCount(getAggregatedIndexUsage(), "unique"));
 
     getTracker()->unregisterIndex("_id_");
-    ASSERT_EQ(0, getGlobalIndexUsage()->getCount());
-    ASSERT_EQ(0, getFeatureUseCount(getGlobalIndexUsage(), "id"));
-    ASSERT_EQ(0, getFeatureUseCount(getGlobalIndexUsage(), "normal"));
-    ASSERT_EQ(0, getFeatureUseCount(getGlobalIndexUsage(), "single"));
-    ASSERT_EQ(0, getFeatureUseCount(getGlobalIndexUsage(), "sparse"));
-    ASSERT_EQ(0, getFeatureUseCount(getGlobalIndexUsage(), "unique"));
-
-    ASSERT_EQ(1, getFeatureAccessCount(getGlobalIndexUsage(), "id"));
-    ASSERT_EQ(1, getFeatureAccessCount(getGlobalIndexUsage(), "normal"));
-    ASSERT_EQ(1, getFeatureAccessCount(getGlobalIndexUsage(), "single"));
-    ASSERT_EQ(1, getFeatureAccessCount(getGlobalIndexUsage(), "sparse"));
-    ASSERT_EQ(1, getFeatureAccessCount(getGlobalIndexUsage(), "unique"));
+    ASSERT_EQ(0, getAggregatedIndexUsage()->getCount());
+    ASSERT_EQ(0, getFeatureUseCount(getAggregatedIndexUsage(), "id"));
+    ASSERT_EQ(0, getFeatureUseCount(getAggregatedIndexUsage(), "normal"));
+    ASSERT_EQ(0, getFeatureUseCount(getAggregatedIndexUsage(), "single"));
+    ASSERT_EQ(0, getFeatureUseCount(getAggregatedIndexUsage(), "sparse"));
+    ASSERT_EQ(0, getFeatureUseCount(getAggregatedIndexUsage(), "unique"));
+
+    ASSERT_EQ(1, getFeatureAccessCount(getAggregatedIndexUsage(), "id"));
+    ASSERT_EQ(1, getFeatureAccessCount(getAggregatedIndexUsage(), "normal"));
+    ASSERT_EQ(1, getFeatureAccessCount(getAggregatedIndexUsage(), "single"));
+    ASSERT_EQ(1, getFeatureAccessCount(getAggregatedIndexUsage(), "sparse"));
+    ASSERT_EQ(1, getFeatureAccessCount(getAggregatedIndexUsage(), "unique"));
 }
 
 }  // namespace
diff --git a/src/mongo/db/query/collection_index_usage_tracker_decoration.cpp b/src/mongo/db/query/collection_index_usage_tracker_decoration.cpp
index 8f4216874b3..ec32e742bbd 100644
--- a/src/mongo/db/query/collection_index_usage_tracker_decoration.cpp
+++ b/src/mongo/db/query/collection_index_usage_tracker_decoration.cpp
@@ -53,7 +53,7 @@ CollectionIndexUsageTracker& CollectionIndexUsageTrackerDecoration::get(
 }
 
 CollectionIndexUsageTrackerDecoration::CollectionIndexUsageTrackerDecoration()
-    : _indexUsageTracker(GlobalIndexUsageTracker::get(getGlobalServiceContext()),
+    : _indexUsageTracker(AggregatedIndexUsageTracker::get(getGlobalServiceContext()),
                          getGlobalServiceContext()->getPreciseClockSource()) {}
 
 }  // namespace mongo