SERVER-67085 Rename ReshardingMetricsNew to ReshardingMetrics

28 files changed, 272 insertions, 280 deletions

diff --git a/src/mongo/db/s/resharding/resharding_collection_cloner.cpp b/src/mongo/db/s/resharding/resharding_collection_cloner.cpp
index a80bfbb88ec..610580612d6 100644
--- a/src/mongo/db/s/resharding/resharding_collection_cloner.cpp
+++ b/src/mongo/db/s/resharding/resharding_collection_cloner.cpp
@@ -50,7 +50,7 @@
 #include "mongo/db/s/resharding/document_source_resharding_ownership_match.h"
 #include "mongo/db/s/resharding/resharding_data_copy_util.h"
 #include "mongo/db/s/resharding/resharding_future_util.h"
-#include "mongo/db/s/resharding/resharding_metrics_new.h"
+#include "mongo/db/s/resharding/resharding_metrics.h"
 #include "mongo/db/s/resharding/resharding_server_parameters_gen.h"
 #include "mongo/db/s/resharding/resharding_util.h"
 #include "mongo/db/service_context.h"
@@ -80,7 +80,7 @@ bool collectionHasSimpleCollation(OperationContext* opCtx, const NamespaceString
 
 }  // namespace
 
-ReshardingCollectionCloner::ReshardingCollectionCloner(ReshardingMetricsNew* metrics,
+ReshardingCollectionCloner::ReshardingCollectionCloner(ReshardingMetrics* metrics,
                                                        ShardKeyPattern newShardKeyPattern,
                                                        NamespaceString sourceNss,
                                                        const UUID& sourceUUID,
diff --git a/src/mongo/db/s/resharding/resharding_collection_cloner.h b/src/mongo/db/s/resharding/resharding_collection_cloner.h
index e24b03c76b6..97e28a4fce5 100644
--- a/src/mongo/db/s/resharding/resharding_collection_cloner.h
+++ b/src/mongo/db/s/resharding/resharding_collection_cloner.h
@@ -52,7 +52,7 @@ class TaskExecutor;
 
 class OperationContext;
 class MongoProcessInterface;
-class ReshardingMetricsNew;
+class ReshardingMetrics;
 class ServiceContext;
 
 /**
@@ -61,7 +61,7 @@ class ServiceContext;
  */
 class ReshardingCollectionCloner {
 public:
-    ReshardingCollectionCloner(ReshardingMetricsNew* metrics,
+    ReshardingCollectionCloner(ReshardingMetrics* metrics,
                                ShardKeyPattern newShardKeyPattern,
                                NamespaceString sourceNss,
                                const UUID& sourceUUID,
@@ -99,7 +99,7 @@ private:
 
     std::unique_ptr<Pipeline, PipelineDeleter> _restartPipeline(OperationContext* opCtx);
 
-    ReshardingMetricsNew* _metrics;
+    ReshardingMetrics* _metrics;
     const ShardKeyPattern _newShardKeyPattern;
     const NamespaceString _sourceNss;
     const UUID _sourceUUID;
diff --git a/src/mongo/db/s/resharding/resharding_coordinator_commit_monitor.cpp b/src/mongo/db/s/resharding/resharding_coordinator_commit_monitor.cpp
index ae6b61fb314..61eb1a620c4 100644
--- a/src/mongo/db/s/resharding/resharding_coordinator_commit_monitor.cpp
+++ b/src/mongo/db/s/resharding/resharding_coordinator_commit_monitor.cpp
@@ -88,13 +88,13 @@ boost::optional<Milliseconds> extractOperationRemainingTime(const BSONObj& obj)
 }  // namespace
 
 CoordinatorCommitMonitor::CoordinatorCommitMonitor(
-    std::shared_ptr<ReshardingMetricsNew> metricsNew,
+    std::shared_ptr<ReshardingMetrics> metrics,
     NamespaceString ns,
     std::vector<ShardId> recipientShards,
     CoordinatorCommitMonitor::TaskExecutorPtr executor,
     CancellationToken cancelToken,
     Milliseconds maxDelayBetweenQueries)
-    : _metricsNew{std::move(metricsNew)},
+    : _metrics{std::move(metrics)},
       _ns(std::move(ns)),
       _recipientShards(std::move(recipientShards)),
       _executor(std::move(executor)),
@@ -209,8 +209,8 @@ ExecutorFuture<void> CoordinatorCommitMonitor::_makeFuture() const {
             return RemainingOperationTimes{Milliseconds(0), Milliseconds::max()};
         })
         .then([this, anchor = shared_from_this()](RemainingOperationTimes remainingTimes) {
-            _metricsNew->setCoordinatorHighEstimateRemainingTimeMillis(remainingTimes.max);
-            _metricsNew->setCoordinatorLowEstimateRemainingTimeMillis(remainingTimes.min);
+            _metrics->setCoordinatorHighEstimateRemainingTimeMillis(remainingTimes.max);
+            _metrics->setCoordinatorLowEstimateRemainingTimeMillis(remainingTimes.min);
 
             // Check if all recipient shards are within the commit threshold.
             if (remainingTimes.max <= _threshold)
diff --git a/src/mongo/db/s/resharding/resharding_coordinator_commit_monitor.h b/src/mongo/db/s/resharding/resharding_coordinator_commit_monitor.h
index fb9f55d614f..aa3ff0727e9 100644
--- a/src/mongo/db/s/resharding/resharding_coordinator_commit_monitor.h
+++ b/src/mongo/db/s/resharding/resharding_coordinator_commit_monitor.h
@@ -33,7 +33,7 @@
 #include <vector>
 
 #include "mongo/db/namespace_string.h"
-#include "mongo/db/s/resharding/resharding_metrics_new.h"
+#include "mongo/db/s/resharding/resharding_metrics.h"
 #include "mongo/executor/task_executor.h"
 #include "mongo/s/shard_id.h"
 #include "mongo/util/cancellation.h"
@@ -69,7 +69,7 @@ public:
         Milliseconds max;
     };
 
-    CoordinatorCommitMonitor(std::shared_ptr<ReshardingMetricsNew> metricsNew,
+    CoordinatorCommitMonitor(std::shared_ptr<ReshardingMetrics> metrics,
                              NamespaceString ns,
                              std::vector<ShardId> recipientShards,
                              TaskExecutorPtr executor,
@@ -95,7 +95,7 @@ private:
     static constexpr auto kDiagnosticLogLevel = 0;
     static constexpr auto kMaxDelayBetweenQueries = Seconds(30);
 
-    std::shared_ptr<ReshardingMetricsNew> _metricsNew;
+    std::shared_ptr<ReshardingMetrics> _metrics;
     const NamespaceString _ns;
     const std::vector<ShardId> _recipientShards;
     const TaskExecutorPtr _executor;
diff --git a/src/mongo/db/s/resharding/resharding_coordinator_commit_monitor_test.cpp b/src/mongo/db/s/resharding/resharding_coordinator_commit_monitor_test.cpp
index 1cc717b7aec..d8740053c80 100644
--- a/src/mongo/db/s/resharding/resharding_coordinator_commit_monitor_test.cpp
+++ b/src/mongo/db/s/resharding/resharding_coordinator_commit_monitor_test.cpp
@@ -40,7 +40,7 @@
 #include "mongo/db/namespace_string.h"
 #include "mongo/db/s/config/config_server_test_fixture.h"
 #include "mongo/db/s/resharding/resharding_coordinator_commit_monitor.h"
-#include "mongo/db/s/resharding/resharding_metrics_new.h"
+#include "mongo/db/s/resharding/resharding_metrics.h"
 #include "mongo/db/s/resharding/resharding_server_parameters_gen.h"
 #include "mongo/executor/thread_pool_task_executor_test_fixture.h"
 #include "mongo/logv2/log.h"
@@ -109,7 +109,7 @@ private:
     boost::optional<Callback> _runOnMockingNextResponse;
 
     ShardingDataTransformCumulativeMetrics _cumulativeMetrics{"dummyForTest"};
-    std::shared_ptr<ReshardingMetricsNew> _metrics;
+    std::shared_ptr<ReshardingMetrics> _metrics;
 };
 
 auto makeExecutor() {
@@ -151,7 +151,7 @@ void CoordinatorCommitMonitorTest::setUp() {
     _cancellationSource = std::make_unique<CancellationSource>();
 
     auto clockSource = getServiceContext()->getFastClockSource();
-    _metrics = std::make_shared<ReshardingMetricsNew>(
+    _metrics = std::make_shared<ReshardingMetrics>(
         UUID::gen(),
         BSON("y" << 1),
         _ns,
diff --git a/src/mongo/db/s/resharding/resharding_coordinator_service.cpp b/src/mongo/db/s/resharding/resharding_coordinator_service.cpp
index cbd6232a5d1..83d4fe92134 100644
--- a/src/mongo/db/s/resharding/resharding_coordinator_service.cpp
+++ b/src/mongo/db/s/resharding/resharding_coordinator_service.cpp
@@ -150,12 +150,12 @@ using resharding_metrics::getIntervalStartFieldName;
 using DocT = ReshardingCoordinatorDocument;
 const auto metricsPrefix = resharding_metrics::getMetricsPrefix<DocT>();
 
-void buildStateDocumentCloneMetricsForUpdate(BSONObjBuilder& bob, ReshardingMetricsNew* metrics) {
+void buildStateDocumentCloneMetricsForUpdate(BSONObjBuilder& bob, ReshardingMetrics* metrics) {
     bob.append(getIntervalStartFieldName<DocT>(ReshardingRecipientMetrics::kDocumentCopyFieldName),
                metrics->getCopyingBegin());
 }
 
-void buildStateDocumentApplyMetricsForUpdate(BSONObjBuilder& bob, ReshardingMetricsNew* metrics) {
+void buildStateDocumentApplyMetricsForUpdate(BSONObjBuilder& bob, ReshardingMetrics* metrics) {
     bob.append(getIntervalEndFieldName<DocT>(ReshardingRecipientMetrics::kDocumentCopyFieldName),
                metrics->getCopyingEnd());
     bob.append(
@@ -164,14 +164,14 @@ void buildStateDocumentApplyMetricsForUpdate(BSONObjBuilder& bob, ReshardingMetr
 }
 
 void buildStateDocumentBlockingWritesMetricsForUpdate(BSONObjBuilder& bob,
-                                                      ReshardingMetricsNew* metrics) {
+                                                      ReshardingMetrics* metrics) {
     bob.append(
         getIntervalEndFieldName<DocT>(ReshardingRecipientMetrics::kOplogApplicationFieldName),
         metrics->getApplyingEnd());
 }
 
 void buildStateDocumentMetricsForUpdate(BSONObjBuilder& bob,
-                                        ReshardingMetricsNew* metrics,
+                                        ReshardingMetrics* metrics,
                                         CoordinatorStateEnum newState) {
     switch (newState) {
         case CoordinatorStateEnum::kCloning:
@@ -189,7 +189,7 @@ void buildStateDocumentMetricsForUpdate(BSONObjBuilder& bob,
 }
 
 void writeToCoordinatorStateNss(OperationContext* opCtx,
-                                ReshardingMetricsNew* metrics,
+                                ReshardingMetrics* metrics,
                                 const ReshardingCoordinatorDocument& coordinatorDoc,
                                 TxnNumber txnNumber) {
     BatchedCommandRequest request([&] {
@@ -608,8 +608,8 @@ BSONObj makeFlushRoutingTableCacheUpdatesCmd(const NamespaceString& nss) {
         BSON(WriteConcernOptions::kWriteConcernField << kMajorityWriteConcern.toBSON()));
 }
 
-ReshardingMetricsNew::CoordinatorState toMetricsState(CoordinatorStateEnum state) {
-    return ReshardingMetricsNew::CoordinatorState(state);
+ReshardingMetrics::CoordinatorState toMetricsState(CoordinatorStateEnum state) {
+    return ReshardingMetrics::CoordinatorState(state);
 }
 
 }  // namespace
@@ -664,7 +664,7 @@ void cleanupSourceConfigCollections(OperationContext* opCtx,
 }
 
 void writeDecisionPersistedState(OperationContext* opCtx,
-                                 ReshardingMetricsNew* metrics,
+                                 ReshardingMetrics* metrics,
                                  const ReshardingCoordinatorDocument& coordinatorDoc,
                                  OID newCollectionEpoch,
                                  Timestamp newCollectionTimestamp) {
@@ -691,7 +691,7 @@ void writeDecisionPersistedState(OperationContext* opCtx,
 }
 
 void insertCoordDocAndChangeOrigCollEntry(OperationContext* opCtx,
-                                          ReshardingMetricsNew* metrics,
+                                          ReshardingMetrics* metrics,
                                           const ReshardingCoordinatorDocument& coordinatorDoc) {
     ShardingCatalogManager::get(opCtx)->bumpCollectionVersionAndChangeMetadataInTxn(
         opCtx,
@@ -741,7 +741,7 @@ void insertCoordDocAndChangeOrigCollEntry(OperationContext* opCtx,
 
 void writeParticipantShardsAndTempCollInfo(
     OperationContext* opCtx,
-    ReshardingMetricsNew* metrics,
+    ReshardingMetrics* metrics,
     const ReshardingCoordinatorDocument& updatedCoordinatorDoc,
     std::vector<ChunkType> initialChunks,
     std::vector<BSONObj> zones) {
@@ -770,7 +770,7 @@ void writeParticipantShardsAndTempCollInfo(
 
 void writeStateTransitionAndCatalogUpdatesThenBumpShardVersions(
     OperationContext* opCtx,
-    ReshardingMetricsNew* metrics,
+    ReshardingMetrics* metrics,
     const ReshardingCoordinatorDocument& coordinatorDoc) {
     // Run updates to config.reshardingOperations and config.collections in a transaction
     auto nextState = coordinatorDoc.getState();
@@ -804,7 +804,7 @@ void writeStateTransitionAndCatalogUpdatesThenBumpShardVersions(
 }
 
 void removeCoordinatorDocAndReshardingFields(OperationContext* opCtx,
-                                             ReshardingMetricsNew* metrics,
+                                             ReshardingMetrics* metrics,
                                              const ReshardingCoordinatorDocument& coordinatorDoc,
                                              boost::optional<Status> abortReason) {
     // If the coordinator needs to abort and isn't in kInitializing, additional collections need to
@@ -1036,7 +1036,7 @@ ReshardingCoordinatorService::ReshardingCoordinator::ReshardingCoordinator(
     : PrimaryOnlyService::TypedInstance<ReshardingCoordinator>(),
       _id(coordinatorDoc.getReshardingUUID().toBSON()),
       _coordinatorService(coordinatorService),
-      _metricsNew{ReshardingMetricsNew::initializeFrom(coordinatorDoc, getGlobalServiceContext())},
+      _metrics{ReshardingMetrics::initializeFrom(coordinatorDoc, getGlobalServiceContext())},
       _metadata(coordinatorDoc.getCommonReshardingMetadata()),
       _coordinatorDoc(coordinatorDoc),
       _markKilledExecutor(std::make_shared<ThreadPool>([] {
@@ -1055,7 +1055,7 @@ ReshardingCoordinatorService::ReshardingCoordinator::ReshardingCoordinator(
         _reshardingCoordinatorObserver->onReshardingParticipantTransition(coordinatorDoc);
     }
 
-    _metricsNew->onStateTransition(boost::none, toMetricsState(coordinatorDoc.getState()));
+    _metrics->onStateTransition(boost::none, toMetricsState(coordinatorDoc.getState()));
 }
 
 void ReshardingCoordinatorService::ReshardingCoordinator::installCoordinatorDoc(
@@ -1080,8 +1080,8 @@ void ReshardingCoordinatorService::ReshardingCoordinator::installCoordinatorDoc(
     const auto previousState = _coordinatorDoc.getState();
     _coordinatorDoc = doc;
 
-    _metricsNew->onStateTransition(toMetricsState(previousState),
-                                   toMetricsState(_coordinatorDoc.getState()));
+    _metrics->onStateTransition(toMetricsState(previousState),
+                                toMetricsState(_coordinatorDoc.getState()));
 
     ShardingLogging::get(opCtx)->logChange(opCtx,
                                            "resharding.coordinator.transition",
@@ -1090,7 +1090,7 @@ void ReshardingCoordinatorService::ReshardingCoordinator::installCoordinatorDoc(
                                            kMajorityWriteConcern);
 }
 
-void markCompleted(const Status& status, ReshardingMetricsNew* metrics) {
+void markCompleted(const Status& status, ReshardingMetrics* metrics) {
     if (status.isOK()) {
         metrics->onSuccess();
     } else if (status == ErrorCodes::ReshardCollectionAborted) {
@@ -1320,7 +1320,7 @@ ReshardingCoordinatorService::ReshardingCoordinator::_commitAndFinishReshardOper
                    })
                    .then([this, executor] { return _awaitAllParticipantShardsDone(executor); })
                    .then([this, executor] {
-                       _metricsNew->onCriticalSectionEnd();
+                       _metrics->onCriticalSectionEnd();
 
                        // Best-effort attempt to trigger a refresh on the participant shards so
                        // they see the collection metadata without reshardingFields and no longer
@@ -1417,7 +1417,7 @@ SemiFuture<void> ReshardingCoordinatorService::ReshardingCoordinator::run(
                 _reshardingCoordinatorObserver->interrupt(status);
             }
 
-            _metricsNew->onStateTransition(toMetricsState(_coordinatorDoc.getState()), boost::none);
+            _metrics->onStateTransition(toMetricsState(_coordinatorDoc.getState()), boost::none);
         })
         .semi();
 }
@@ -1432,12 +1432,12 @@ ExecutorFuture<void> ReshardingCoordinatorService::ReshardingCoordinator::_onAbo
                auto opCtx = _cancelableOpCtxFactory->makeOperationContext(&cc());
 
                // Notify metrics as the operation is now complete for external observers.
-               markCompleted(status, _metricsNew.get());
+               markCompleted(status, _metrics.get());
 
                // The temporary collection and its corresponding entries were never created. Only
                // the coordinator document and reshardingFields require cleanup.
                resharding::removeCoordinatorDocAndReshardingFields(
-                   opCtx.get(), _metricsNew.get(), _coordinatorDoc, status);
+                   opCtx.get(), _metrics.get(), _coordinatorDoc, status);
                return status;
            })
         .onTransientError([](const Status& retryStatus) {
@@ -1506,7 +1506,7 @@ void ReshardingCoordinatorService::ReshardingCoordinator::abort() {
 boost::optional<BSONObj> ReshardingCoordinatorService::ReshardingCoordinator::reportForCurrentOp(
     MongoProcessInterface::CurrentOpConnectionsMode,
     MongoProcessInterface::CurrentOpSessionsMode) noexcept {
-    return _metricsNew->reportForCurrentOp();
+    return _metrics->reportForCurrentOp();
 }
 
 std::shared_ptr<ReshardingCoordinatorObserver>
@@ -1561,13 +1561,13 @@ void ReshardingCoordinatorService::ReshardingCoordinator::_insertCoordDocAndChan
     ReshardingCoordinatorDocument updatedCoordinatorDoc = _coordinatorDoc;
     updatedCoordinatorDoc.setState(CoordinatorStateEnum::kInitializing);
     resharding::insertCoordDocAndChangeOrigCollEntry(
-        opCtx.get(), _metricsNew.get(), updatedCoordinatorDoc);
+        opCtx.get(), _metrics.get(), updatedCoordinatorDoc);
     installCoordinatorDoc(opCtx.get(), updatedCoordinatorDoc);
 
     {
         // Note: don't put blocking or interruptible code in this block.
         _coordinatorDocWrittenPromise.emplaceValue();
-        _metricsNew->onStarted();
+        _metrics->onStarted();
     }
 
     pauseBeforeInsertCoordinatorDoc.pauseWhileSet();
@@ -1599,7 +1599,7 @@ void ReshardingCoordinatorService::ReshardingCoordinator::
     updatedCoordinatorDoc.setZones(boost::none);
 
     resharding::writeParticipantShardsAndTempCollInfo(opCtx.get(),
-                                                      _metricsNew.get(),
+                                                      _metrics.get(),
                                                       updatedCoordinatorDoc,
                                                       std::move(shardsAndChunks.initialChunks),
                                                       std::move(zones));
@@ -1659,7 +1659,7 @@ ReshardingCoordinatorService::ReshardingCoordinator::_awaitAllDonorsReadyToDonat
                 coordinatorDocChangedOnDisk,
                 highestMinFetchTimestamp,
                 computeApproxCopySize(coordinatorDocChangedOnDisk));
-            _metricsNew->onCopyingBegin();
+            _metrics->onCopyingBegin();
         })
         .then([this] { return _waitForMajority(_ctHolder->getAbortToken()); });
 }
@@ -1678,8 +1678,8 @@ ReshardingCoordinatorService::ReshardingCoordinator::_awaitAllRecipientsFinished
         .then([this](ReshardingCoordinatorDocument coordinatorDocChangedOnDisk) {
             this->_updateCoordinatorDocStateAndCatalogEntries(CoordinatorStateEnum::kApplying,
                                                               coordinatorDocChangedOnDisk);
-            _metricsNew->onCopyingEnd();
-            _metricsNew->onApplyingBegin();
+            _metrics->onCopyingEnd();
+            _metrics->onApplyingBegin();
         })
         .then([this] { return _waitForMajority(_ctHolder->getAbortToken()); });
 }
@@ -1691,7 +1691,7 @@ void ReshardingCoordinatorService::ReshardingCoordinator::_startCommitMonitor(
     }
 
     _commitMonitor = std::make_shared<resharding::CoordinatorCommitMonitor>(
-        _metricsNew,
+        _metrics,
         _coordinatorDoc.getSourceNss(),
         extractShardIdsFromParticipantEntries(_coordinatorDoc.getRecipientShards()),
         **executor,
@@ -1738,8 +1738,8 @@ ReshardingCoordinatorService::ReshardingCoordinator::_awaitAllRecipientsFinished
 
             this->_updateCoordinatorDocStateAndCatalogEntries(CoordinatorStateEnum::kBlockingWrites,
                                                               _coordinatorDoc);
-            _metricsNew->onApplyingEnd();
-            _metricsNew->onCriticalSectionBegin();
+            _metrics->onApplyingEnd();
+            _metrics->onCriticalSectionBegin();
         })
         .then([this] { return _waitForMajority(_ctHolder->getAbortToken()); })
         .thenRunOn(**executor)
@@ -1805,7 +1805,7 @@ Future<void> ReshardingCoordinatorService::ReshardingCoordinator::_commit(
 
 
     resharding::writeDecisionPersistedState(opCtx.get(),
-                                            _metricsNew.get(),
+                                            _metrics.get(),
                                             updatedCoordinatorDoc,
                                             std::move(newCollectionEpoch),
                                             std::move(newCollectionTimestamp));
@@ -1879,10 +1879,10 @@ ReshardingCoordinatorService::ReshardingCoordinator::_awaitAllParticipantShardsD
                 opCtx.get(), _ctHolder->getStepdownToken());
 
             // Notify metrics as the operation is now complete for external observers.
-            markCompleted(abortReason ? *abortReason : Status::OK(), _metricsNew.get());
+            markCompleted(abortReason ? *abortReason : Status::OK(), _metrics.get());
 
             resharding::removeCoordinatorDocAndReshardingFields(
-                opCtx.get(), _metricsNew.get(), coordinatorDoc, abortReason);
+                opCtx.get(), _metrics.get(), coordinatorDoc, abortReason);
         });
 }
 
@@ -1902,7 +1902,7 @@ void ReshardingCoordinatorService::ReshardingCoordinator::
 
     auto opCtx = _cancelableOpCtxFactory->makeOperationContext(&cc());
     resharding::writeStateTransitionAndCatalogUpdatesThenBumpShardVersions(
-        opCtx.get(), _metricsNew.get(), updatedCoordinatorDoc);
+        opCtx.get(), _metrics.get(), updatedCoordinatorDoc);
 
     // Update in-memory coordinator doc
     installCoordinatorDoc(opCtx.get(), updatedCoordinatorDoc);
@@ -2036,7 +2036,7 @@ void ReshardingCoordinatorService::ReshardingCoordinator::_updateChunkImbalanceM
         auto imbalanceCount =
             getMaxChunkImbalanceCount(routingInfo, allShardsWithOpTime.value, zoneInfo);
 
-        _metricsNew->setLastOpEndingChunkImbalance(imbalanceCount);
+        _metrics->setLastOpEndingChunkImbalance(imbalanceCount);
     } catch (const DBException& ex) {
         LOGV2_WARNING(5543000,
                       "Encountered error while trying to update resharding chunk imbalance metrics",
diff --git a/src/mongo/db/s/resharding/resharding_coordinator_service.h b/src/mongo/db/s/resharding/resharding_coordinator_service.h
index d24c23f6b68..6f0eb95c79a 100644
--- a/src/mongo/db/s/resharding/resharding_coordinator_service.h
+++ b/src/mongo/db/s/resharding/resharding_coordinator_service.h
@@ -33,7 +33,7 @@
 #include "mongo/db/repl/primary_only_service.h"
 #include "mongo/db/s/resharding/coordinator_document_gen.h"
 #include "mongo/db/s/resharding/resharding_coordinator_observer.h"
-#include "mongo/db/s/resharding/resharding_metrics_new.h"
+#include "mongo/db/s/resharding/resharding_metrics.h"
 #include "mongo/platform/mutex.h"
 #include "mongo/s/catalog/type_chunk.h"
 #include "mongo/s/catalog/type_collection.h"
@@ -55,28 +55,28 @@ void cleanupSourceConfigCollections(OperationContext* opCtx,
                                     const ReshardingCoordinatorDocument& coordinatorDoc);
 
 void writeDecisionPersistedState(OperationContext* opCtx,
-                                 ReshardingMetricsNew* metrics,
+                                 ReshardingMetrics* metrics,
                                  const ReshardingCoordinatorDocument& coordinatorDoc,
                                  OID newCollectionEpoch,
                                  Timestamp newCollectionTimestamp);
 
 void insertCoordDocAndChangeOrigCollEntry(OperationContext* opCtx,
-                                          ReshardingMetricsNew* metrics,
+                                          ReshardingMetrics* metrics,
                                           const ReshardingCoordinatorDocument& coordinatorDoc);
 
 void writeParticipantShardsAndTempCollInfo(OperationContext* opCtx,
-                                           ReshardingMetricsNew* metrics,
+                                           ReshardingMetrics* metrics,
                                            const ReshardingCoordinatorDocument& coordinatorDoc,
                                            std::vector<ChunkType> initialChunks,
                                            std::vector<BSONObj> zones);
 
 void writeStateTransitionAndCatalogUpdatesThenBumpShardVersions(
     OperationContext* opCtx,
-    ReshardingMetricsNew* metrics,
+    ReshardingMetrics* metrics,
     const ReshardingCoordinatorDocument& coordinatorDoc);
 
 void removeCoordinatorDocAndReshardingFields(OperationContext* opCtx,
-                                             ReshardingMetricsNew* metrics,
+                                             ReshardingMetrics* metrics,
                                              const ReshardingCoordinatorDocument& coordinatorDoc,
                                              boost::optional<Status> abortReason = boost::none);
 }  // namespace resharding
@@ -513,7 +513,7 @@ private:
     // The primary-only service instance corresponding to the coordinator instance. Not owned.
     const ReshardingCoordinatorService* const _coordinatorService;
 
-    std::shared_ptr<ReshardingMetricsNew> _metricsNew;
+    std::shared_ptr<ReshardingMetrics> _metrics;
 
     // The in-memory representation of the immutable portion of the document in
     // config.reshardingOperations.
diff --git a/src/mongo/db/s/resharding/resharding_coordinator_test.cpp b/src/mongo/db/s/resharding/resharding_coordinator_test.cpp
index da56d0d8cb5..4a8a994f144 100644
--- a/src/mongo/db/s/resharding/resharding_coordinator_test.cpp
+++ b/src/mongo/db/s/resharding/resharding_coordinator_test.cpp
@@ -85,13 +85,12 @@ protected:
         TransactionCoordinatorService::get(operationContext())
             ->onShardingInitialization(operationContext(), true);
 
-        _metrics =
-            ReshardingMetricsNew::makeInstance(_originalUUID,
-                                               _newShardKey.toBSON(),
-                                               _originalNss,
-                                               ReshardingMetricsNew::Role::kCoordinator,
-                                               getServiceContext()->getFastClockSource()->now(),
-                                               getServiceContext());
+        _metrics = ReshardingMetrics::makeInstance(_originalUUID,
+                                                   _newShardKey.toBSON(),
+                                                   _originalNss,
+                                                   ReshardingMetrics::Role::kCoordinator,
+                                                   getServiceContext()->getFastClockSource()->now(),
+                                                   getServiceContext());
     }
 
     void tearDown() override {
@@ -723,7 +722,7 @@ protected:
     ShardKeyPattern _oldShardKey = ShardKeyPattern(BSON("oldSK" << 1));
     ShardKeyPattern _newShardKey = ShardKeyPattern(BSON("newSK" << 1));
 
-    std::unique_ptr<ReshardingMetricsNew> _metrics;
+    std::unique_ptr<ReshardingMetrics> _metrics;
 
     const std::vector<ChunkRange> _oldChunkRanges = {
         ChunkRange(_oldShardKey.getKeyPattern().globalMin(), BSON("oldSK" << 12345)),
diff --git a/src/mongo/db/s/resharding/resharding_data_replication.cpp b/src/mongo/db/s/resharding/resharding_data_replication.cpp
index 4143c8c0c76..afd580b0037 100644
--- a/src/mongo/db/s/resharding/resharding_data_replication.cpp
+++ b/src/mongo/db/s/resharding/resharding_data_replication.cpp
@@ -81,12 +81,12 @@ void ensureFulfilledPromise(SharedPromise<void>& sp, Status error) {
 }  // namespace
 
 std::unique_ptr<ReshardingCollectionCloner> ReshardingDataReplication::_makeCollectionCloner(
-    ReshardingMetricsNew* metricsNew,
+    ReshardingMetrics* metrics,
     const CommonReshardingMetadata& metadata,
     const ShardId& myShardId,
     Timestamp cloneTimestamp) {
     return std::make_unique<ReshardingCollectionCloner>(
-        metricsNew,
+        metrics,
         ShardKeyPattern{metadata.getReshardingKey()},
         metadata.getSourceNss(),
         metadata.getSourceUUID(),
@@ -112,7 +112,7 @@ std::vector<std::unique_ptr<ReshardingTxnCloner>> ReshardingDataReplication::_ma
 
 std::vector<std::unique_ptr<ReshardingOplogFetcher>> ReshardingDataReplication::_makeOplogFetchers(
     OperationContext* opCtx,
-    ReshardingMetricsNew* metricsNew,
+    ReshardingMetrics* metrics,
     const CommonReshardingMetadata& metadata,
     const std::vector<DonorShardFetchTimestamp>& donorShards,
     const ShardId& myShardId) {
@@ -128,7 +128,7 @@ std::vector<std::unique_ptr<ReshardingOplogFetcher>> ReshardingDataReplication::
         invariant((idToResumeFrom >= ReshardingDonorOplogId{minFetchTimestamp, minFetchTimestamp}));
 
         oplogFetchers.emplace_back(std::make_unique<ReshardingOplogFetcher>(
-            std::make_unique<ReshardingOplogFetcher::Env>(opCtx->getServiceContext(), metricsNew),
+            std::make_unique<ReshardingOplogFetcher::Env>(opCtx->getServiceContext(), metrics),
             metadata.getReshardingUUID(),
             metadata.getSourceUUID(),
             // The recipient fetches oplog entries from the donor starting from the largest _id
@@ -206,7 +206,7 @@ std::vector<std::unique_ptr<ReshardingOplogApplier>> ReshardingDataReplication::
 
 std::unique_ptr<ReshardingDataReplicationInterface> ReshardingDataReplication::make(
     OperationContext* opCtx,
-    ReshardingMetricsNew* metricsNew,
+    ReshardingMetrics* metrics,
     ReshardingApplierMetricsMap* applierMetricsMap,
     CommonReshardingMetadata metadata,
     const std::vector<DonorShardFetchTimestamp>& donorShards,
@@ -218,11 +218,11 @@ std::unique_ptr<ReshardingDataReplicationInterface> ReshardingDataReplication::m
     std::vector<std::unique_ptr<ReshardingTxnCloner>> txnCloners;
 
     if (!cloningDone) {
-        collectionCloner = _makeCollectionCloner(metricsNew, metadata, myShardId, cloneTimestamp);
+        collectionCloner = _makeCollectionCloner(metrics, metadata, myShardId, cloneTimestamp);
         txnCloners = _makeTxnCloners(metadata, donorShards);
     }
 
-    auto oplogFetchers = _makeOplogFetchers(opCtx, metricsNew, metadata, donorShards, myShardId);
+    auto oplogFetchers = _makeOplogFetchers(opCtx, metrics, metadata, donorShards, myShardId);
 
     auto oplogFetcherExecutor = _makeOplogFetcherExecutor(donorShards.size());
 
diff --git a/src/mongo/db/s/resharding/resharding_data_replication.h b/src/mongo/db/s/resharding/resharding_data_replication.h
index f8348646758..2e44a5d2a21 100644
--- a/src/mongo/db/s/resharding/resharding_data_replication.h
+++ b/src/mongo/db/s/resharding/resharding_data_replication.h
@@ -140,7 +140,7 @@ private:
 public:
     static std::unique_ptr<ReshardingDataReplicationInterface> make(
         OperationContext* opCtx,
-        ReshardingMetricsNew* metricsNew,
+        ReshardingMetrics* metrics,
         ReshardingApplierMetricsMap* applierMetricsMap,
         CommonReshardingMetadata metadata,
         const std::vector<DonorShardFetchTimestamp>& donorShards,
@@ -196,7 +196,7 @@ public:
 
 private:
     static std::unique_ptr<ReshardingCollectionCloner> _makeCollectionCloner(
-        ReshardingMetricsNew* metricsNew,
+        ReshardingMetrics* metrics,
         const CommonReshardingMetadata& metadata,
         const ShardId& myShardId,
         Timestamp cloneTimestamp);
@@ -207,7 +207,7 @@ private:
 
     static std::vector<std::unique_ptr<ReshardingOplogFetcher>> _makeOplogFetchers(
         OperationContext* opCtx,
-        ReshardingMetricsNew* metricsNew,
+        ReshardingMetrics* metrics,
         const CommonReshardingMetadata& metadata,
         const std::vector<DonorShardFetchTimestamp>& donorShards,
         const ShardId& myShardId);
diff --git a/src/mongo/db/s/resharding/resharding_donor_service.cpp b/src/mongo/db/s/resharding/resharding_donor_service.cpp
index 7f870033a1f..2ba67f8463b 100644
--- a/src/mongo/db/s/resharding/resharding_donor_service.cpp
+++ b/src/mongo/db/s/resharding/resharding_donor_service.cpp
@@ -183,8 +183,8 @@ public:
     }
 };
 
-ReshardingMetricsNew::DonorState toMetricsState(DonorStateEnum state) {
-    return ReshardingMetricsNew::DonorState(state);
+ReshardingMetrics::DonorState toMetricsState(DonorStateEnum state) {
+    return ReshardingMetrics::DonorState(state);
 }
 
 }  // namespace
@@ -209,7 +209,7 @@ ReshardingDonorService::DonorStateMachine::DonorStateMachine(
     std::unique_ptr<DonorStateMachineExternalState> externalState)
     : repl::PrimaryOnlyService::TypedInstance<DonorStateMachine>(),
       _donorService(donorService),
-      _metricsNew{ReshardingMetricsNew::initializeFrom(donorDoc, getGlobalServiceContext())},
+      _metrics{ReshardingMetrics::initializeFrom(donorDoc, getGlobalServiceContext())},
       _metadata{donorDoc.getCommonReshardingMetadata()},
       _recipientShardIds{donorDoc.getRecipientShards()},
       _donorCtx{donorDoc.getMutableState()},
@@ -233,7 +233,7 @@ ReshardingDonorService::DonorStateMachine::DonorStateMachine(
       }()) {
     invariant(_externalState);
 
-    _metricsNew->onStateTransition(boost::none, toMetricsState(_donorCtx.getState()));
+    _metrics->onStateTransition(boost::none, toMetricsState(_donorCtx.getState()));
 }
 
 ExecutorFuture<void> ReshardingDonorService::DonorStateMachine::_runUntilBlockingWritesOrErrored(
@@ -385,7 +385,7 @@ ExecutorFuture<void> ReshardingDonorService::DonorStateMachine::_finishReshardin
                            _critSecReason,
                            ShardingCatalogClient::kLocalWriteConcern);
 
-                   _metricsNew->onCriticalSectionEnd();
+                   _metrics->onCriticalSectionEnd();
                }
 
                auto opCtx = _cancelableOpCtxFactory->makeOperationContext(&cc());
@@ -427,7 +427,7 @@ Status ReshardingDonorService::DonorStateMachine::_runMandatoryCleanup(
         ensureFulfilledPromise(lk, _completionPromise, statusForPromise);
     }
 
-    _metricsNew->onStateTransition(toMetricsState(_donorCtx.getState()), boost::none);
+    _metrics->onStateTransition(toMetricsState(_donorCtx.getState()), boost::none);
 
     return status;
 }
@@ -493,7 +493,7 @@ void ReshardingDonorService::DonorStateMachine::interrupt(Status status) {}
 boost::optional<BSONObj> ReshardingDonorService::DonorStateMachine::reportForCurrentOp(
     MongoProcessInterface::CurrentOpConnectionsMode connMode,
     MongoProcessInterface::CurrentOpSessionsMode sessionMode) noexcept {
-    return _metricsNew->reportForCurrentOp();
+    return _metrics->reportForCurrentOp();
 }
 
 void ReshardingDonorService::DonorStateMachine::onReshardingFieldsChanges(
@@ -521,11 +521,11 @@ void ReshardingDonorService::DonorStateMachine::onReshardingFieldsChanges(
 }
 
 void ReshardingDonorService::DonorStateMachine::onWriteDuringCriticalSection() {
-    _metricsNew->onWriteDuringCriticalSection();
+    _metrics->onWriteDuringCriticalSection();
 }
 
 void ReshardingDonorService::DonorStateMachine::onReadDuringCriticalSection() {
-    _metricsNew->onReadDuringCriticalSection();
+    _metrics->onReadDuringCriticalSection();
 }
 
 SharedSemiFuture<void> ReshardingDonorService::DonorStateMachine::awaitCriticalSectionAcquired() {
@@ -690,7 +690,7 @@ void ReshardingDonorService::DonorStateMachine::
                 _critSecReason,
                 ShardingCatalogClient::kLocalWriteConcern);
 
-        _metricsNew->onCriticalSectionBegin();
+        _metrics->onCriticalSectionBegin();
     }
 
     {
@@ -828,7 +828,7 @@ void ReshardingDonorService::DonorStateMachine::_transitionState(DonorShardConte
 
     _updateDonorDocument(std::move(newDonorCtx));
 
-    _metricsNew->onStateTransition(toMetricsState(oldState), toMetricsState(newState));
+    _metrics->onStateTransition(toMetricsState(oldState), toMetricsState(newState));
 
     LOGV2_INFO(5279505,
                "Transitioned resharding donor state",
diff --git a/src/mongo/db/s/resharding/resharding_donor_service.h b/src/mongo/db/s/resharding/resharding_donor_service.h
index f2f4d99d2e8..2d5fc6e05df 100644
--- a/src/mongo/db/s/resharding/resharding_donor_service.h
+++ b/src/mongo/db/s/resharding/resharding_donor_service.h
@@ -32,7 +32,7 @@
 #include "mongo/db/cancelable_operation_context.h"
 #include "mongo/db/repl/primary_only_service.h"
 #include "mongo/db/s/resharding/donor_document_gen.h"
-#include "mongo/db/s/resharding/resharding_metrics_new.h"
+#include "mongo/db/s/resharding/resharding_metrics.h"
 #include "mongo/s/resharding/type_collection_fields_gen.h"
 
 namespace mongo {
@@ -218,7 +218,7 @@ private:
     // The primary-only service instance corresponding to the donor instance. Not owned.
     const ReshardingDonorService* const _donorService;
 
-    std::unique_ptr<ReshardingMetricsNew> _metricsNew;
+    std::unique_ptr<ReshardingMetrics> _metrics;
 
     // The in-memory representation of the immutable portion of the document in
     // config.localReshardingOperations.donor.
diff --git a/src/mongo/db/s/resharding/resharding_metrics_new.cpp b/src/mongo/db/s/resharding/resharding_metrics.cpp
index e07468ad1b9..610ef970475 100644
--- a/src/mongo/db/s/resharding/resharding_metrics_new.cpp
+++ b/src/mongo/db/s/resharding/resharding_metrics.cpp
@@ -26,15 +26,15 @@
  *    exception statement from all source files in the program, then also delete
  *    it in the license file.
  */
-#include "mongo/db/s/resharding/resharding_metrics_new.h"
+#include "mongo/db/s/resharding/resharding_metrics.h"
 #include "mongo/db/exec/document_value/document.h"
 
 
 namespace mongo {
 namespace {
 
-inline ReshardingMetricsNew::State getDefaultState(ReshardingMetricsNew::Role role) {
-    using Role = ReshardingMetricsNew::Role;
+inline ReshardingMetrics::State getDefaultState(ReshardingMetrics::Role role) {
+    using Role = ReshardingMetrics::Role;
     switch (role) {
         case Role::kCoordinator:
             return CoordinatorStateEnum::kUnused;
@@ -70,14 +70,13 @@ Date_t readStartTime(const CommonReshardingMetadata& metadata, ClockSource* fall
 
 }  // namespace
 
-ReshardingMetricsNew::ReshardingMetricsNew(
-    UUID instanceId,
-    BSONObj shardKey,
-    NamespaceString nss,
-    Role role,
-    Date_t startTime,
-    ClockSource* clockSource,
-    ShardingDataTransformCumulativeMetrics* cumulativeMetrics)
+ReshardingMetrics::ReshardingMetrics(UUID instanceId,
+                                     BSONObj shardKey,
+                                     NamespaceString nss,
+                                     Role role,
+                                     Date_t startTime,
+                                     ClockSource* clockSource,
+                                     ShardingDataTransformCumulativeMetrics* cumulativeMetrics)
     : ShardingDataTransformInstanceMetrics{std::move(instanceId),
                                            createOriginalCommand(nss, std::move(shardKey)),
                                            nss,
@@ -87,44 +86,42 @@ ReshardingMetricsNew::ReshardingMetricsNew(
                                            cumulativeMetrics},
       _state{getDefaultState(role)} {}
 
-ReshardingMetricsNew::ReshardingMetricsNew(
-    const CommonReshardingMetadata& metadata,
-    Role role,
-    ClockSource* clockSource,
-    ShardingDataTransformCumulativeMetrics* cumulativeMetrics)
-    : ReshardingMetricsNew{metadata.getReshardingUUID(),
-                           metadata.getReshardingKey().toBSON(),
-                           metadata.getSourceNss(),
-                           role,
-                           readStartTime(metadata, clockSource),
-                           clockSource,
-                           cumulativeMetrics} {}
-
-std::string ReshardingMetricsNew::createOperationDescription() const noexcept {
+ReshardingMetrics::ReshardingMetrics(const CommonReshardingMetadata& metadata,
+                                     Role role,
+                                     ClockSource* clockSource,
+                                     ShardingDataTransformCumulativeMetrics* cumulativeMetrics)
+    : ReshardingMetrics{metadata.getReshardingUUID(),
+                        metadata.getReshardingKey().toBSON(),
+                        metadata.getSourceNss(),
+                        role,
+                        readStartTime(metadata, clockSource),
+                        clockSource,
+                        cumulativeMetrics} {}
+
+std::string ReshardingMetrics::createOperationDescription() const noexcept {
     return fmt::format("ReshardingMetrics{}Service {}",
                        ShardingDataTransformMetrics::getRoleName(_role),
                        _instanceId.toString());
 }
 
-std::unique_ptr<ReshardingMetricsNew> ReshardingMetricsNew::makeInstance(
-    UUID instanceId,
-    BSONObj shardKey,
-    NamespaceString nss,
-    Role role,
-    Date_t startTime,
-    ServiceContext* serviceContext) {
+std::unique_ptr<ReshardingMetrics> ReshardingMetrics::makeInstance(UUID instanceId,
+                                                                   BSONObj shardKey,
+                                                                   NamespaceString nss,
+                                                                   Role role,
+                                                                   Date_t startTime,
+                                                                   ServiceContext* serviceContext) {
     auto cumulativeMetrics =
         ShardingDataTransformCumulativeMetrics::getForResharding(serviceContext);
-    return std::make_unique<ReshardingMetricsNew>(instanceId,
-                                                  createOriginalCommand(nss, std::move(shardKey)),
-                                                  std::move(nss),
-                                                  role,
-                                                  startTime,
-                                                  serviceContext->getFastClockSource(),
-                                                  cumulativeMetrics);
+    return std::make_unique<ReshardingMetrics>(instanceId,
+                                               createOriginalCommand(nss, std::move(shardKey)),
+                                               std::move(nss),
+                                               role,
+                                               startTime,
+                                               serviceContext->getFastClockSource(),
+                                               cumulativeMetrics);
 }
 
-StringData ReshardingMetricsNew::getStateString() const noexcept {
+StringData ReshardingMetrics::getStateString() const noexcept {
     return stdx::visit(
         visit_helper::Overloaded{
             [](CoordinatorStateEnum state) { return CoordinatorState_serializer(state); },
@@ -133,7 +130,7 @@ StringData ReshardingMetricsNew::getStateString() const noexcept {
         _state.load());
 }
 
-void ReshardingMetricsNew::accumulateFrom(const ReshardingOplogApplierProgress& progressDoc) {
+void ReshardingMetrics::accumulateFrom(const ReshardingOplogApplierProgress& progressDoc) {
     invariant(_role == Role::kRecipient);
 
     accumulateValues(progressDoc.getInsertsApplied(),
@@ -142,7 +139,7 @@ void ReshardingMetricsNew::accumulateFrom(const ReshardingOplogApplierProgress&
                      progressDoc.getWritesToStashCollections());
 }
 
-void ReshardingMetricsNew::restoreRecipientSpecificFields(
+void ReshardingMetrics::restoreRecipientSpecificFields(
     const ReshardingRecipientDocument& document) {
     auto metrics = document.getMetrics();
     if (!metrics) {
@@ -161,14 +158,14 @@ void ReshardingMetricsNew::restoreRecipientSpecificFields(
     restorePhaseDurationFields(document);
 }
 
-void ReshardingMetricsNew::restoreCoordinatorSpecificFields(
+void ReshardingMetrics::restoreCoordinatorSpecificFields(
     const ReshardingCoordinatorDocument& document) {
     restorePhaseDurationFields(document);
 }
 
-ReshardingMetricsNew::DonorState::DonorState(DonorStateEnum enumVal) : _enumVal(enumVal) {}
+ReshardingMetrics::DonorState::DonorState(DonorStateEnum enumVal) : _enumVal(enumVal) {}
 
-ShardingDataTransformCumulativeMetrics::DonorStateEnum ReshardingMetricsNew::DonorState::toMetrics()
+ShardingDataTransformCumulativeMetrics::DonorStateEnum ReshardingMetrics::DonorState::toMetrics()
     const {
     using MetricsEnum = ShardingDataTransformCumulativeMetrics::DonorStateEnum;
 
@@ -204,15 +201,14 @@ ShardingDataTransformCumulativeMetrics::DonorStateEnum ReshardingMetricsNew::Don
     }
 }
 
-DonorStateEnum ReshardingMetricsNew::DonorState::getState() const {
+DonorStateEnum ReshardingMetrics::DonorState::getState() const {
     return _enumVal;
 }
 
-ReshardingMetricsNew::RecipientState::RecipientState(RecipientStateEnum enumVal)
-    : _enumVal(enumVal) {}
+ReshardingMetrics::RecipientState::RecipientState(RecipientStateEnum enumVal) : _enumVal(enumVal) {}
 
 ShardingDataTransformCumulativeMetrics::RecipientStateEnum
-ReshardingMetricsNew::RecipientState::toMetrics() const {
+ReshardingMetrics::RecipientState::toMetrics() const {
     using MetricsEnum = ShardingDataTransformCumulativeMetrics::RecipientStateEnum;
 
     switch (_enumVal) {
@@ -248,15 +244,15 @@ ReshardingMetricsNew::RecipientState::toMetrics() const {
     }
 }
 
-RecipientStateEnum ReshardingMetricsNew::RecipientState::getState() const {
+RecipientStateEnum ReshardingMetrics::RecipientState::getState() const {
     return _enumVal;
 }
 
-ReshardingMetricsNew::CoordinatorState::CoordinatorState(CoordinatorStateEnum enumVal)
+ReshardingMetrics::CoordinatorState::CoordinatorState(CoordinatorStateEnum enumVal)
     : _enumVal(enumVal) {}
 
 ShardingDataTransformCumulativeMetrics::CoordinatorStateEnum
-ReshardingMetricsNew::CoordinatorState::toMetrics() const {
+ReshardingMetrics::CoordinatorState::toMetrics() const {
     switch (_enumVal) {
         case CoordinatorStateEnum::kUnused:
             return ShardingDataTransformCumulativeMetrics::CoordinatorStateEnum::kUnused;
@@ -292,7 +288,7 @@ ReshardingMetricsNew::CoordinatorState::toMetrics() const {
     }
 }
 
-CoordinatorStateEnum ReshardingMetricsNew::CoordinatorState::getState() const {
+CoordinatorStateEnum ReshardingMetrics::CoordinatorState::getState() const {
     return _enumVal;
 }
 
diff --git a/src/mongo/db/s/resharding/resharding_metrics_new.h b/src/mongo/db/s/resharding/resharding_metrics.h
index b8e96698b0d..a1faa5a96da 100644
--- a/src/mongo/db/s/resharding/resharding_metrics_new.h
+++ b/src/mongo/db/s/resharding/resharding_metrics.h
@@ -38,7 +38,7 @@
 
 namespace mongo {
 
-class ReshardingMetricsNew : public ShardingDataTransformInstanceMetrics {
+class ReshardingMetrics : public ShardingDataTransformInstanceMetrics {
 public:
     using State = stdx::variant<CoordinatorStateEnum, RecipientStateEnum, DonorStateEnum>;
 
@@ -78,24 +78,24 @@ public:
         CoordinatorStateEnum _enumVal;
     };
 
-    ReshardingMetricsNew(UUID instanceId,
-                         BSONObj shardKey,
-                         NamespaceString nss,
-                         Role role,
-                         Date_t startTime,
-                         ClockSource* clockSource,
-                         ShardingDataTransformCumulativeMetrics* cumulativeMetrics);
-    ReshardingMetricsNew(const CommonReshardingMetadata& metadata,
-                         Role role,
-                         ClockSource* clockSource,
-                         ShardingDataTransformCumulativeMetrics* cumulativeMetrics);
-
-    static std::unique_ptr<ReshardingMetricsNew> makeInstance(UUID instanceId,
-                                                              BSONObj shardKey,
-                                                              NamespaceString nss,
-                                                              Role role,
-                                                              Date_t startTime,
-                                                              ServiceContext* serviceContext);
+    ReshardingMetrics(UUID instanceId,
+                      BSONObj shardKey,
+                      NamespaceString nss,
+                      Role role,
+                      Date_t startTime,
+                      ClockSource* clockSource,
+                      ShardingDataTransformCumulativeMetrics* cumulativeMetrics);
+    ReshardingMetrics(const CommonReshardingMetadata& metadata,
+                      Role role,
+                      ClockSource* clockSource,
+                      ShardingDataTransformCumulativeMetrics* cumulativeMetrics);
+
+    static std::unique_ptr<ReshardingMetrics> makeInstance(UUID instanceId,
+                                                           BSONObj shardKey,
+                                                           NamespaceString nss,
+                                                           Role role,
+                                                           Date_t startTime,
+                                                           ServiceContext* serviceContext);
 
     template <typename T>
     static auto initializeFrom(const T& document,
@@ -103,10 +103,10 @@ public:
                                ShardingDataTransformCumulativeMetrics* cumulativeMetrics) {
         static_assert(resharding_metrics::isStateDocument<T>);
         auto result =
-            std::make_unique<ReshardingMetricsNew>(document.getCommonReshardingMetadata(),
-                                                   resharding_metrics::getRoleForStateDocument<T>(),
-                                                   clockSource,
-                                                   cumulativeMetrics);
+            std::make_unique<ReshardingMetrics>(document.getCommonReshardingMetadata(),
+                                                resharding_metrics::getRoleForStateDocument<T>(),
+                                                clockSource,
+                                                cumulativeMetrics);
         result->setState(resharding_metrics::getState(document));
         result->restoreRoleSpecificFields(document);
         return result;
diff --git a/src/mongo/db/s/resharding/resharding_metrics_new_test.cpp b/src/mongo/db/s/resharding/resharding_metrics_test.cpp
index 82bcba56d43..48a81ba5183 100644
--- a/src/mongo/db/s/resharding/resharding_metrics_new_test.cpp
+++ b/src/mongo/db/s/resharding/resharding_metrics_test.cpp
@@ -30,7 +30,7 @@
 
 #include "mongo/platform/basic.h"
 
-#include "mongo/db/s/resharding/resharding_metrics_new.h"
+#include "mongo/db/s/resharding/resharding_metrics.h"
 #include "mongo/db/s/resharding/resharding_service_test_helpers.h"
 #include "mongo/db/s/resharding/resharding_util.h"
 #include "mongo/db/s/sharding_data_transform_cumulative_metrics.h"
@@ -49,16 +49,16 @@ const auto kShardKey = BSON("newKey" << 1);
 class ReshardingMetricsTest : public ShardingDataTransformMetricsTestFixture {
 
 public:
-    std::unique_ptr<ReshardingMetricsNew> createInstanceMetrics(ClockSource* clockSource,
-                                                                UUID instanceId = UUID::gen(),
-                                                                Role role = Role::kDonor) {
-        return std::make_unique<ReshardingMetricsNew>(instanceId,
-                                                      BSON("y" << 1),
-                                                      kTestNamespace,
-                                                      role,
-                                                      clockSource->now(),
-                                                      clockSource,
-                                                      &_cumulativeMetrics);
+    std::unique_ptr<ReshardingMetrics> createInstanceMetrics(ClockSource* clockSource,
+                                                             UUID instanceId = UUID::gen(),
+                                                             Role role = Role::kDonor) {
+        return std::make_unique<ReshardingMetrics>(instanceId,
+                                                   BSON("y" << 1),
+                                                   kTestNamespace,
+                                                   role,
+                                                   clockSource->now(),
+                                                   clockSource,
+                                                   &_cumulativeMetrics);
     }
 
     const UUID& getSourceCollectionId() {
@@ -69,7 +69,7 @@ public:
     template <typename T>
     BSONObj getReportFromStateDocument(T document) {
         auto metrics =
-            ReshardingMetricsNew::initializeFrom(document, getClockSource(), &_cumulativeMetrics);
+            ReshardingMetrics::initializeFrom(document, getClockSource(), &_cumulativeMetrics);
         return metrics->reportForCurrentOp();
     }
 
@@ -169,7 +169,7 @@ public:
         doc.setMetrics(metricsDoc);
 
         auto metrics =
-            ReshardingMetricsNew::initializeFrom(doc, getClockSource(), &_cumulativeMetrics);
+            ReshardingMetrics::initializeFrom(doc, getClockSource(), &_cumulativeMetrics);
 
         clock->advance(kInterval);
         auto report = metrics->reportForCurrentOp();
diff --git a/src/mongo/db/s/resharding/resharding_oplog_applier.h b/src/mongo/db/s/resharding/resharding_oplog_applier.h
index 56a7e9d3a0a..f1df65219cc 100644
--- a/src/mongo/db/s/resharding/resharding_oplog_applier.h
+++ b/src/mongo/db/s/resharding/resharding_oplog_applier.h
@@ -36,7 +36,7 @@
 #include "mongo/db/repl/oplog_entry.h"
 #include "mongo/db/s/resharding/donor_oplog_id_gen.h"
 #include "mongo/db/s/resharding/resharding_donor_oplog_iterator.h"
-#include "mongo/db/s/resharding/resharding_metrics_new.h"
+#include "mongo/db/s/resharding/resharding_metrics.h"
 #include "mongo/db/s/resharding/resharding_oplog_application.h"
 #include "mongo/db/s/resharding/resharding_oplog_applier_progress_gen.h"
 #include "mongo/db/s/resharding/resharding_oplog_batch_applier.h"
diff --git a/src/mongo/db/s/resharding/resharding_oplog_applier_metrics.cpp b/src/mongo/db/s/resharding/resharding_oplog_applier_metrics.cpp
index 31bb6ca8dd6..7a474b7edf1 100644
--- a/src/mongo/db/s/resharding/resharding_oplog_applier_metrics.cpp
+++ b/src/mongo/db/s/resharding/resharding_oplog_applier_metrics.cpp
@@ -34,8 +34,8 @@
 namespace mongo {
 
 ReshardingOplogApplierMetrics::ReshardingOplogApplierMetrics(
-    ReshardingMetricsNew* metricsNew, boost::optional<ReshardingOplogApplierProgress> progressDoc)
-    : _metricsNew(metricsNew) {
+    ReshardingMetrics* metrics, boost::optional<ReshardingOplogApplierProgress> progressDoc)
+    : _metrics(metrics) {
     if (progressDoc) {
         _insertsApplied = progressDoc->getInsertsApplied();
         _updatesApplied = progressDoc->getUpdatesApplied();
@@ -46,35 +46,35 @@ ReshardingOplogApplierMetrics::ReshardingOplogApplierMetrics(
 
 void ReshardingOplogApplierMetrics::onInsertApplied() {
     _insertsApplied++;
-    _metricsNew->onInsertApplied();
+    _metrics->onInsertApplied();
 }
 
 void ReshardingOplogApplierMetrics::onUpdateApplied() {
     _updatesApplied++;
-    _metricsNew->onUpdateApplied();
+    _metrics->onUpdateApplied();
 }
 
 void ReshardingOplogApplierMetrics::onDeleteApplied() {
     _deletesApplied++;
-    _metricsNew->onDeleteApplied();
+    _metrics->onDeleteApplied();
 }
 
 void ReshardingOplogApplierMetrics::onBatchRetrievedDuringOplogApplying(Milliseconds elapsed) {
-    _metricsNew->onBatchRetrievedDuringOplogApplying(elapsed);
+    _metrics->onBatchRetrievedDuringOplogApplying(elapsed);
 }
 
 void ReshardingOplogApplierMetrics::onOplogLocalBatchApplied(Milliseconds elapsed) {
-    _metricsNew->onOplogLocalBatchApplied(elapsed);
+    _metrics->onOplogLocalBatchApplied(elapsed);
 }
 
 void ReshardingOplogApplierMetrics::onOplogEntriesApplied(int64_t numEntries) {
     _oplogEntriesApplied += numEntries;
-    _metricsNew->onOplogEntriesApplied(numEntries);
+    _metrics->onOplogEntriesApplied(numEntries);
 }
 
 void ReshardingOplogApplierMetrics::onWriteToStashCollections() {
     _writesToStashCollections++;
-    _metricsNew->onWriteToStashedCollections();
+    _metrics->onWriteToStashedCollections();
 }
 
 int64_t ReshardingOplogApplierMetrics::getInsertsApplied() const {
diff --git a/src/mongo/db/s/resharding/resharding_oplog_applier_metrics.h b/src/mongo/db/s/resharding/resharding_oplog_applier_metrics.h
index 28830da1bfc..14347ce0b6b 100644
--- a/src/mongo/db/s/resharding/resharding_oplog_applier_metrics.h
+++ b/src/mongo/db/s/resharding/resharding_oplog_applier_metrics.h
@@ -29,7 +29,7 @@
 
 #pragma once
 
-#include "mongo/db/s/resharding/resharding_metrics_new.h"
+#include "mongo/db/s/resharding/resharding_metrics.h"
 #include "mongo/db/s/resharding/resharding_oplog_applier_progress_gen.h"
 #include "mongo/util/duration.h"
 
@@ -40,7 +40,7 @@ namespace mongo {
  */
 class ReshardingOplogApplierMetrics {
 public:
-    ReshardingOplogApplierMetrics(ReshardingMetricsNew* metricsNew,
+    ReshardingOplogApplierMetrics(ReshardingMetrics* metrics,
                                   boost::optional<ReshardingOplogApplierProgress> progressDoc);
 
     void onInsertApplied();
@@ -59,7 +59,7 @@ public:
     int64_t getWritesToStashCollections() const;
 
 private:
-    ReshardingMetricsNew* _metricsNew;
+    ReshardingMetrics* _metrics;
     int64_t _insertsApplied{0};
     int64_t _updatesApplied{0};
     int64_t _deletesApplied{0};
diff --git a/src/mongo/db/s/resharding/resharding_oplog_applier_metrics_test.cpp b/src/mongo/db/s/resharding/resharding_oplog_applier_metrics_test.cpp
index 44ea5efb842..7c04439713a 100644
--- a/src/mongo/db/s/resharding/resharding_oplog_applier_metrics_test.cpp
+++ b/src/mongo/db/s/resharding/resharding_oplog_applier_metrics_test.cpp
@@ -42,14 +42,14 @@ namespace {
 
 class ReshardingOplogApplierMetricsTest : public ShardingDataTransformMetricsTestFixture {
 public:
-    std::unique_ptr<ReshardingMetricsNew> createInstanceMetrics() {
-        return std::make_unique<ReshardingMetricsNew>(UUID::gen(),
-                                                      kTestCommand,
-                                                      kTestNamespace,
-                                                      ReshardingMetricsNew::Role::kRecipient,
-                                                      getClockSource()->now(),
-                                                      getClockSource(),
-                                                      &_cumulativeMetrics);
+    std::unique_ptr<ReshardingMetrics> createInstanceMetrics() {
+        return std::make_unique<ReshardingMetrics>(UUID::gen(),
+                                                   kTestCommand,
+                                                   kTestNamespace,
+                                                   ReshardingMetrics::Role::kRecipient,
+                                                   getClockSource()->now(),
+                                                   getClockSource(),
+                                                   &_cumulativeMetrics);
     }
 };
 
diff --git a/src/mongo/db/s/resharding/resharding_oplog_applier_test.cpp b/src/mongo/db/s/resharding/resharding_oplog_applier_test.cpp
index 0e3f5a87504..f3171d09254 100644
--- a/src/mongo/db/s/resharding/resharding_oplog_applier_test.cpp
+++ b/src/mongo/db/s/resharding/resharding_oplog_applier_test.cpp
@@ -158,13 +158,12 @@ public:
 
         _cm = createChunkManagerForOriginalColl();
 
-        _metrics =
-            ReshardingMetricsNew::makeInstance(kCrudUUID,
-                                               BSON("y" << 1),
-                                               kCrudNs,
-                                               ReshardingMetricsNew::Role::kRecipient,
-                                               getServiceContext()->getFastClockSource()->now(),
-                                               getServiceContext());
+        _metrics = ReshardingMetrics::makeInstance(kCrudUUID,
+                                                   BSON("y" << 1),
+                                                   kCrudNs,
+                                                   ReshardingMetrics::Role::kRecipient,
+                                                   getServiceContext()->getFastClockSource()->now(),
+                                                   getServiceContext());
         _applierMetrics =
             std::make_unique<ReshardingOplogApplierMetrics>(_metrics.get(), boost::none);
 
@@ -363,7 +362,7 @@ protected:
     boost::optional<ChunkManager> _cm;
 
     const ReshardingSourceId _sourceId{UUID::gen(), kMyShardId};
-    std::unique_ptr<ReshardingMetricsNew> _metrics;
+    std::unique_ptr<ReshardingMetrics> _metrics;
     std::unique_ptr<ReshardingOplogApplierMetrics> _applierMetrics;
 
     std::shared_ptr<executor::ThreadPoolTaskExecutor> _executor;
diff --git a/src/mongo/db/s/resharding/resharding_oplog_batch_applier_test.cpp b/src/mongo/db/s/resharding/resharding_oplog_batch_applier_test.cpp
index f8af8d80998..5ee0720d57b 100644
--- a/src/mongo/db/s/resharding/resharding_oplog_batch_applier_test.cpp
+++ b/src/mongo/db/s/resharding/resharding_oplog_batch_applier_test.cpp
@@ -46,7 +46,7 @@
 #include "mongo/db/repl/storage_interface_impl.h"
 #include "mongo/db/s/op_observer_sharding_impl.h"
 #include "mongo/db/s/resharding/resharding_data_copy_util.h"
-#include "mongo/db/s/resharding/resharding_metrics_new.h"
+#include "mongo/db/s/resharding/resharding_metrics.h"
 #include "mongo/db/s/resharding/resharding_oplog_application.h"
 #include "mongo/db/s/resharding/resharding_oplog_batch_applier.h"
 #include "mongo/db/s/resharding/resharding_oplog_session_application.h"
@@ -111,15 +111,15 @@ public:
                     opCtx.get(), nss, CollectionOptions{});
             }
 
-            _metricsNew =
-                ReshardingMetricsNew::makeInstance(UUID::gen(),
-                                                   BSON("y" << 1),
-                                                   _outputNss,
-                                                   ShardingDataTransformMetrics::Role::kRecipient,
-                                                   serviceContext->getFastClockSource()->now(),
-                                                   serviceContext);
+            _metrics =
+                ReshardingMetrics::makeInstance(UUID::gen(),
+                                                BSON("y" << 1),
+                                                _outputNss,
+                                                ShardingDataTransformMetrics::Role::kRecipient,
+                                                serviceContext->getFastClockSource()->now(),
+                                                serviceContext);
             _applierMetrics =
-                std::make_unique<ReshardingOplogApplierMetrics>(_metricsNew.get(), boost::none);
+                std::make_unique<ReshardingOplogApplierMetrics>(_metrics.get(), boost::none);
             _crudApplication = std::make_unique<ReshardingOplogApplicationRules>(
                 _outputNss,
                 std::vector<NamespaceString>{_myStashNss, _otherStashNss},
@@ -362,7 +362,7 @@ private:
         getLocalConflictStashNamespace(_sourceUUID, _otherDonorId);
     const NamespaceString _myOplogBufferNss = getLocalOplogBufferNamespace(_sourceUUID, _myDonorId);
 
-    std::unique_ptr<ReshardingMetricsNew> _metricsNew;
+    std::unique_ptr<ReshardingMetrics> _metrics;
     std::unique_ptr<ReshardingOplogApplierMetrics> _applierMetrics;
 
     std::unique_ptr<ReshardingOplogApplicationRules> _crudApplication;
diff --git a/src/mongo/db/s/resharding/resharding_oplog_crud_application_test.cpp b/src/mongo/db/s/resharding/resharding_oplog_crud_application_test.cpp
index 4114100a5bc..fa3c7804902 100644
--- a/src/mongo/db/s/resharding/resharding_oplog_crud_application_test.cpp
+++ b/src/mongo/db/s/resharding/resharding_oplog_crud_application_test.cpp
@@ -47,7 +47,7 @@
 #include "mongo/db/s/collection_sharding_runtime.h"
 #include "mongo/db/s/op_observer_sharding_impl.h"
 #include "mongo/db/s/resharding/resharding_data_copy_util.h"
-#include "mongo/db/s/resharding/resharding_metrics_new.h"
+#include "mongo/db/s/resharding/resharding_metrics.h"
 #include "mongo/db/s/resharding/resharding_oplog_application.h"
 #include "mongo/db/s/resharding/resharding_util.h"
 #include "mongo/db/s/sharding_state.h"
@@ -112,15 +112,15 @@ public:
                         CollectionMetadata(makeChunkManagerForOutputCollection(), _myDonorId));
             }
 
-            _metricsNew =
-                ReshardingMetricsNew::makeInstance(_sourceUUID,
-                                                   BSON(_newShardKey << 1),
-                                                   _outputNss,
-                                                   ShardingDataTransformMetrics::Role::kRecipient,
-                                                   serviceContext->getFastClockSource()->now(),
-                                                   serviceContext);
+            _metrics =
+                ReshardingMetrics::makeInstance(_sourceUUID,
+                                                BSON(_newShardKey << 1),
+                                                _outputNss,
+                                                ShardingDataTransformMetrics::Role::kRecipient,
+                                                serviceContext->getFastClockSource()->now(),
+                                                serviceContext);
             _oplogApplierMetrics =
-                std::make_unique<ReshardingOplogApplierMetrics>(_metricsNew.get(), boost::none);
+                std::make_unique<ReshardingOplogApplierMetrics>(_metrics.get(), boost::none);
             _applier = std::make_unique<ReshardingOplogApplicationRules>(
                 _outputNss,
                 std::vector<NamespaceString>{_myStashNss, _otherStashNss},
@@ -341,7 +341,7 @@ private:
         getLocalConflictStashNamespace(_sourceUUID, _otherDonorId);
 
     std::unique_ptr<ReshardingOplogApplicationRules> _applier;
-    std::unique_ptr<ReshardingMetricsNew> _metricsNew;
+    std::unique_ptr<ReshardingMetrics> _metrics;
     std::unique_ptr<ReshardingOplogApplierMetrics> _oplogApplierMetrics;
 };
 
diff --git a/src/mongo/db/s/resharding/resharding_oplog_fetcher.cpp b/src/mongo/db/s/resharding/resharding_oplog_fetcher.cpp
index 41f87420e70..40f51e56e60 100644
--- a/src/mongo/db/s/resharding/resharding_oplog_fetcher.cpp
+++ b/src/mongo/db/s/resharding/resharding_oplog_fetcher.cpp
@@ -45,7 +45,7 @@
 #include "mongo/db/pipeline/aggregate_command_gen.h"
 #include "mongo/db/repl/read_concern_args.h"
 #include "mongo/db/repl/read_concern_level.h"
-#include "mongo/db/s/resharding/resharding_metrics_new.h"
+#include "mongo/db/s/resharding/resharding_metrics.h"
 #include "mongo/db/s/resharding/resharding_util.h"
 #include "mongo/db/s/sharding_data_transform_cumulative_metrics.h"
 #include "mongo/db/storage/write_unit_of_work.h"
@@ -326,8 +326,8 @@ bool ReshardingOplogFetcher::consume(Client* client,
         [this, &batchesProcessed, &moreToCome, &opCtxRaii, &batchFetchTimer, factory](
             const std::vector<BSONObj>& batch,
             const boost::optional<BSONObj>& postBatchResumeToken) {
-            _env->metricsNew()->onOplogEntriesFetched(batch.size(),
-                                                      Milliseconds(batchFetchTimer.millis()));
+            _env->metrics()->onOplogEntriesFetched(batch.size(),
+                                                   Milliseconds(batchFetchTimer.millis()));
 
             ThreadClient client(fmt::format("ReshardingFetcher-{}-{}",
                                             _reshardingUUID.toString(),
@@ -354,7 +354,7 @@ bool ReshardingOplogFetcher::consume(Client* client,
                 uassertStatusOK(toWriteTo->insertDocument(opCtx, InsertStatement{doc}, nullptr));
                 wuow.commit();
 
-                _env->metricsNew()->onLocalInsertDuringOplogFetching(
+                _env->metrics()->onLocalInsertDuringOplogFetching(
                     Milliseconds(insertTimer.millis()));
 
                 ++_numOplogEntriesCopied;
@@ -402,7 +402,7 @@ bool ReshardingOplogFetcher::consume(Client* client,
 
                     // Also include synthetic oplog in the fetched count so it can match up with the
                     // total oplog applied count in the end.
-                    _env->metricsNew()->onOplogEntriesFetched(1, Milliseconds(0));
+                    _env->metrics()->onOplogEntriesFetched(1, Milliseconds(0));
 
                     auto [p, f] = makePromiseFuture<void>();
                     {
diff --git a/src/mongo/db/s/resharding/resharding_oplog_fetcher.h b/src/mongo/db/s/resharding/resharding_oplog_fetcher.h
index 5772c6bdfaa..37f5090f0e2 100644
--- a/src/mongo/db/s/resharding/resharding_oplog_fetcher.h
+++ b/src/mongo/db/s/resharding/resharding_oplog_fetcher.h
@@ -50,25 +50,25 @@
 
 namespace mongo {
 
-class ReshardingMetricsNew;
+class ReshardingMetrics;
 
 class ReshardingOplogFetcher : public resharding::OnInsertAwaitable {
 public:
     class Env {
     public:
-        Env(ServiceContext* service, ReshardingMetricsNew* metricsNew)
-            : _service(service), _metricsNew(metricsNew) {}
+        Env(ServiceContext* service, ReshardingMetrics* metrics)
+            : _service(service), _metrics(metrics) {}
         ServiceContext* service() const {
             return _service;
         }
 
-        ReshardingMetricsNew* metricsNew() const {
-            return _metricsNew;
+        ReshardingMetrics* metrics() const {
+            return _metrics;
         }
 
     private:
         ServiceContext* _service;
-        ReshardingMetricsNew* _metricsNew;
+        ReshardingMetrics* _metrics;
     };
 
     // Special value to use for startAt to indicate there are no more oplog entries needing to be
diff --git a/src/mongo/db/s/resharding/resharding_oplog_fetcher_test.cpp b/src/mongo/db/s/resharding/resharding_oplog_fetcher_test.cpp
index 17624acced9..dc6f82ad701 100644
--- a/src/mongo/db/s/resharding/resharding_oplog_fetcher_test.cpp
+++ b/src/mongo/db/s/resharding/resharding_oplog_fetcher_test.cpp
@@ -45,7 +45,7 @@
 #include "mongo/db/repl/storage_interface_impl.h"
 #include "mongo/db/repl/wait_for_majority_service.h"
 #include "mongo/db/s/operation_sharding_state.h"
-#include "mongo/db/s/resharding/resharding_metrics_new.h"
+#include "mongo/db/s/resharding/resharding_metrics.h"
 #include "mongo/db/s/resharding/resharding_oplog_fetcher.h"
 #include "mongo/db/s/resharding/resharding_util.h"
 #include "mongo/db/s/shard_server_test_fixture.h"
@@ -98,13 +98,12 @@ public:
             OldClientContext ctx(_opCtx, NamespaceString::kRsOplogNamespace.ns());
         }
 
-        _metrics =
-            ReshardingMetricsNew::makeInstance(_reshardingUUID,
-                                               BSON("y" << 1),
-                                               NamespaceString{""},
-                                               ReshardingMetricsNew::Role::kRecipient,
-                                               getServiceContext()->getFastClockSource()->now(),
-                                               getServiceContext());
+        _metrics = ReshardingMetrics::makeInstance(_reshardingUUID,
+                                                   BSON("y" << 1),
+                                                   NamespaceString{""},
+                                                   ReshardingMetrics::Role::kRecipient,
+                                                   getServiceContext()->getFastClockSource()->now(),
+                                                   getServiceContext());
 
         for (const auto& shardId : kTwoShardIdList) {
             auto shardTargeter = RemoteCommandTargeterMock::get(
@@ -343,7 +342,7 @@ protected:
     Timestamp _fetchTimestamp;
     ShardId _donorShard;
     ShardId _destinationShard;
-    std::unique_ptr<ReshardingMetricsNew> _metrics;
+    std::unique_ptr<ReshardingMetrics> _metrics;
 
 private:
     static HostAndPort makeHostAndPort(const ShardId& shardId) {
diff --git a/src/mongo/db/s/resharding/resharding_recipient_service.cpp b/src/mongo/db/s/resharding/resharding_recipient_service.cpp
index baaf64fc5e3..f3dbeca4811 100644
--- a/src/mongo/db/s/resharding/resharding_recipient_service.cpp
+++ b/src/mongo/db/s/resharding/resharding_recipient_service.cpp
@@ -120,12 +120,12 @@ using resharding_metrics::getIntervalStartFieldName;
 using DocT = ReshardingRecipientDocument;
 const auto metricsPrefix = resharding_metrics::getMetricsPrefix<DocT>();
 
-void buildStateDocumentCloneMetricsForUpdate(BSONObjBuilder& bob, ReshardingMetricsNew* metrics) {
+void buildStateDocumentCloneMetricsForUpdate(BSONObjBuilder& bob, ReshardingMetrics* metrics) {
     bob.append(getIntervalStartFieldName<DocT>(ReshardingRecipientMetrics::kDocumentCopyFieldName),
                metrics->getCopyingBegin());
 }
 
-void buildStateDocumentApplyMetricsForUpdate(BSONObjBuilder& bob, ReshardingMetricsNew* metrics) {
+void buildStateDocumentApplyMetricsForUpdate(BSONObjBuilder& bob, ReshardingMetrics* metrics) {
     bob.append(getIntervalEndFieldName<DocT>(ReshardingRecipientMetrics::kDocumentCopyFieldName),
                metrics->getCopyingEnd());
     bob.append(
@@ -138,14 +138,14 @@ void buildStateDocumentApplyMetricsForUpdate(BSONObjBuilder& bob, ReshardingMetr
 }
 
 void buildStateDocumentStrictConsistencyMetricsForUpdate(BSONObjBuilder& bob,
-                                                         ReshardingMetricsNew* metrics) {
+                                                         ReshardingMetrics* metrics) {
     bob.append(
         getIntervalEndFieldName<DocT>(ReshardingRecipientMetrics::kOplogApplicationFieldName),
         metrics->getApplyingEnd());
 }
 
 void buildStateDocumentMetricsForUpdate(BSONObjBuilder& bob,
-                                        ReshardingMetricsNew* metrics,
+                                        ReshardingMetrics* metrics,
                                         RecipientStateEnum newState) {
     switch (newState) {
         case RecipientStateEnum::kCloning:
@@ -162,8 +162,8 @@ void buildStateDocumentMetricsForUpdate(BSONObjBuilder& bob,
     }
 }
 
-ReshardingMetricsNew::RecipientState toMetricsState(RecipientStateEnum state) {
-    return ReshardingMetricsNew::RecipientState(state);
+ReshardingMetrics::RecipientState toMetricsState(RecipientStateEnum state) {
+    return ReshardingMetrics::RecipientState(state);
 }
 
 }  // namespace
@@ -190,7 +190,7 @@ ReshardingRecipientService::RecipientStateMachine::RecipientStateMachine(
     ReshardingDataReplicationFactory dataReplicationFactory)
     : repl::PrimaryOnlyService::TypedInstance<RecipientStateMachine>(),
       _recipientService{recipientService},
-      _metricsNew{ReshardingMetricsNew::initializeFrom(recipientDoc, getGlobalServiceContext())},
+      _metrics{ReshardingMetrics::initializeFrom(recipientDoc, getGlobalServiceContext())},
       _metadata{recipientDoc.getCommonReshardingMetadata()},
       _minimumOperationDuration{Milliseconds{recipientDoc.getMinimumOperationDurationMillis()}},
       _recipientCtx{recipientDoc.getMutableState()},
@@ -219,7 +219,7 @@ ReshardingRecipientService::RecipientStateMachine::RecipientStateMachine(
       }()) {
     invariant(_externalState);
 
-    _metricsNew->onStateTransition(boost::none, toMetricsState(_recipientCtx.getState()));
+    _metrics->onStateTransition(boost::none, toMetricsState(_recipientCtx.getState()));
 }
 
 ExecutorFuture<void>
@@ -417,7 +417,7 @@ ExecutorFuture<void> ReshardingRecipientService::RecipientStateMachine::_runMand
                        self = shared_from_this(),
                        outerStatus = status,
                        isCanceled = stepdownToken.isCanceled()](Status dataReplicationHaltStatus) {
-            _metricsNew->onStateTransition(toMetricsState(_recipientCtx.getState()), boost::none);
+            _metrics->onStateTransition(toMetricsState(_recipientCtx.getState()), boost::none);
 
             // If the stepdownToken was triggered, it takes priority in order to make sure that
             // the promise is set with an error that the coordinator can retry with. If it ran into
@@ -504,7 +504,7 @@ void ReshardingRecipientService::RecipientStateMachine::interrupt(Status status)
 boost::optional<BSONObj> ReshardingRecipientService::RecipientStateMachine::reportForCurrentOp(
     MongoProcessInterface::CurrentOpConnectionsMode,
     MongoProcessInterface::CurrentOpSessionsMode) noexcept {
-    return _metricsNew->reportForCurrentOp();
+    return _metrics->reportForCurrentOp();
 }
 
 void ReshardingRecipientService::RecipientStateMachine::onReshardingFieldsChanges(
@@ -550,8 +550,8 @@ ExecutorFuture<void> ReshardingRecipientService::RecipientStateMachine::
                   ReshardingRecipientService::RecipientStateMachine::CloneDetails cloneDetails) {
             _transitionToCreatingCollection(
                 cloneDetails, (*executor)->now() + _minimumOperationDuration, factory);
-            _metricsNew->setDocumentsToCopyCounts(cloneDetails.approxDocumentsToCopy,
-                                                  cloneDetails.approxBytesToCopy);
+            _metrics->setDocumentsToCopyCounts(cloneDetails.approxDocumentsToCopy,
+                                               cloneDetails.approxBytesToCopy);
         });
 }
 
@@ -616,7 +616,7 @@ ReshardingRecipientService::RecipientStateMachine::_makeDataReplication(Operatio
         for (const auto& donor : _donorShards) {
             _applierMetricsMap.emplace(
                 donor.getShardId(),
-                std::make_unique<ReshardingOplogApplierMetrics>(_metricsNew.get(), boost::none));
+                std::make_unique<ReshardingOplogApplierMetrics>(_metrics.get(), boost::none));
         }
     } else {
         invariant(_applierMetricsMap.size() == _donorShards.size(),
@@ -625,7 +625,7 @@ ReshardingRecipientService::RecipientStateMachine::_makeDataReplication(Operatio
     }
 
     return _dataReplicationFactory(opCtx,
-                                   _metricsNew.get(),
+                                   _metrics.get(),
                                    &_applierMetricsMap,
                                    _metadata,
                                    _donorShards,
@@ -846,7 +846,7 @@ void ReshardingRecipientService::RecipientStateMachine::_transitionState(
     _updateRecipientDocument(
         std::move(newRecipientCtx), std::move(cloneDetails), std::move(configStartTime), factory);
 
-    _metricsNew->onStateTransition(toMetricsState(oldState), toMetricsState(newState));
+    _metrics->onStateTransition(toMetricsState(oldState), toMetricsState(newState));
 
     LOGV2_INFO(5279506,
                "Transitioned resharding recipient state",
@@ -871,7 +871,7 @@ void ReshardingRecipientService::RecipientStateMachine::_transitionToCreatingCol
 
 void ReshardingRecipientService::RecipientStateMachine::_transitionToCloning(
     const CancelableOperationContextFactory& factory) {
-    _metricsNew->onCopyingBegin();
+    _metrics->onCopyingBegin();
     auto newRecipientCtx = _recipientCtx;
     newRecipientCtx.setState(RecipientStateEnum::kCloning);
     _transitionState(std::move(newRecipientCtx), boost::none, boost::none, factory);
@@ -883,8 +883,8 @@ void ReshardingRecipientService::RecipientStateMachine::_transitionToApplying(
     newRecipientCtx.setState(RecipientStateEnum::kApplying);
     _transitionState(std::move(newRecipientCtx), boost::none, boost::none, factory);
 
-    _metricsNew->onCopyingEnd();
-    _metricsNew->onApplyingBegin();
+    _metrics->onCopyingEnd();
+    _metrics->onApplyingBegin();
 }
 
 void ReshardingRecipientService::RecipientStateMachine::_transitionToStrictConsistency(
@@ -893,7 +893,7 @@ void ReshardingRecipientService::RecipientStateMachine::_transitionToStrictConsi
     newRecipientCtx.setState(RecipientStateEnum::kStrictConsistency);
     _transitionState(std::move(newRecipientCtx), boost::none, boost::none, factory);
 
-    _metricsNew->onApplyingEnd();
+    _metrics->onApplyingEnd();
 }
 
 void ReshardingRecipientService::RecipientStateMachine::_transitionToError(
@@ -1052,8 +1052,7 @@ void ReshardingRecipientService::RecipientStateMachine::_updateRecipientDocument
                               *configStartTime);
         }
 
-        buildStateDocumentMetricsForUpdate(
-            setBuilder, _metricsNew.get(), newRecipientCtx.getState());
+        buildStateDocumentMetricsForUpdate(setBuilder, _metrics.get(), newRecipientCtx.getState());
 
         setBuilder.doneFast();
     }
@@ -1156,7 +1155,7 @@ void ReshardingRecipientService::RecipientStateMachine::_restoreMetrics(
             // metrics section of the recipient state document and restored during metrics
             // initialization. This is so that applied oplog entries that add or remove documents do
             // not affect the cloning metrics.
-            _metricsNew->restoreDocumentsCopied(documentCountCopied, documentBytesCopied);
+            _metrics->restoreDocumentsCopied(documentCountCopied, documentBytesCopied);
         }
     }
 
@@ -1208,19 +1207,19 @@ void ReshardingRecipientService::RecipientStateMachine::_restoreMetrics(
         if (!progressDoc) {
             _applierMetricsMap.emplace(
                 shardId,
-                std::make_unique<ReshardingOplogApplierMetrics>(_metricsNew.get(), boost::none));
+                std::make_unique<ReshardingOplogApplierMetrics>(_metrics.get(), boost::none));
             continue;
         }
 
-        _metricsNew->accumulateFrom(*progressDoc);
+        _metrics->accumulateFrom(*progressDoc);
 
         auto applierMetrics =
-            std::make_unique<ReshardingOplogApplierMetrics>(_metricsNew.get(), progressDoc);
+            std::make_unique<ReshardingOplogApplierMetrics>(_metrics.get(), progressDoc);
         _applierMetricsMap.emplace(shardId, std::move(applierMetrics));
     }
 
-    _metricsNew->restoreOplogEntriesFetched(oplogEntriesFetched);
-    _metricsNew->restoreOplogEntriesApplied(oplogEntriesApplied);
+    _metrics->restoreOplogEntriesFetched(oplogEntriesFetched);
+    _metrics->restoreOplogEntriesApplied(oplogEntriesApplied);
 }
 
 CancellationToken ReshardingRecipientService::RecipientStateMachine::_initAbortSource(
diff --git a/src/mongo/db/s/resharding/resharding_recipient_service.h b/src/mongo/db/s/resharding/resharding_recipient_service.h
index fc41ba0e9ee..5dab490b96f 100644
--- a/src/mongo/db/s/resharding/resharding_recipient_service.h
+++ b/src/mongo/db/s/resharding/resharding_recipient_service.h
@@ -33,7 +33,7 @@
 #include "mongo/db/s/resharding/recipient_document_gen.h"
 #include "mongo/db/s/resharding/resharding_data_replication.h"
 #include "mongo/db/s/resharding/resharding_future_util.h"
-#include "mongo/db/s/resharding/resharding_metrics_new.h"
+#include "mongo/db/s/resharding/resharding_metrics.h"
 #include "mongo/db/s/resharding/resharding_oplog_applier_metrics.h"
 #include "mongo/db/s/resharding/resharding_util.h"
 #include "mongo/s/resharding/type_collection_fields_gen.h"
@@ -163,9 +163,9 @@ public:
         return _metadata;
     }
 
-    inline const ReshardingMetricsNew& getMetrics() const {
-        invariant(_metricsNew);
-        return *_metricsNew;
+    inline const ReshardingMetrics& getMetrics() const {
+        invariant(_metrics);
+        return *_metrics;
     }
 
     boost::optional<BSONObj> reportForCurrentOp(
@@ -289,7 +289,7 @@ private:
     // The primary-only service instance corresponding to the recipient instance. Not owned.
     const ReshardingRecipientService* const _recipientService;
 
-    std::unique_ptr<ReshardingMetricsNew> _metricsNew;
+    std::unique_ptr<ReshardingMetrics> _metrics;
     ReshardingApplierMetricsMap _applierMetricsMap;
 
     // The in-memory representation of the immutable portion of the document in
diff --git a/src/mongo/db/s/resharding/resharding_util.cpp b/src/mongo/db/s/resharding/resharding_util.cpp
index d9a04064d3c..4febc199126 100644
--- a/src/mongo/db/s/resharding/resharding_util.cpp
+++ b/src/mongo/db/s/resharding/resharding_util.cpp
@@ -48,7 +48,7 @@
 #include "mongo/db/s/collection_sharding_state.h"
 #include "mongo/db/s/resharding/document_source_resharding_add_resume_id.h"
 #include "mongo/db/s/resharding/document_source_resharding_iterate_transaction.h"
-#include "mongo/db/s/resharding/resharding_metrics_new.h"
+#include "mongo/db/s/resharding/resharding_metrics.h"
 #include "mongo/db/s/sharding_state.h"
 #include "mongo/db/storage/write_unit_of_work.h"
 #include "mongo/logv2/log.h"