SERVER-65987 ServerStatusMetric API refresh

46 files changed, 476 insertions, 604 deletions

diff --git a/src/mongo/db/SConscript b/src/mongo/db/SConscript
index 079f19712f1..f26cf836af2 100644
--- a/src/mongo/db/SConscript
+++ b/src/mongo/db/SConscript
@@ -2685,6 +2685,7 @@ if wiredtiger:
             'logical_session_cache_test.cpp',
             'logical_session_id_test.cpp',
             'logical_time_test.cpp',
+            'metric_tree_test.cpp',
             'mirroring_sampler_test.cpp',
             'multi_key_path_tracker_test.cpp',
             'namespace_string_test.cpp',
diff --git a/src/mongo/db/clientcursor.cpp b/src/mongo/db/clientcursor.cpp
index 9c1be7e4fc2..f0082b28b0c 100644
--- a/src/mongo/db/clientcursor.cpp
+++ b/src/mongo/db/clientcursor.cpp
@@ -27,15 +27,12 @@
  *    it in the license file.
  */
 
-#include "mongo/platform/basic.h"
-
 #include "mongo/db/clientcursor.h"
 
 #include <string>
 #include <time.h>
 #include <vector>
 
-#include "mongo/base/counter.h"
 #include "mongo/db/audit.h"
 #include "mongo/db/auth/action_set.h"
 #include "mongo/db/auth/action_type.h"
@@ -62,24 +59,12 @@ namespace mongo {
 using std::string;
 using std::stringstream;
 
-static Counter64 cursorStatsOpen;           // gauge
-static Counter64 cursorStatsOpenPinned;     // gauge
-static Counter64 cursorStatsOpenNoTimeout;  // gauge
-static Counter64 cursorStatsTimedOut;
-static Counter64 cursorStatsTotalOpened;
-static Counter64 cursorStatsMoreThanOneBatch;
-
-static ServerStatusMetricField<Counter64> dCursorStatsOpen("cursor.open.total", &cursorStatsOpen);
-static ServerStatusMetricField<Counter64> dCursorStatsOpenPinned("cursor.open.pinned",
-                                                                 &cursorStatsOpenPinned);
-static ServerStatusMetricField<Counter64> dCursorStatsOpenNoTimeout("cursor.open.noTimeout",
-                                                                    &cursorStatsOpenNoTimeout);
-static ServerStatusMetricField<Counter64> dCursorStatusTimedout("cursor.timedOut",
-                                                                &cursorStatsTimedOut);
-static ServerStatusMetricField<Counter64> dCursorStatsTotalOpened("cursor.totalOpened",
-                                                                  &cursorStatsTotalOpened);
-static ServerStatusMetricField<Counter64> dCursorStatsMoreThanOneBatch(
-    "cursor.moreThanOneBatch", &cursorStatsMoreThanOneBatch);
+static CounterMetric cursorStatsOpen{"cursor.open.total"};
+static CounterMetric cursorStatsOpenPinned{"cursor.open.pinned"};
+static CounterMetric cursorStatsOpenNoTimeout{"cursor.open.noTimeout"};
+static CounterMetric cursorStatsTimedOut{"cursor.timedOut"};
+static CounterMetric cursorStatsTotalOpened{"cursor.totalOpened"};
+static CounterMetric cursorStatsMoreThanOneBatch{"cursor.moreThanOneBatch"};
 
 ClientCursor::ClientCursor(ClientCursorParams params,
                            CursorId cursorId,
diff --git a/src/mongo/db/collection_index_usage_tracker.cpp b/src/mongo/db/collection_index_usage_tracker.cpp
index a02f04cd89d..f0fc7873732 100644
--- a/src/mongo/db/collection_index_usage_tracker.cpp
+++ b/src/mongo/db/collection_index_usage_tracker.cpp
@@ -28,13 +28,10 @@
  */
 
 
-#include "mongo/platform/basic.h"
-
 #include "mongo/db/collection_index_usage_tracker.h"
 
 #include <atomic>
 
-#include "mongo/base/counter.h"
 #include "mongo/db/commands/server_status_metric.h"
 #include "mongo/db/index/index_descriptor.h"
 #include "mongo/util/assert_util.h"
@@ -45,14 +42,8 @@
 
 namespace mongo {
 namespace {
-Counter64 collectionScansCounter;
-Counter64 collectionScansNonTailableCounter;
-
-ServerStatusMetricField<Counter64> displayCollectionScans("queryExecutor.collectionScans.total",
-                                                          &collectionScansCounter);
-ServerStatusMetricField<Counter64> displayCollectionScansNonTailable(
-    "queryExecutor.collectionScans.nonTailable", &collectionScansNonTailableCounter);
-
+CounterMetric collectionScansCounter("queryExecutor.collectionScans.total");
+CounterMetric collectionScansNonTailableCounter("queryExecutor.collectionScans.nonTailable");
 }  // namespace
 
 CollectionIndexUsageTracker::CollectionIndexUsageTracker(
diff --git a/src/mongo/db/commands.cpp b/src/mongo/db/commands.cpp
index 6ebe905b732..988e3db8831 100644
--- a/src/mongo/db/commands.cpp
+++ b/src/mongo/db/commands.cpp
@@ -28,8 +28,6 @@
  */
 
 
-#include "mongo/platform/basic.h"
-
 #include "mongo/db/commands.h"
 
 #include <string>
@@ -976,8 +974,8 @@ std::unique_ptr<CommandInvocation> BasicCommandWithReplyBuilderInterface::parse(
 Command::Command(StringData name, std::vector<StringData> aliases)
     : _name(name.toString()),
       _aliases(std::move(aliases)),
-      _commandsExecutedMetric("commands." + _name + ".total", &_commandsExecuted),
-      _commandsFailedMetric("commands." + _name + ".failed", &_commandsFailed) {
+      _commandsExecuted("commands." + _name + ".total"),
+      _commandsFailed("commands." + _name + ".failed") {
     globalCommandRegistry()->registerCommand(this, _name, _aliases);
 }
 
diff --git a/src/mongo/db/commands.h b/src/mongo/db/commands.h
index 41d93c75a4c..15f80320e0f 100644
--- a/src/mongo/db/commands.h
+++ b/src/mongo/db/commands.h
@@ -35,7 +35,6 @@
 #include <string>
 #include <vector>
 
-#include "mongo/base/counter.h"
 #include "mongo/base/init.h"
 #include "mongo/base/status.h"
 #include "mongo/base/status_with.h"
@@ -640,11 +639,8 @@ private:
     const std::vector<StringData> _aliases;
 
     // Counters for how many times this command has been executed and failed
-    mutable Counter64 _commandsExecuted;
-    mutable Counter64 _commandsFailed;
-    // Pointers to hold the metrics tree references
-    ServerStatusMetricField<Counter64> _commandsExecutedMetric;
-    ServerStatusMetricField<Counter64> _commandsFailedMetric;
+    CounterMetric _commandsExecuted;
+    CounterMetric _commandsFailed;
 };
 
 /**
@@ -1339,8 +1335,7 @@ class CommandRegistry {
 public:
     using CommandMap = Command::CommandMap;
 
-    CommandRegistry() : _unknownsMetricField("commands.<UNKNOWN>", &_unknowns) {}
-
+    CommandRegistry() = default;
     CommandRegistry(const CommandRegistry&) = delete;
     CommandRegistry& operator=(const CommandRegistry&) = delete;
 
@@ -1357,9 +1352,7 @@ public:
     }
 
 private:
-    Counter64 _unknowns;
-    ServerStatusMetricField<Counter64> _unknownsMetricField;
-
+    CounterMetric _unknowns{"commands.<UNKNOWN>"};
     CommandMap _commands;
 };
 
diff --git a/src/mongo/db/commands/SConscript b/src/mongo/db/commands/SConscript
index 1d9f194a151..3db1399d5eb 100644
--- a/src/mongo/db/commands/SConscript
+++ b/src/mongo/db/commands/SConscript
@@ -22,7 +22,6 @@ env.Library(
     target='server_status_core',
     source=[
         'server_status.cpp',
-        'server_status_internal.cpp',
         'server_status_metric.cpp',
     ],
     LIBDEPS=[
diff --git a/src/mongo/db/commands/run_aggregate.cpp b/src/mongo/db/commands/run_aggregate.cpp
index ddbe5b2b0f1..13dd0243a7d 100644
--- a/src/mongo/db/commands/run_aggregate.cpp
+++ b/src/mongo/db/commands/run_aggregate.cpp
@@ -28,8 +28,6 @@
  */
 
 
-#include "mongo/platform/basic.h"
-
 #include "mongo/db/commands/run_aggregate.h"
 
 #include <boost/optional.hpp>
@@ -101,12 +99,9 @@ using std::string;
 using std::stringstream;
 using std::unique_ptr;
 
-Counter64 allowDiskUseFalseCounter;
+CounterMetric allowDiskUseFalseCounter("query.allowDiskUseFalse");
 
 namespace {
-ServerStatusMetricField<Counter64> allowDiskUseMetric{"query.allowDiskUseFalse",
-                                                      &allowDiskUseFalseCounter};
-
 /**
  * If a pipeline is empty (assuming that a $cursor stage hasn't been created yet), it could mean
  * that we were able to absorb all pipeline stages and pull them into a single PlanExecutor. So,
diff --git a/src/mongo/db/commands/run_aggregate.h b/src/mongo/db/commands/run_aggregate.h
index b61538fb93d..0bb86ac91b0 100644
--- a/src/mongo/db/commands/run_aggregate.h
+++ b/src/mongo/db/commands/run_aggregate.h
@@ -72,5 +72,5 @@ Status runAggregate(OperationContext* opCtx,
 /**
  * Tracks explicit use of allowDiskUse:false with find and aggregate commands.
  */
-extern Counter64 allowDiskUseFalseCounter;
+extern CounterMetric allowDiskUseFalseCounter;
 }  // namespace mongo
diff --git a/src/mongo/db/commands/server_status.cpp b/src/mongo/db/commands/server_status.cpp
index b7e6c5d3a24..584726a56e0 100644
--- a/src/mongo/db/commands/server_status.cpp
+++ b/src/mongo/db/commands/server_status.cpp
@@ -31,7 +31,6 @@
 
 #include "mongo/db/commands/server_status.h"
 
-#include "mongo/db/commands/server_status_internal.h"
 #include "mongo/db/service_context.h"
 #include "mongo/util/version.h"
 
diff --git a/src/mongo/db/commands/server_status_command.cpp b/src/mongo/db/commands/server_status_command.cpp
index dac1fe8c56f..eccd2c0174c 100644
--- a/src/mongo/db/commands/server_status_command.cpp
+++ b/src/mongo/db/commands/server_status_command.cpp
@@ -28,12 +28,9 @@
  */
 
 
-#include "mongo/platform/basic.h"
-
 #include "mongo/db/auth/authorization_session.h"
 #include "mongo/db/commands.h"
 #include "mongo/db/commands/server_status.h"
-#include "mongo/db/commands/server_status_internal.h"
 #include "mongo/db/service_context.h"
 #include "mongo/db/stats/counters.h"
 #include "mongo/logv2/log.h"
@@ -140,17 +137,13 @@ public:
         }
 
         // --- counters
-        bool includeMetricTree = MetricTree::theMetricTree != nullptr;
+        MetricTree* metricTree = globalMetricTree(/* create */ false);
         auto metricsEl = cmdObj["metrics"_sd];
-        if (metricsEl.type() && !metricsEl.trueValue())
-            includeMetricTree = false;
-
-        if (includeMetricTree) {
+        if (metricTree && (metricsEl.eoo() || metricsEl.trueValue())) {
             if (metricsEl.type() == BSONType::Object) {
-                MetricTree::theMetricTree->appendTo(BSON("metrics" << metricsEl.embeddedObject()),
-                                                    result);
+                metricTree->appendTo(BSON("metrics" << metricsEl.embeddedObject()), result);
             } else {
-                MetricTree::theMetricTree->appendTo(result);
+                metricTree->appendTo(result);
             }
         }
 
@@ -252,7 +245,8 @@ public:
 class MemBase : public ServerStatusMetric {
 public:
     MemBase() : ServerStatusMetric(".mem.bits") {}
-    virtual void appendAtLeaf(BSONObjBuilder& b) const {
+
+    void appendAtLeaf(BSONObjBuilder& b) const override {
         b.append("bits", sizeof(int*) == 4 ? 32 : 64);
 
         ProcessInfo p;
@@ -267,7 +261,9 @@ public:
             b.appendBool("supported", false);
         }
     }
-} memBase;
+};
+
+MemBase& memBase = addMetricToTree(std::make_unique<MemBase>());
 
 class HttpClientServerStatus : public ServerStatusSection {
 public:
diff --git a/src/mongo/db/commands/server_status_internal.cpp b/src/mongo/db/commands/server_status_internal.cpp
deleted file mode 100644
index 9b87187aaa6..00000000000
--- a/src/mongo/db/commands/server_status_internal.cpp
+++ /dev/null
@@ -1,132 +0,0 @@
-/**
- *    Copyright (C) 2018-present MongoDB, Inc.
- *
- *    This program is free software: you can redistribute it and/or modify
- *    it under the terms of the Server Side Public License, version 1,
- *    as published by MongoDB, Inc.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    Server Side Public License for more details.
- *
- *    You should have received a copy of the Server Side Public License
- *    along with this program. If not, see
- *    <http://www.mongodb.com/licensing/server-side-public-license>.
- *
- *    As a special exception, the copyright holders give permission to link the
- *    code of portions of this program with the OpenSSL library under certain
- *    conditions as described in each individual source file and distribute
- *    linked combinations including the program with the OpenSSL library. You
- *    must comply with the Server Side Public License in all respects for
- *    all of the code used other than as permitted herein. If you modify file(s)
- *    with this exception, you may extend this exception to your version of the
- *    file(s), but you are not obligated to do so. If you do not wish to do so,
- *    delete this exception statement from your version. If you delete this
- *    exception statement from all source files in the program, then also delete
- *    it in the license file.
- */
-
-#include "mongo/db/commands/server_status_internal.h"
-
-#include <iostream>
-
-#include "mongo/bson/bsontypes.h"
-#include "mongo/db/commands/server_status_metric.h"
-#include "mongo/util/str.h"
-
-namespace mongo {
-
-using std::cerr;
-using std::endl;
-using std::map;
-using std::string;
-
-MetricTree* MetricTree::theMetricTree = nullptr;
-
-void MetricTree::add(ServerStatusMetric* metric) {
-    string name = metric->getMetricName();
-    if (name[0] == '.')
-        _add(name.substr(1), metric);
-    else
-        _add(str::stream() << "metrics." << name, metric);
-}
-
-void MetricTree::_add(const string& path, ServerStatusMetric* metric) {
-    size_t idx = path.find(".");
-    if (idx == string::npos) {
-        if (_subtrees.count(path) > 0) {
-            cerr << "metric conflict on: " << path << endl;
-            fassertFailed(6483100);
-        }
-        if (_metrics.count(path) > 0) {
-            cerr << "duplicate metric: " << path << endl;
-            fassertFailed(6483101);
-        }
-        _metrics[path] = metric;
-        return;
-    }
-
-    string myLevel = path.substr(0, idx);
-    if (_metrics.count(myLevel) > 0) {
-        cerr << "metric conflict on: " << path << endl;
-        fassertFailed(16461);
-    }
-
-    MetricTree*& sub = _subtrees[myLevel];
-    if (!sub)
-        sub = new MetricTree();
-    sub->_add(path.substr(idx + 1), metric);
-}
-
-void MetricTree::appendTo(BSONObjBuilder& b) const {
-    for (const auto& i : _metrics) {
-        i.second->appendAtLeaf(b);
-    }
-
-    for (const auto& i : _subtrees) {
-        BSONObjBuilder bb(b.subobjStart(i.first));
-        i.second->appendTo(bb);
-        bb.done();
-    }
-}
-
-void MetricTree::appendTo(const BSONObj& excludePaths, BSONObjBuilder& b) const {
-    auto fieldNamesInExclude = excludePaths.getFieldNames<stdx::unordered_set<std::string>>();
-    for (const auto& i : _metrics) {
-        auto key = i.first;
-        auto el = fieldNamesInExclude.contains(key) ? excludePaths.getField(key) : BSONElement();
-        if (el) {
-            uassert(ErrorCodes::InvalidBSONType,
-                    "Exclusion value for a leaf must be a boolean.",
-                    el.type() == Bool);
-            if (el.boolean() == false) {
-                continue;
-            }
-        }
-        i.second->appendAtLeaf(b);
-    }
-
-    for (const auto& i : _subtrees) {
-        auto key = i.first;
-        auto el = fieldNamesInExclude.contains(key) ? excludePaths.getField(key) : BSONElement();
-        if (el) {
-            uassert(ErrorCodes::InvalidBSONType,
-                    "Exclusion value must be a boolean or a nested object.",
-                    el.type() == Bool || el.type() == Object);
-            if (el.isBoolean() && el.boolean() == false) {
-                continue;
-            }
-        }
-
-        BSONObjBuilder bb(b.subobjStart(key));
-        if (el.type() == Object) {
-            i.second->appendTo(el.embeddedObject(), bb);
-        } else {
-            i.second->appendTo(bb);
-        }
-        bb.done();
-    }
-}
-
-}  // namespace mongo
diff --git a/src/mongo/db/commands/server_status_internal.h b/src/mongo/db/commands/server_status_internal.h
deleted file mode 100644
index b59b0b36762..00000000000
--- a/src/mongo/db/commands/server_status_internal.h
+++ /dev/null
@@ -1,64 +0,0 @@
-/**
- *    Copyright (C) 2018-present MongoDB, Inc.
- *
- *    This program is free software: you can redistribute it and/or modify
- *    it under the terms of the Server Side Public License, version 1,
- *    as published by MongoDB, Inc.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    Server Side Public License for more details.
- *
- *    You should have received a copy of the Server Side Public License
- *    along with this program. If not, see
- *    <http://www.mongodb.com/licensing/server-side-public-license>.
- *
- *    As a special exception, the copyright holders give permission to link the
- *    code of portions of this program with the OpenSSL library under certain
- *    conditions as described in each individual source file and distribute
- *    linked combinations including the program with the OpenSSL library. You
- *    must comply with the Server Side Public License in all respects for
- *    all of the code used other than as permitted herein. If you modify file(s)
- *    with this exception, you may extend this exception to your version of the
- *    file(s), but you are not obligated to do so. If you do not wish to do so,
- *    delete this exception statement from your version. If you delete this
- *    exception statement from all source files in the program, then also delete
- *    it in the license file.
- */
-
-#pragma once
-
-#include <map>
-#include <string>
-
-#include "mongo/db/jsobj.h"
-
-namespace mongo {
-
-class ServerStatusMetric;
-
-class MetricTree {
-public:
-    void add(ServerStatusMetric* metric);
-
-    /**
-     * Append the metrics tree to the given BSON builder.
-     */
-    void appendTo(BSONObjBuilder& b) const;
-
-    /**
-     * Implementation of appendTo which allows tree of exclude paths. The alternative overload is
-     * preferred to avoid overhead when no excludes are present.
-     */
-    void appendTo(const BSONObj& excludePaths, BSONObjBuilder& b) const;
-
-    static MetricTree* theMetricTree;
-
-private:
-    void _add(const std::string& path, ServerStatusMetric* metric);
-
-    std::map<std::string, MetricTree*> _subtrees;
-    std::map<std::string, ServerStatusMetric*> _metrics;
-};
-}  // namespace mongo
diff --git a/src/mongo/db/commands/server_status_metric.cpp b/src/mongo/db/commands/server_status_metric.cpp
index 9cac3b3ecd4..347b514b45d 100644
--- a/src/mongo/db/commands/server_status_metric.cpp
+++ b/src/mongo/db/commands/server_status_metric.cpp
@@ -29,24 +29,122 @@
 
 #include "mongo/db/commands/server_status_metric.h"
 
-#include "mongo/db/commands/server_status_internal.h"
+#include <fmt/format.h>
+
+#include "mongo/bson/bsontypes.h"
+#include "mongo/logv2/log.h"
+#include "mongo/util/str.h"
+
+#define MONGO_LOGV2_DEFAULT_COMPONENT ::mongo::logv2::LogComponent::kCommand
+
 
 namespace mongo {
 
-using std::string;
+using namespace fmt::literals;
 
-ServerStatusMetric::ServerStatusMetric(const string& nameIn)
-    : _name(nameIn), _leafName(_parseLeafName(nameIn)) {
-    if (MetricTree::theMetricTree == nullptr)
-        MetricTree::theMetricTree = new MetricTree();
-    MetricTree::theMetricTree->add(this);
-}
+ServerStatusMetric::ServerStatusMetric(const std::string& nameIn)
+    : _name(nameIn), _leafName(_parseLeafName(nameIn)) {}
 
-string ServerStatusMetric::_parseLeafName(const string& name) {
+std::string ServerStatusMetric::_parseLeafName(const std::string& name) {
     size_t idx = name.rfind(".");
-    if (idx == string::npos)
+    if (idx == std::string::npos)
         return name;
-
     return name.substr(idx + 1);
 }
+
+MetricTree* globalMetricTree(bool create) {
+    static struct {
+        stdx::mutex* mutex = new stdx::mutex();  // NOLINT
+        MetricTree* metricTree = nullptr;
+    } instance;
+    stdx::lock_guard lock(*instance.mutex);
+    if (create && !instance.metricTree)
+        instance.metricTree = new MetricTree();
+    return instance.metricTree;
+}
+
+void MetricTree::add(std::unique_ptr<ServerStatusMetric> metric) {
+    std::string name = metric->getMetricName();
+    if (!name.empty()) {
+        if (auto begin = name.begin(); *begin == '.')
+            name.erase(begin);
+        else
+            name = "metrics.{}"_format(name);
+    }
+
+    if (!name.empty())
+        _add(name, std::move(metric));
+}
+
+void MetricTree::_add(const std::string& path, std::unique_ptr<ServerStatusMetric> metric) {
+    size_t idx = path.find('.');
+    if (idx == std::string::npos) {
+        if (_subtrees.count(path) > 0)
+            LOGV2_FATAL(6483100, "metric conflict", "path"_attr = path);
+
+        if (!_metrics.try_emplace(path, std::move(metric)).second)
+            LOGV2_FATAL(6483102, "duplicate metric", "path"_attr = path);
+
+        return;
+    }
+
+    std::string myLevel = path.substr(0, idx);
+    if (_metrics.count(myLevel) > 0)
+        LOGV2_FATAL(16461, "metric conflict", "path"_attr = path);
+
+    auto& sub = _subtrees[myLevel];
+    if (!sub)
+        sub = std::make_unique<MetricTree>();
+    sub->_add(path.substr(idx + 1), std::move(metric));
+}
+
+void MetricTree::appendTo(BSONObjBuilder& b) const {
+    for (const auto& i : _metrics) {
+        i.second->appendAtLeaf(b);
+    }
+
+    for (const auto& i : _subtrees) {
+        BSONObjBuilder bb(b.subobjStart(i.first));
+        i.second->appendTo(bb);
+        bb.done();
+    }
+}
+
+void MetricTree::appendTo(const BSONObj& excludePaths, BSONObjBuilder& b) const {
+    auto fieldNamesInExclude = excludePaths.getFieldNames<stdx::unordered_set<std::string>>();
+    for (const auto& i : _metrics) {
+        auto key = i.first;
+        auto el = fieldNamesInExclude.contains(key) ? excludePaths.getField(key) : BSONElement();
+        if (el) {
+            uassert(ErrorCodes::InvalidBSONType,
+                    "Exclusion value for a leaf must be a boolean.",
+                    el.type() == Bool);
+            if (el.boolean() == false) {
+                continue;
+            }
+        }
+        i.second->appendAtLeaf(b);
+    }
+
+    for (const auto& i : _subtrees) {
+        auto key = i.first;
+        auto el = fieldNamesInExclude.contains(key) ? excludePaths.getField(key) : BSONElement();
+        if (el) {
+            uassert(ErrorCodes::InvalidBSONType,
+                    "Exclusion value must be a boolean or a nested object.",
+                    el.type() == Bool || el.type() == Object);
+            if (el.isBoolean() && el.boolean() == false) {
+                continue;
+            }
+        }
+
+        BSONObjBuilder bb(b.subobjStart(key));
+        if (el.type() == Object) {
+            i.second->appendTo(el.embeddedObject(), bb);
+        } else {
+            i.second->appendTo(bb);
+        }
+    }
+}
+
 }  // namespace mongo
diff --git a/src/mongo/db/commands/server_status_metric.h b/src/mongo/db/commands/server_status_metric.h
index ff546527a8d..dadb41ebfa2 100644
--- a/src/mongo/db/commands/server_status_metric.h
+++ b/src/mongo/db/commands/server_status_metric.h
@@ -29,6 +29,8 @@
 
 #pragma once
 
+#include <map>
+#include <memory>
 #include <string>
 
 #include "mongo/db/jsobj.h"
@@ -37,14 +39,7 @@ namespace mongo {
 
 class ServerStatusMetric {
 public:
-    /**
-     * @param name is a dotted path of a counter name
-     *             if name starts with . its treated as a path from the serverStatus root
-     *             otherwise it will live under the "counters" namespace
-     *             so foo.bar would be serverStatus().counters.foo.bar
-     */
-    ServerStatusMetric(const std::string& name);
-    virtual ~ServerStatusMetric() {}
+    virtual ~ServerStatusMetric() = default;
 
     std::string getMetricName() const {
         return _name;
@@ -55,33 +50,143 @@ public:
 protected:
     static std::string _parseLeafName(const std::string& name);
 
+    /**
+     * The parameter name is a string where periods have a special meaning.
+     * It represents the path where the metric can be found into the tree.
+     * If name starts with ".", it will be treated as a path from
+     * the serverStatus root otherwise it will live under the "counters"
+     * namespace so foo.bar would be serverStatus().counters.foo.bar
+     */
+    explicit ServerStatusMetric(const std::string& name);
+
     const std::string _name;
     const std::string _leafName;
 };
 
 /**
- * usage
+ * ServerStatusMetricField is the generic class for storing and reporting server
+ * status metrics.
+ * Its recommended usage is through the addMetricToTree helper function. Here is an
+ * example of a ServerStatusMetricField holding a Counter64.
+ *
+ * auto& metric =
+ *      addMetricToTree(std::make_unique<ServerStatusMetricField<Counter64>>("path.to.counter"));
+ *      ...
+ *      metric.value().increment();
  *
- * declared once
- *    Counter counter;
- *    ServerStatusMetricField myAwesomeCounterDisplay( "path.to.counter", &counter );
+ * Or with `makeServerStatusMetric`:
  *
- * call
- *    counter.hit();
+ *     auto& counter = makeServerStatusMetric<Counter64>("path.to.counter");
+ *     ...
+ *     counter.increment();
  *
- * will show up in db.serverStatus().metrics.path.to.counter
+ * To read the metric from JavaScript:
+ *      db.serverStatus().metrics.path.to.counter
  */
 template <typename T>
 class ServerStatusMetricField : public ServerStatusMetric {
 public:
-    ServerStatusMetricField(const std::string& name, const T* t)
-        : ServerStatusMetric(name), _t(t) {}
+    explicit ServerStatusMetricField(const std::string& name) : ServerStatusMetric(name) {}
 
-    virtual void appendAtLeaf(BSONObjBuilder& b) const {
-        b.append(_leafName, *_t);
+    void appendAtLeaf(BSONObjBuilder& b) const override {
+        b.append(_leafName, _t);
     }
 
+    T& value() {
+        return _t;
+    }
+
+    T _t;
+};
+
+class MetricTree {
+public:
+    ~MetricTree() = default;
+
+    void add(std::unique_ptr<ServerStatusMetric> metric);
+
+    /**
+     * Append the metrics tree to the given BSON builder.
+     */
+    void appendTo(BSONObjBuilder& b) const;
+
+    /**
+     * Overload of appendTo which allows tree of exclude paths. The alternative overload is
+     * preferred to avoid overhead when no excludes are present.
+     */
+    void appendTo(const BSONObj& excludePaths, BSONObjBuilder& b) const;
+
 private:
-    const T* _t;
+    void _add(const std::string& path, std::unique_ptr<ServerStatusMetric> metric);
+
+    std::map<std::string, std::unique_ptr<MetricTree>> _subtrees;
+    std::map<std::string, std::unique_ptr<ServerStatusMetric>> _metrics;
 };
+
+/**
+ * globalMetricTree is responsible for creating and returning a MetricTree instance
+ * statically stored inside. The create parameter bypasses its creation returning a
+ * null pointer for when it has not been created yet.
+ */
+MetricTree* globalMetricTree(bool create = true);
+
+template <typename T>
+T& addMetricToTree(std::unique_ptr<T> metric, MetricTree* metricTree = globalMetricTree()) {
+    invariant(metric);
+    invariant(metricTree);
+    T& reference = *metric;
+    metricTree->add(std::move(metric));
+    return reference;
+}
+
+template <typename TYPE>
+TYPE& makeServerStatusMetric(std::string path) {
+    return addMetricToTree(std::make_unique<ServerStatusMetricField<TYPE>>(std::move(path)))
+        .value();
+}
+
+class CounterMetric {
+public:
+    CounterMetric(std::string name)
+        : _counter{makeServerStatusMetric<Counter64>(std::move(name))} {}
+    CounterMetric(CounterMetric&) = delete;
+    CounterMetric& operator=(CounterMetric&) = delete;
+
+    operator Counter64&() {
+        return _counter;
+    }
+
+    /**
+     * replicates the same public interface found in Counter64.
+     */
+
+    /**
+     * Atomically increment.
+     */
+    void increment(uint64_t n = 1) const {
+        _counter.increment(n);
+    }
+
+    /**
+     * Atomically decrement.
+     */
+    void decrement(uint64_t n = 1) const {
+        _counter.decrement(n);
+    }
+
+    /**
+     * Return the current value.
+     */
+    long long get() const {
+        return _counter.get();
+    }
+
+    operator long long() const {
+        return get();
+    }
+
+private:
+    Counter64& _counter;
+};
+
 }  // namespace mongo
diff --git a/src/mongo/db/commands/update_metrics.cpp b/src/mongo/db/commands/update_metrics.cpp
index 357920aeb7e..a730e812c28 100644
--- a/src/mongo/db/commands/update_metrics.cpp
+++ b/src/mongo/db/commands/update_metrics.cpp
@@ -27,16 +27,12 @@
  *    it in the license file.
  */
 
-#include "mongo/platform/basic.h"
-
 #include "mongo/db/commands/update_metrics.h"
 
 namespace mongo {
 UpdateMetrics::UpdateMetrics(StringData commandName)
-    : _commandsWithAggregationPipelineMetric("commands." + commandName + ".pipeline",
-                                             &_commandsWithAggregationPipeline),
-      _commandsWithArrayFiltersMetric("commands." + commandName + ".arrayFilters",
-                                      &_commandsWithArrayFilters) {}
+    : _commandsWithAggregationPipeline("commands." + commandName + ".pipeline"),
+      _commandsWithArrayFilters("commands." + commandName + ".arrayFilters") {}
 
 void UpdateMetrics::incrementExecutedWithAggregationPipeline() {
     _commandsWithAggregationPipeline.increment();
diff --git a/src/mongo/db/commands/update_metrics.h b/src/mongo/db/commands/update_metrics.h
index c6732762778..d485d723e81 100644
--- a/src/mongo/db/commands/update_metrics.h
+++ b/src/mongo/db/commands/update_metrics.h
@@ -29,7 +29,6 @@
 
 #pragma once
 
-#include "mongo/base/counter.h"
 #include "mongo/base/string_data.h"
 #include "mongo/bson/bsonobj.h"
 #include "mongo/db/commands/server_status_metric.h"
@@ -73,16 +72,9 @@ public:
 private:
     // A counter for how many times this command has been executed with an aggregation
     // pipeline-style update parameter.
-    Counter64 _commandsWithAggregationPipeline;
+    CounterMetric _commandsWithAggregationPipeline;
 
     // A counter for how many times this command has been executed with the arrayFilters option.
-    Counter64 _commandsWithArrayFilters;
-
-    // A server metric field for the command executions with an aggregation pipeline-style update
-    // parameter counter.
-    ServerStatusMetricField<Counter64> _commandsWithAggregationPipelineMetric;
-
-    // A server metric field for the command executions with arrayFilters option counter.
-    ServerStatusMetricField<Counter64> _commandsWithArrayFiltersMetric;
+    CounterMetric _commandsWithArrayFilters;
 };
 }  // namespace mongo
diff --git a/src/mongo/db/concurrency/exception_util.cpp b/src/mongo/db/concurrency/exception_util.cpp
index 989cf54b320..3f9dec3441e 100644
--- a/src/mongo/db/concurrency/exception_util.cpp
+++ b/src/mongo/db/concurrency/exception_util.cpp
@@ -30,7 +30,6 @@
 
 #include "mongo/db/concurrency/exception_util.h"
 
-#include "mongo/base/counter.h"
 #include "mongo/db/commands/server_status_metric.h"
 #include "mongo/db/concurrency/exception_util_gen.h"
 #include "mongo/db/namespace_string.h"
@@ -57,17 +56,10 @@ void logWriteConflictAndBackoff(int attempt, StringData operation, StringData ns
 
 namespace {
 
-Counter64 temporarilyUnavailableErrors;
-Counter64 temporarilyUnavailableErrorsEscaped;
-Counter64 temporarilyUnavailableErrorsConvertedToWriteConflict;
-
-ServerStatusMetricField<Counter64> displayTemporarilyUnavailableErrors(
-    "operation.temporarilyUnavailableErrors", &temporarilyUnavailableErrors);
-ServerStatusMetricField<Counter64> displayTemporarilyUnavailableErrorsEscaped(
-    "operation.temporarilyUnavailableErrorsEscaped", &temporarilyUnavailableErrorsEscaped);
-ServerStatusMetricField<Counter64> displayTemporarilyUnavailableErrorsConverted(
-    "operation.temporarilyUnavailableErrorsConvertedToWriteConflict",
-    &temporarilyUnavailableErrorsConvertedToWriteConflict);
+CounterMetric temporarilyUnavailableErrors{"operation.temporarilyUnavailableErrors"};
+CounterMetric temporarilyUnavailableErrorsEscaped{"operation.temporarilyUnavailableErrorsEscaped"};
+CounterMetric temporarilyUnavailableErrorsConvertedToWriteConflict{
+    "operation.temporarilyUnavailableErrorsConvertedToWriteConflict"};
 
 }  // namespace
 
diff --git a/src/mongo/db/curop.cpp b/src/mongo/db/curop.cpp
index 6fc209bd270..bd15b40232c 100644
--- a/src/mongo/db/curop.cpp
+++ b/src/mongo/db/curop.cpp
@@ -30,8 +30,6 @@
 // CHECK_LOG_REDACTION
 
 
-#include "mongo/platform/basic.h"
-
 #include "mongo/db/curop.h"
 
 #include <iomanip>
@@ -69,9 +67,7 @@ using std::string;
 
 namespace {
 
-TimerStats oplogGetMoreStats;
-ServerStatusMetricField<TimerStats> displayBatchesReceived("repl.network.oplogGetMoresProcessed",
-                                                           &oplogGetMoreStats);
+auto& oplogGetMoreStats = makeServerStatusMetric<TimerStats>("repl.network.oplogGetMoresProcessed");
 
 }  // namespace
 
diff --git a/src/mongo/db/curop_metrics.cpp b/src/mongo/db/curop_metrics.cpp
index 63537de8980..526f779efa2 100644
--- a/src/mongo/db/curop_metrics.cpp
+++ b/src/mongo/db/curop_metrics.cpp
@@ -27,9 +27,6 @@
  *    it in the license file.
  */
 
-#include "mongo/platform/basic.h"
-
-#include "mongo/base/counter.h"
 #include "mongo/db/commands/server_status_metric.h"
 #include "mongo/db/curop.h"
 #include "mongo/db/operation_context.h"
@@ -37,28 +34,17 @@
 
 namespace mongo {
 namespace {
-Counter64 returnedCounter;
-Counter64 insertedCounter;
-Counter64 updatedCounter;
-Counter64 deletedCounter;
-Counter64 scannedCounter;
-Counter64 scannedObjectCounter;
 
-ServerStatusMetricField<Counter64> displayReturned("document.returned", &returnedCounter);
-ServerStatusMetricField<Counter64> displayUpdated("document.updated", &updatedCounter);
-ServerStatusMetricField<Counter64> displayInserted("document.inserted", &insertedCounter);
-ServerStatusMetricField<Counter64> displayDeleted("document.deleted", &deletedCounter);
-ServerStatusMetricField<Counter64> displayScanned("queryExecutor.scanned", &scannedCounter);
-ServerStatusMetricField<Counter64> displayScannedObjects("queryExecutor.scannedObjects",
-                                                         &scannedObjectCounter);
+CounterMetric deletedCounter("document.deleted");
+CounterMetric insertedCounter("document.inserted");
+CounterMetric returnedCounter("document.returned");
+CounterMetric updatedCounter("document.updated");
 
-Counter64 scanAndOrderCounter;
-Counter64 writeConflictsCounter;
+CounterMetric scannedCounter("queryExecutor.scanned");
+CounterMetric scannedObjectCounter("queryExecutor.scannedObjects");
 
-ServerStatusMetricField<Counter64> displayScanAndOrder("operation.scanAndOrder",
-                                                       &scanAndOrderCounter);
-ServerStatusMetricField<Counter64> displayWriteConflicts("operation.writeConflicts",
-                                                         &writeConflictsCounter);
+CounterMetric scanAndOrderCounter("operation.scanAndOrder");
+CounterMetric writeConflictsCounter("operation.writeConflicts");
 
 }  // namespace
 
diff --git a/src/mongo/db/cursor_manager.cpp b/src/mongo/db/cursor_manager.cpp
index 8d09c6811fb..ce81235bdd0 100644
--- a/src/mongo/db/cursor_manager.cpp
+++ b/src/mongo/db/cursor_manager.cpp
@@ -28,8 +28,6 @@
  */
 
 
-#include "mongo/platform/basic.h"
-
 #include "mongo/db/cursor_manager.h"
 
 #include <memory>
@@ -63,28 +61,14 @@
 
 namespace mongo {
 
-static Counter64 cursorStatsLifespanLessThan1Second;
-static Counter64 cursorStatsLifespanLessThan5Seconds;
-static Counter64 cursorStatsLifespanLessThan15Seconds;
-static Counter64 cursorStatsLifespanLessThan30Seconds;
-static Counter64 cursorStatsLifespanLessThan1Minute;
-static Counter64 cursorStatsLifespanLessThan10Minutes;
-static Counter64 cursorStatsLifespanGreaterThanOrEqual10Minutes;
-
-static ServerStatusMetricField<Counter64> dCursorStatsLifespanLessThan1Second(
-    "cursor.lifespan.lessThan1Second", &cursorStatsLifespanLessThan1Second);
-static ServerStatusMetricField<Counter64> dCursorStatsLifespanLessThan5Seconds(
-    "cursor.lifespan.lessThan5Seconds", &cursorStatsLifespanLessThan5Seconds);
-static ServerStatusMetricField<Counter64> dCursorStatsLifespanLessThan15Seconds(
-    "cursor.lifespan.lessThan15Seconds", &cursorStatsLifespanLessThan15Seconds);
-static ServerStatusMetricField<Counter64> dCursorStatsLifespanLessThan30Seconds(
-    "cursor.lifespan.lessThan30Seconds", &cursorStatsLifespanLessThan30Seconds);
-static ServerStatusMetricField<Counter64> dCursorStatsLifespanLessThan1Minute(
-    "cursor.lifespan.lessThan1Minute", &cursorStatsLifespanLessThan1Minute);
-static ServerStatusMetricField<Counter64> dCursorStatsLifespanLessThan10Minutes(
-    "cursor.lifespan.lessThan10Minutes", &cursorStatsLifespanLessThan10Minutes);
-static ServerStatusMetricField<Counter64> dCursorStatsLifespanGreaterThanOrEqual10Minutes(
-    "cursor.lifespan.greaterThanOrEqual10Minutes", &cursorStatsLifespanGreaterThanOrEqual10Minutes);
+static CounterMetric cursorStatsLifespanLessThan1Second{"cursor.lifespan.lessThan1Second"};
+static CounterMetric cursorStatsLifespanLessThan5Seconds{"cursor.lifespan.lessThan5Seconds"};
+static CounterMetric cursorStatsLifespanLessThan15Seconds{"cursor.lifespan.lessThan15Seconds"};
+static CounterMetric cursorStatsLifespanLessThan30Seconds{"cursor.lifespan.lessThan30Seconds"};
+static CounterMetric cursorStatsLifespanLessThan1Minute{"cursor.lifespan.lessThan1Minute"};
+static CounterMetric cursorStatsLifespanLessThan10Minutes{"cursor.lifespan.lessThan10Minutes"};
+static CounterMetric cursorStatsLifespanGreaterThanOrEqual10Minutes{
+    "cursor.lifespan.greaterThanOrEqual10Minutes"};
 
 constexpr int CursorManager::kNumPartitions;
 
diff --git a/src/mongo/db/exec/histogram_server_status_metric.h b/src/mongo/db/exec/histogram_server_status_metric.h
index 83a53f2999e..6d3656a8a68 100644
--- a/src/mongo/db/exec/histogram_server_status_metric.h
+++ b/src/mongo/db/exec/histogram_server_status_metric.h
@@ -53,7 +53,8 @@ namespace mongo {
 class HistogramServerStatusMetric {
 public:
     HistogramServerStatusMetric(std::string name, std::vector<uint64_t> bounds)
-        : _hist{std::move(bounds)}, _metric{std::move(name), this} {}
+        : _hist{std::move(bounds)},
+          _metric(addMetricToTree(std::make_unique<Metric>(std::move(name), this))) {}
 
     void increment(uint64_t value) {
         _hist.increment(value);
@@ -95,7 +96,7 @@ private:
     }
 
     Histogram<uint64_t> _hist;
-    Metric _metric;
+    Metric& _metric;
 };
 
 }  // namespace mongo
diff --git a/src/mongo/db/exec/multi_plan.cpp b/src/mongo/db/exec/multi_plan.cpp
index 0dbb0c4a405..52465c59c8a 100644
--- a/src/mongo/db/exec/multi_plan.cpp
+++ b/src/mongo/db/exec/multi_plan.cpp
@@ -28,8 +28,6 @@
  */
 
 
-#include "mongo/platform/basic.h"
-
 #include "mongo/db/exec/multi_plan.h"
 
 #include <algorithm>
@@ -72,27 +70,20 @@ void markShouldCollectTimingInfoOnSubtree(PlanStage* root) {
     }
 }
 
-Counter64 classicMicrosTotal;
-Counter64 classicWorksTotal;
-Counter64 classicCount;
-
 /**
  * Aggregation of the total number of microseconds spent (in the classic multiplanner).
  */
-ServerStatusMetricField<Counter64> classicMicrosTotalDisplay("query.multiPlanner.classicMicros",
-                                                             &classicMicrosTotal);
+CounterMetric classicMicrosTotal("query.multiPlanner.classicMicros");
 
 /**
  * Aggregation of the total number of "works" performed (in the classic multiplanner).
  */
-ServerStatusMetricField<Counter64> classicWorksTotalDisplay("query.multiPlanner.classicWorks",
-                                                            &classicWorksTotal);
+CounterMetric classicWorksTotal("query.multiPlanner.classicWorks");
 
 /**
  * Aggregation of the total number of invocations (of the classic multiplanner).
  */
-ServerStatusMetricField<Counter64> classicCountDisplay("query.multiPlanner.classicCount",
-                                                       &classicCount);
+CounterMetric classicCount("query.multiPlanner.classicCount");
 
 /**
  * An element in this histogram is the number of microseconds spent in an invocation (of the
diff --git a/src/mongo/db/metric_tree_test.cpp b/src/mongo/db/metric_tree_test.cpp
new file mode 100644
index 00000000000..6de4042226b
--- /dev/null
+++ b/src/mongo/db/metric_tree_test.cpp
@@ -0,0 +1,95 @@
+/**
+ *    Copyright (C) 2022-present MongoDB, Inc.
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the Server Side Public License, version 1,
+ *    as published by MongoDB, Inc.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    Server Side Public License for more details.
+ *
+ *    You should have received a copy of the Server Side Public License
+ *    along with this program. If not, see
+ *    <http://www.mongodb.com/licensing/server-side-public-license>.
+ *
+ *    As a special exception, the copyright holders give permission to link the
+ *    code of portions of this program with the OpenSSL library under certain
+ *    conditions as described in each individual source file and distribute
+ *    linked combinations including the program with the OpenSSL library. You
+ *    must comply with the Server Side Public License in all respects for
+ *    all of the code used other than as permitted herein. If you modify file(s)
+ *    with this exception, you may extend this exception to your version of the
+ *    file(s), but you are not obligated to do so. If you do not wish to do so,
+ *    delete this exception statement from your version. If you delete this
+ *    exception statement from all source files in the program, then also delete
+ *    it in the license file.
+ */
+
+#include "mongo/db/commands/server_status_metric.h"
+
+#include "mongo/bson/bsonelement.h"
+#include "mongo/bson/bsonobj.h"
+#include "mongo/bson/bsonobjbuilder.h"
+#include "mongo/unittest/unittest.h"
+
+namespace mongo {
+namespace {
+
+class MetricTreeTest : public unittest::Test {
+protected:
+    MetricTree* tree() const {
+        return _tree.get();
+    }
+
+    BSONObj metrics() {
+        BSONObjBuilder builder;
+        tree()->appendTo(builder);
+        return builder.obj();
+    }
+
+    std::unique_ptr<MetricTree> _tree = std::make_unique<MetricTree>();
+};
+
+TEST_F(MetricTreeTest, ValidateCounterMetric) {
+    auto& counter =
+        addMetricToTree(std::make_unique<ServerStatusMetricField<Counter64>>("tree.counter"),
+                        tree())
+            .value();
+
+    counter.increment();
+    const auto firstMetrics = metrics();
+    BSONElement counterElement = firstMetrics["metrics"]["tree"]["counter"];
+    ASSERT(counterElement.isNumber());
+    ASSERT_EQ(counterElement.numberInt(), counter.get());
+
+    counter.increment(2);
+
+    const auto secondMetrics = metrics();
+    BSONElement anotherCounterElement = secondMetrics["metrics"]["tree"]["counter"];
+    ASSERT(anotherCounterElement.isNumber());
+    ASSERT_EQ(anotherCounterElement.numberInt(), counter.get());
+}
+
+TEST_F(MetricTreeTest, ValidateTextMetric) {
+    auto& text =
+        addMetricToTree(std::make_unique<ServerStatusMetricField<std::string>>("tree.text"), tree())
+            .value();
+
+    text = "hello";
+
+    auto firstMetrics = metrics();
+    BSONElement textElement = firstMetrics["metrics"]["tree"]["text"];
+    ASSERT_EQ(textElement.type(), BSONType::String);
+    ASSERT_EQ(textElement.String(), text);
+
+    text = "bye";
+
+    auto secondMetrics = metrics();
+    BSONElement anotherTextElement = secondMetrics["metrics"]["tree"]["text"];
+    ASSERT_EQ(anotherTextElement.type(), BSONType::String);
+    ASSERT_EQ(anotherTextElement.String(), text);
+}
+}  // namespace
+}  // namespace mongo
diff --git a/src/mongo/db/query/classic_plan_cache.cpp b/src/mongo/db/query/classic_plan_cache.cpp
index 683b4b3660a..748d75cf238 100644
--- a/src/mongo/db/query/classic_plan_cache.cpp
+++ b/src/mongo/db/query/classic_plan_cache.cpp
@@ -32,12 +32,7 @@
 #include "mongo/db/commands/server_status_metric.h"
 
 namespace mongo {
-namespace {
-ServerStatusMetricField<Counter64> totalPlanCacheSizeEstimateBytesMetric(
-    "query.planCacheTotalSizeEstimateBytes", &mongo::planCacheTotalSizeEstimateBytes);
-}  // namespace
-
-Counter64 planCacheTotalSizeEstimateBytes;
+CounterMetric planCacheTotalSizeEstimateBytes("query.planCacheTotalSizeEstimateBytes");
 
 std::ostream& operator<<(std::ostream& stream, const PlanCacheKey& key) {
     stream << key.toString();
diff --git a/src/mongo/db/query/plan_cache.h b/src/mongo/db/query/plan_cache.h
index dc52b10c4f4..1201c0f197c 100644
--- a/src/mongo/db/query/plan_cache.h
+++ b/src/mongo/db/query/plan_cache.h
@@ -30,6 +30,7 @@
 #pragma once
 
 #include "mongo/db/catalog/util/partitioned.h"
+#include "mongo/db/commands/server_status_metric.h"
 #include "mongo/db/query/lru_key_value.h"
 #include "mongo/db/query/plan_cache_callbacks.h"
 #include "mongo/db/query/plan_cache_debug_info.h"
@@ -46,7 +47,7 @@ class PlanCacheEntryBase;
 /**
  * Tracks the approximate cumulative size of the plan cache entries across all the collections.
  */
-extern Counter64 planCacheTotalSizeEstimateBytes;
+extern CounterMetric planCacheTotalSizeEstimateBytes;
 
 /**
  * Information returned from a get(...) query.
diff --git a/src/mongo/db/query/sbe_runtime_planner.cpp b/src/mongo/db/query/sbe_runtime_planner.cpp
index 5edf89539bf..de601c0d823 100644
--- a/src/mongo/db/query/sbe_runtime_planner.cpp
+++ b/src/mongo/db/query/sbe_runtime_planner.cpp
@@ -26,7 +26,6 @@
  *    exception statement from all source files in the program, then also delete
  *    it in the license file.
  */
-#include "mongo/platform/basic.h"
 
 #include "mongo/db/query/sbe_runtime_planner.h"
 
@@ -40,26 +39,20 @@
 namespace mongo::sbe {
 namespace {
 
-Counter64 sbeMicrosTotal;
-Counter64 sbeNumReadsTotal;
-Counter64 sbeCount;
-
 /**
  * Aggregation of the total number of microseconds spent (in SBE multiplanner).
  */
-ServerStatusMetricField<Counter64> sbeMicrosTotalDisplay("query.multiPlanner.sbeMicros",
-                                                         &sbeMicrosTotal);
+CounterMetric sbeMicrosTotal("query.multiPlanner.sbeMicros");
 
 /**
  * Aggregation of the total number of reads done (in SBE multiplanner).
  */
-ServerStatusMetricField<Counter64> sbeNumReadsTotalDisplay("query.multiPlanner.sbeNumReads",
-                                                           &sbeNumReadsTotal);
+CounterMetric sbeNumReadsTotal("query.multiPlanner.sbeNumReads");
 
 /**
  * Aggregation of the total number of invocations (of the SBE multiplanner).
  */
-ServerStatusMetricField<Counter64> sbeCountDisplay("query.multiPlanner.sbeCount", &sbeCount);
+CounterMetric sbeCount("query.multiPlanner.sbeCount");
 
 /**
  * An element in this histogram is the number of microseconds spent in an invocation (of the SBE
diff --git a/src/mongo/db/repl/bgsync.cpp b/src/mongo/db/repl/bgsync.cpp
index 893ae8014e0..69d9868e1b0 100644
--- a/src/mongo/db/repl/bgsync.cpp
+++ b/src/mongo/db/repl/bgsync.cpp
@@ -28,13 +28,10 @@
  */
 
 
-#include "mongo/platform/basic.h"
-
 #include "mongo/db/repl/bgsync.h"
 
 #include <memory>
 
-#include "mongo/base/counter.h"
 #include "mongo/base/string_data.h"
 #include "mongo/bson/util/bson_extract.h"
 #include "mongo/client/connection_pool.h"
@@ -81,27 +78,19 @@ const Milliseconds kRollbackOplogSocketTimeout(10 * 60 * 1000);
 // The number of times a node attempted to choose a node to sync from among the available sync
 // source options. This occurs if we re-evaluate our sync source, receive an error from the source,
 // or step down.
-Counter64 numSyncSourceSelections;
-ServerStatusMetricField<Counter64> displayNumSyncSourceSelections("repl.syncSource.numSelections",
-                                                                  &numSyncSourceSelections);
+CounterMetric numSyncSourceSelections("repl.syncSource.numSelections");
 
 // The number of times a node kept it's original sync source after re-evaluating if its current sync
 // source was optimal.
-Counter64 numTimesChoseSameSyncSource;
-ServerStatusMetricField<Counter64> displayNumTimesChoseSameSyncSource(
-    "repl.syncSource.numTimesChoseSame", &numTimesChoseSameSyncSource);
+CounterMetric numTimesChoseSameSyncSource("repl.syncSource.numTimesChoseSame");
 
 // The number of times a node chose a new sync source after re-evaluating if its current sync source
 // was optimal.
-Counter64 numTimesChoseDifferentSyncSource;
-ServerStatusMetricField<Counter64> displayNumTimesChoseDifferentSyncSource(
-    "repl.syncSource.numTimesChoseDifferent", &numTimesChoseDifferentSyncSource);
+CounterMetric numTimesChoseDifferentSyncSource("repl.syncSource.numTimesChoseDifferent");
 
 // The number of times a node could not find a sync source when choosing a node to sync from among
 // the available options.
-Counter64 numTimesCouldNotFindSyncSource;
-ServerStatusMetricField<Counter64> displayNumTimesCouldNotFindSyncSource(
-    "repl.syncSource.numTimesCouldNotFind", &numTimesCouldNotFindSyncSource);
+CounterMetric numTimesCouldNotFindSyncSource("repl.syncSource.numTimesCouldNotFind");
 
 /**
  * Extends DataReplicatorExternalStateImpl to be member state aware.
diff --git a/src/mongo/db/repl/initial_syncer_common_stats.cpp b/src/mongo/db/repl/initial_syncer_common_stats.cpp
index 34a4b7cad6f..cd5c943f56f 100644
--- a/src/mongo/db/repl/initial_syncer_common_stats.cpp
+++ b/src/mongo/db/repl/initial_syncer_common_stats.cpp
@@ -38,16 +38,9 @@ namespace mongo {
 namespace repl {
 namespace initial_sync_common_stats {
 
-Counter64 initialSyncFailedAttempts;
-Counter64 initialSyncFailures;
-Counter64 initialSyncCompletes;
-
-ServerStatusMetricField<Counter64> displaySSInitialSyncFailedAttempts(
-    "repl.initialSync.failedAttempts", &initialSyncFailedAttempts);
-ServerStatusMetricField<Counter64> displaySSInitialSyncFailures("repl.initialSync.failures",
-                                                                &initialSyncFailures);
-ServerStatusMetricField<Counter64> displaySSInitialSyncCompleted("repl.initialSync.completed",
-                                                                 &initialSyncCompletes);
+CounterMetric initialSyncFailedAttempts("repl.initialSync.failedAttempts");
+CounterMetric initialSyncFailures("repl.initialSync.failures");
+CounterMetric initialSyncCompletes("repl.initialSync.completed");
 
 void LogInitialSyncAttemptStats(const StatusWith<OpTimeAndWallTime>& attemptResult,
                                 bool hasRetries,
diff --git a/src/mongo/db/repl/initial_syncer_common_stats.h b/src/mongo/db/repl/initial_syncer_common_stats.h
index beb8a829bc5..4a0fd858f50 100644
--- a/src/mongo/db/repl/initial_syncer_common_stats.h
+++ b/src/mongo/db/repl/initial_syncer_common_stats.h
@@ -29,6 +29,7 @@
 
 #pragma once
 
+#include "mongo/db/commands/server_status_metric.h"
 #include "mongo/db/repl/optime.h"
 
 namespace mongo {
@@ -38,17 +39,17 @@ namespace initial_sync_common_stats {
 // The number of initial sync attempts that have failed since server startup. Each instance of
 // InitialSyncer may run multiple attempts to fulfill an initial sync request that is triggered
 // when InitialSyncer::startup() is called.
-extern Counter64 initialSyncFailedAttempts;
+extern CounterMetric initialSyncFailedAttempts;
 
 // The number of initial sync requests that have been requested and failed. Each instance of
 // InitialSyncer (upon successful startup()) corresponds to a single initial sync request.
 // This value does not include the number of times where a InitialSyncer is created successfully
 // but failed in startup().
-extern Counter64 initialSyncFailures;
+extern CounterMetric initialSyncFailures;
 
 // The number of initial sync requests that have been requested and completed successfully. Each
 // instance of InitialSyncer corresponds to a single initial sync request.
-extern Counter64 initialSyncCompletes;
+extern CounterMetric initialSyncCompletes;
 
 void LogInitialSyncAttemptStats(const StatusWith<OpTimeAndWallTime>& attemptResult,
                                 bool hasRetries,
diff --git a/src/mongo/db/repl/oplog_applier_impl.cpp b/src/mongo/db/repl/oplog_applier_impl.cpp
index 575035711e0..d897241134b 100644
--- a/src/mongo/db/repl/oplog_applier_impl.cpp
+++ b/src/mongo/db/repl/oplog_applier_impl.cpp
@@ -63,16 +63,13 @@ MONGO_FAIL_POINT_DEFINE(pauseBatchApplicationAfterWritingOplogEntries);
 MONGO_FAIL_POINT_DEFINE(hangAfterRecordingOpApplicationStartTime);
 
 // The oplog entries applied
-Counter64 opsAppliedStats;
-ServerStatusMetricField<Counter64> displayOpsApplied("repl.apply.ops", &opsAppliedStats);
+CounterMetric opsAppliedStats("repl.apply.ops");
 
 // Tracks the oplog application batch size.
-Counter64 oplogApplicationBatchSize;
-ServerStatusMetricField<Counter64> displayOplogApplicationBatchSize("repl.apply.batchSize",
-                                                                    &oplogApplicationBatchSize);
+CounterMetric oplogApplicationBatchSize("repl.apply.batchSize");
+
 // Number and time of each ApplyOps worker pool round
-TimerStats applyBatchStats;
-ServerStatusMetricField<TimerStats> displayOpBatchesApplied("repl.apply.batches", &applyBatchStats);
+auto& applyBatchStats = makeServerStatusMetric<TimerStats>("repl.apply.batches");
 
 /**
  * Used for logging a report of ops that take longer than "slowMS" to apply. This is called
diff --git a/src/mongo/db/repl/oplog_buffer.h b/src/mongo/db/repl/oplog_buffer.h
index 2e039cb1f91..f3b0fabb228 100644
--- a/src/mongo/db/repl/oplog_buffer.h
+++ b/src/mongo/db/repl/oplog_buffer.h
@@ -31,10 +31,11 @@
 
 #include <boost/optional.hpp>
 #include <cstddef>
+#include <string>
 #include <vector>
 
-#include "mongo/base/counter.h"
 #include "mongo/bson/bsonobj.h"
+#include "mongo/db/commands/server_status_metric.h"
 #include "mongo/util/interruptible.h"
 #include "mongo/util/time_support.h"
 
@@ -191,6 +192,11 @@ public:
 
 class OplogBuffer::Counters {
 public:
+    explicit Counters(const std::string& prefix)
+        : count(prefix + ".count"),
+          size(prefix + ".sizeBytes"),
+          maxSize(prefix + ".maxSizeBytes") {}
+
     /**
      * Sets maximum size of operations for this OplogBuffer.
      * This function should only be called by a single thread.
@@ -219,13 +225,13 @@ public:
     }
 
     // Number of operations in this OplogBuffer.
-    Counter64 count;
+    CounterMetric count;
 
     // Total size of operations in this OplogBuffer. Measured in bytes.
-    Counter64 size;
+    CounterMetric size;
 
     // Maximum size of operations in this OplogBuffer. Measured in bytes.
-    Counter64 maxSize;
+    CounterMetric maxSize;
 };
 
 /**
diff --git a/src/mongo/db/repl/oplog_fetcher.cpp b/src/mongo/db/repl/oplog_fetcher.cpp
index 6ec6c9778de..a08a241a2b9 100644
--- a/src/mongo/db/repl/oplog_fetcher.cpp
+++ b/src/mongo/db/repl/oplog_fetcher.cpp
@@ -30,7 +30,6 @@
 
 #include "mongo/db/repl/oplog_fetcher.h"
 
-#include "mongo/base/counter.h"
 #include "mongo/bson/mutable/document.h"
 #include "mongo/db/commands/server_status_metric.h"
 #include "mongo/db/jsobj.h"
@@ -91,19 +90,13 @@ BSONObj OplogBatchStats::getReport() const {
 }
 
 // The number and time spent reading batches off the network
-OplogBatchStats oplogBatchStats;
-ServerStatusMetricField<OplogBatchStats> displayBatchesRecieved("repl.network.getmores",
-                                                                &oplogBatchStats);
+auto& oplogBatchStats = makeServerStatusMetric<OplogBatchStats>("repl.network.getmores");
 // The oplog entries read via the oplog reader
-Counter64 opsReadStats;
-ServerStatusMetricField<Counter64> displayOpsRead("repl.network.ops", &opsReadStats);
+CounterMetric opsReadStats("repl.network.ops");
 // The bytes read via the oplog reader
-Counter64 networkByteStats;
-ServerStatusMetricField<Counter64> displayBytesRead("repl.network.bytes", &networkByteStats);
+CounterMetric networkByteStats("repl.network.bytes");
 
-Counter64 readersCreatedStats;
-ServerStatusMetricField<Counter64> displayReadersCreated("repl.network.readersCreated",
-                                                         &readersCreatedStats);
+CounterMetric readersCreatedStats("repl.network.readersCreated");
 
 const Milliseconds maximumAwaitDataTimeoutMS(30 * 1000);
 
diff --git a/src/mongo/db/repl/repl_set_commands.cpp b/src/mongo/db/repl/repl_set_commands.cpp
index af67f31e3c6..2411b496c7c 100644
--- a/src/mongo/db/repl/repl_set_commands.cpp
+++ b/src/mongo/db/repl/repl_set_commands.cpp
@@ -32,8 +32,6 @@
     LOGV2_DEBUG_OPTIONS(                               \
         ID, DLEVEL, {logv2::LogComponent::kReplicationHeartbeats}, MESSAGE, ##__VA_ARGS__)
 
-#include "mongo/platform/basic.h"
-
 #include <boost/algorithm/string.hpp>
 
 #include "mongo/db/repl/repl_set_command.h"
@@ -85,7 +83,9 @@ public:
     virtual void appendAtLeaf(BSONObjBuilder& b) const {
         ReplicationCoordinator::get(getGlobalServiceContext())->appendDiagnosticBSON(&b);
     }
-} replExecutorSSM;
+};
+
+auto& replExecutorSSM = addMetricToTree(std::make_unique<ReplExecutorSSM>());
 
 // Testing only, enabled via command-line.
 class CmdReplSetTest : public ReplSetCommand {
@@ -533,12 +533,8 @@ public:
         return false;
     }
 
-    CmdReplSetStepDown()
-        : ReplSetCommand("replSetStepDown"),
-          _stepDownCmdsWithForceExecutedMetric("commands.replSetStepDownWithForce.total",
-                                               &_stepDownCmdsWithForceExecuted),
-          _stepDownCmdsWithForceFailedMetric("commands.replSetStepDownWithForce.failed",
-                                             &_stepDownCmdsWithForceFailed) {}
+    CmdReplSetStepDown() : ReplSetCommand("replSetStepDown") {}
+
     virtual bool run(OperationContext* opCtx,
                      const string&,
                      const BSONObj& cmdObj,
@@ -604,10 +600,8 @@ public:
     }
 
 private:
-    mutable Counter64 _stepDownCmdsWithForceExecuted;
-    mutable Counter64 _stepDownCmdsWithForceFailed;
-    ServerStatusMetricField<Counter64> _stepDownCmdsWithForceExecutedMetric;
-    ServerStatusMetricField<Counter64> _stepDownCmdsWithForceFailedMetric;
+    CounterMetric _stepDownCmdsWithForceExecuted{"commands.replSetStepDownWithForce.total"};
+    CounterMetric _stepDownCmdsWithForceFailed{"commands.replSetStepDownWithForce.failed"};
 
     ActionSet getAuthActionSet() const override {
         return ActionSet{ActionType::replSetStateChange};
diff --git a/src/mongo/db/repl/replication_coordinator_external_state_impl.cpp b/src/mongo/db/repl/replication_coordinator_external_state_impl.cpp
index 47e9bd7a29e..45480cd9020 100644
--- a/src/mongo/db/repl/replication_coordinator_external_state_impl.cpp
+++ b/src/mongo/db/repl/replication_coordinator_external_state_impl.cpp
@@ -28,8 +28,6 @@
  */
 
 
-#include "mongo/platform/basic.h"
-
 #include "mongo/db/repl/replication_coordinator_external_state_impl.h"
 
 #include <functional>
@@ -146,14 +144,7 @@ const NamespaceString configCollectionNS{"local", "system.replset"};
 MONGO_FAIL_POINT_DEFINE(dropPendingCollectionReaperHang);
 
 // The count of items in the buffer
-OplogBuffer::Counters bufferGauge;
-ServerStatusMetricField<Counter64> displayBufferCount("repl.buffer.count", &bufferGauge.count);
-// The size (bytes) of items in the buffer
-ServerStatusMetricField<Counter64> displayBufferSize("repl.buffer.sizeBytes", &bufferGauge.size);
-// The max size (bytes) of the buffer. If the buffer does not have a size constraint, this is
-// set to 0.
-ServerStatusMetricField<Counter64> displayBufferMaxSize("repl.buffer.maxSizeBytes",
-                                                        &bufferGauge.maxSize);
+OplogBuffer::Counters bufferGauge("repl.buffer");
 
 /**
  * Returns new thread pool for thread pool task executor.
diff --git a/src/mongo/db/repl/replication_coordinator_impl.cpp b/src/mongo/db/repl/replication_coordinator_impl.cpp
index fe769df7572..9e44ce2d034 100644
--- a/src/mongo/db/repl/replication_coordinator_impl.cpp
+++ b/src/mongo/db/repl/replication_coordinator_impl.cpp
@@ -32,8 +32,6 @@
     LOGV2_DEBUG_OPTIONS(                             \
         ID, DLEVEL, {logv2::LogComponent::kReplicationElection}, MESSAGE, ##__VA_ARGS__)
 
-#include "mongo/platform/basic.h"
-
 #include "mongo/db/repl/replication_coordinator_impl.h"
 
 #include <algorithm>
@@ -159,31 +157,22 @@ MONGO_FAIL_POINT_DEFINE(setCustomErrorInHelloResponseMongoD);
 MONGO_FAIL_POINT_DEFINE(throwBeforeRecoveringTenantMigrationAccessBlockers);
 
 // Number of times we tried to go live as a secondary.
-Counter64 attemptsToBecomeSecondary;
-ServerStatusMetricField<Counter64> displayAttemptsToBecomeSecondary(
-    "repl.apply.attemptsToBecomeSecondary", &attemptsToBecomeSecondary);
+CounterMetric attemptsToBecomeSecondary("repl.apply.attemptsToBecomeSecondary");
 
 // Tracks the last state transition performed in this replca set.
-std::string lastStateTransition;
-ServerStatusMetricField<std::string> displayLastStateTransition(
-    "repl.stateTransition.lastStateTransition", &lastStateTransition);
+std::string& lastStateTransition =
+    makeServerStatusMetric<std::string>("repl.stateTransition.lastStateTransition");
 
 // Tracks the number of operations killed on state transition.
-Counter64 userOpsKilled;
-ServerStatusMetricField<Counter64> displayUserOpsKilled("repl.stateTransition.userOperationsKilled",
-                                                        &userOpsKilled);
+CounterMetric userOpsKilled("repl.stateTransition.userOperationsKilled");
 
 // Tracks the number of operations left running on state transition.
-Counter64 userOpsRunning;
-ServerStatusMetricField<Counter64> displayUserOpsRunning(
-    "repl.stateTransition.userOperationsRunning", &userOpsRunning);
+CounterMetric userOpsRunning("repl.stateTransition.userOperationsRunning");
 
 // Tracks the number of times we have successfully performed automatic reconfigs to remove
 // 'newlyAdded' fields.
-Counter64 numAutoReconfigsForRemovalOfNewlyAddedFields;
-ServerStatusMetricField<Counter64> displayNumAutoReconfigs(
-    "repl.reconfig.numAutoReconfigsForRemovalOfNewlyAddedFields",
-    &numAutoReconfigsForRemovalOfNewlyAddedFields);
+CounterMetric numAutoReconfigsForRemovalOfNewlyAddedFields(
+    "repl.reconfig.numAutoReconfigsForRemovalOfNewlyAddedFields");
 
 using namespace fmt::literals;
 
diff --git a/src/mongo/db/repl/reporter.cpp b/src/mongo/db/repl/reporter.cpp
index 138d16c54f9..c135c179877 100644
--- a/src/mongo/db/repl/reporter.cpp
+++ b/src/mongo/db/repl/reporter.cpp
@@ -28,11 +28,8 @@
  */
 
 
-#include "mongo/platform/basic.h"
-
 #include "mongo/db/repl/reporter.h"
 
-#include "mongo/base/counter.h"
 #include "mongo/bson/util/bson_extract.h"
 #include "mongo/db/commands/server_status_metric.h"
 #include "mongo/db/repl/update_position_args.h"
@@ -50,9 +47,7 @@ namespace repl {
 namespace {
 
 // The number of replSetUpdatePosition commands a node sent to its sync source.
-Counter64 numUpdatePosition;
-ServerStatusMetricField<Counter64> displayNumUpdatePosition(
-    "repl.network.replSetUpdatePosition.num", &numUpdatePosition);
+CounterMetric numUpdatePosition("repl.network.replSetUpdatePosition.num");
 
 }  // namespace
 
diff --git a/src/mongo/db/repl/topology_coordinator.cpp b/src/mongo/db/repl/topology_coordinator.cpp
index c72bb2ddfb3..e8044d24af6 100644
--- a/src/mongo/db/repl/topology_coordinator.cpp
+++ b/src/mongo/db/repl/topology_coordinator.cpp
@@ -35,8 +35,6 @@
     LOGV2_DEBUG_OPTIONS(                               \
         ID, DLEVEL, {logv2::LogComponent::kReplicationHeartbeats}, MESSAGE, ##__VA_ARGS__)
 
-#include "mongo/platform/basic.h"
-
 #include "mongo/db/repl/topology_coordinator.h"
 #include "mongo/db/repl/topology_coordinator_gen.h"
 
@@ -84,10 +82,8 @@ constexpr Milliseconds TopologyCoordinator::PingStats::UninitializedPingTime;
 
 // Tracks the number of times we decide to change sync sources in order to sync from a significantly
 // closer node.
-Counter64 numSyncSourceChangesDueToSignificantlyCloserNode;
-ServerStatusMetricField<Counter64> displayNumSyncSourceChangesDueToSignificantlyCloserNode(
-    "repl.syncSource.numSyncSourceChangesDueToSignificantlyCloserNode",
-    &numSyncSourceChangesDueToSignificantlyCloserNode);
+CounterMetric numSyncSourceChangesDueToSignificantlyCloserNode(
+    "repl.syncSource.numSyncSourceChangesDueToSignificantlyCloserNode");
 
 using namespace fmt::literals;
 
diff --git a/src/mongo/db/service_entry_point_common.cpp b/src/mongo/db/service_entry_point_common.cpp
index bc167fba693..10b0097a0b9 100644
--- a/src/mongo/db/service_entry_point_common.cpp
+++ b/src/mongo/db/service_entry_point_common.cpp
@@ -131,15 +131,11 @@ MONGO_FAIL_POINT_DEFINE(hangAfterCheckingWritabilityForMultiDocumentTransactions
 
 // Tracks the number of times a legacy unacknowledged write failed due to
 // not primary error resulted in network disconnection.
-Counter64 notPrimaryLegacyUnackWrites;
-ServerStatusMetricField<Counter64> displayNotPrimaryLegacyUnackWrites(
-    "repl.network.notPrimaryLegacyUnacknowledgedWrites", &notPrimaryLegacyUnackWrites);
+CounterMetric notPrimaryLegacyUnackWrites("repl.network.notPrimaryLegacyUnacknowledgedWrites");
 
 // Tracks the number of times an unacknowledged write failed due to not primary error
 // resulted in network disconnection.
-Counter64 notPrimaryUnackWrites;
-ServerStatusMetricField<Counter64> displayNotPrimaryUnackWrites(
-    "repl.network.notPrimaryUnacknowledgedWrites", &notPrimaryUnackWrites);
+CounterMetric notPrimaryUnackWrites("repl.network.notPrimaryUnacknowledgedWrites");
 
 namespace {
 
diff --git a/src/mongo/db/stats/api_version_metrics.cpp b/src/mongo/db/stats/api_version_metrics.cpp
index 959e5b9e3f6..bbcd3f24f37 100644
--- a/src/mongo/db/stats/api_version_metrics.cpp
+++ b/src/mongo/db/stats/api_version_metrics.cpp
@@ -27,10 +27,8 @@
  *    it in the license file.
  */
 
-#include "mongo/platform/basic.h"
-
-#include "mongo/db/commands/server_status.h"
 #include "mongo/db/stats/api_version_metrics.h"
+#include "mongo/db/commands/server_status.h"
 #include "mongo/util/duration.h"
 
 namespace mongo {
@@ -122,6 +120,9 @@ public:
             .appendAPIVersionMetricsInfo(&apiVersionBob);
         apiVersionBob.done();
     }
-} apiVersionMetricsSSM;
+};
+
+auto& apiVersionMetricsSSM =
+    addMetricToTree(std::make_unique<APIVersionMetrics::APIVersionMetricsSSM>());
 
 }  // namespace mongo
diff --git a/src/mongo/db/stats/api_version_metrics.h b/src/mongo/db/stats/api_version_metrics.h
index 6a57e0953fa..edc3d95f9e7 100644
--- a/src/mongo/db/stats/api_version_metrics.h
+++ b/src/mongo/db/stats/api_version_metrics.h
@@ -58,9 +58,9 @@ public:
 
     APIVersionMetricsMap getAPIVersionMetrics_forTest();
 
-private:
     class APIVersionMetricsSSM;
 
+private:
     void _removeStaleTimestamps(WithLock lk, Date_t now);
 
     mutable Mutex _mutex = MONGO_MAKE_LATCH("APIVersionMetrics::_mutex");
diff --git a/src/mongo/db/stats/counters.h b/src/mongo/db/stats/counters.h
index cbf429127f6..815a6856772 100644
--- a/src/mongo/db/stats/counters.h
+++ b/src/mongo/db/stats/counters.h
@@ -302,10 +302,8 @@ class AggStageCounters {
 public:
     // Container for a stage count metric along with its corresponding counter.
     struct StageCounter {
-        StageCounter(StringData name) : metric("aggStageCounters." + name, &counter) {}
-
-        Counter64 counter;
-        ServerStatusMetricField<Counter64> metric;
+        StageCounter(StringData name) : counter("aggStageCounters." + name) {}
+        CounterMetric counter;
     };
 
     // Map of aggregation stages to the number of occurrences.
@@ -316,10 +314,6 @@ extern AggStageCounters aggStageCounters;
 
 class DotsAndDollarsFieldsCounters {
 public:
-    DotsAndDollarsFieldsCounters()
-        : insertMetric("dotsAndDollarsFields.inserts", &inserts),
-          updateMetric("dotsAndDollarsFields.updates", &updates) {}
-
     void incrementForUpsert(bool didInsert) {
         if (didInsert) {
             inserts.increment();
@@ -328,28 +322,15 @@ public:
         }
     }
 
-    Counter64 inserts;
-    Counter64 updates;
-    ServerStatusMetricField<Counter64> insertMetric;
-    ServerStatusMetricField<Counter64> updateMetric;
+    CounterMetric inserts{"dotsAndDollarsFields.inserts"};
+    CounterMetric updates{"dotsAndDollarsFields.updates"};
 };
 
 extern DotsAndDollarsFieldsCounters dotsAndDollarsFieldsCounters;
 
 class QueryEngineCounters {
 public:
-    QueryEngineCounters()
-        : sbeFindQueryMetric("query.queryExecutionEngine.find.sbe", &sbeFindQueryCounter),
-          classicFindQueryMetric("query.queryExecutionEngine.find.classic",
-                                 &classicFindQueryCounter),
-          sbeOnlyAggregationMetric("query.queryExecutionEngine.aggregate.sbeOnly",
-                                   &sbeOnlyAggregationCounter),
-          classicOnlyAggregationMetric("query.queryExecutionEngine.aggregate.classicOnly",
-                                       &classicOnlyAggregationCounter),
-          sbeHybridAggregationMetric("query.queryExecutionEngine.aggregate.sbeHybrid",
-                                     &sbeHybridAggregationCounter),
-          classicHybridAggregationMetric("query.queryExecutionEngine.aggregate.classicHybrid",
-                                         &classicHybridAggregationCounter) {}
+    QueryEngineCounters() = default;
 
     void incrementQueryEngineCounters(CurOp* curop) {
         auto& debug = curop->debug();
@@ -381,21 +362,17 @@ public:
     // Query counters that record whether a find query was fully or partially executed in SBE, or
     // fully executed using the classic engine. One or the other will always be incremented during a
     // query.
-    Counter64 sbeFindQueryCounter;
-    Counter64 classicFindQueryCounter;
-    ServerStatusMetricField<Counter64> sbeFindQueryMetric;
-    ServerStatusMetricField<Counter64> classicFindQueryMetric;
+    CounterMetric sbeFindQueryCounter{"query.queryExecutionEngine.find.sbe"};
+    CounterMetric classicFindQueryCounter{"query.queryExecutionEngine.find.classic"};
+
     // Aggregation query counters that record whether an aggregation was fully or partially executed
     // in DocumentSource (an sbe/classic hybrid plan), or fully pushed down to the sbe/classic
     // layer. Only incremented during aggregations.
-    Counter64 sbeOnlyAggregationCounter;
-    Counter64 classicOnlyAggregationCounter;
-    Counter64 sbeHybridAggregationCounter;
-    Counter64 classicHybridAggregationCounter;
-    ServerStatusMetricField<Counter64> sbeOnlyAggregationMetric;
-    ServerStatusMetricField<Counter64> classicOnlyAggregationMetric;
-    ServerStatusMetricField<Counter64> sbeHybridAggregationMetric;
-    ServerStatusMetricField<Counter64> classicHybridAggregationMetric;
+    CounterMetric sbeOnlyAggregationCounter{"query.queryExecutionEngine.aggregate.sbeOnly"};
+    CounterMetric classicOnlyAggregationCounter{"query.queryExecutionEngine.aggregate.classicOnly"};
+    CounterMetric sbeHybridAggregationCounter{"query.queryExecutionEngine.aggregate.sbeHybrid"};
+    CounterMetric classicHybridAggregationCounter{
+        "query.queryExecutionEngine.aggregate.classicHybrid"};
 };
 extern QueryEngineCounters queryEngineCounters;
 
@@ -405,9 +382,8 @@ extern QueryEngineCounters queryEngineCounters;
 class OperatorCounters {
 private:
     struct ExprCounter {
-        ExprCounter(const std::string name) : metric(name, &counter) {}
-        Counter64 counter;
-        ServerStatusMetricField<Counter64> metric;
+        ExprCounter(const std::string& name) : counter(name) {}
+        CounterMetric counter;
     };
 
 public:
diff --git a/src/mongo/db/ttl.cpp b/src/mongo/db/ttl.cpp
index 1bd928185b8..73f3727776a 100644
--- a/src/mongo/db/ttl.cpp
+++ b/src/mongo/db/ttl.cpp
@@ -28,11 +28,8 @@
  */
 
 
-#include "mongo/platform/basic.h"
-
 #include "mongo/db/ttl.h"
 
-#include "mongo/base/counter.h"
 #include "mongo/db/auth/authorization_session.h"
 #include "mongo/db/auth/user_name.h"
 #include "mongo/db/catalog/collection.h"
@@ -197,14 +194,10 @@ MONGO_FAIL_POINT_DEFINE(hangTTLMonitorBetweenPasses);
 // consist of multiple sub-passes. Each sub-pass deletes all the expired documents it can up to
 // 'ttlSubPassTargetSecs'. It is possible for a sub-pass to complete before all expired documents
 // have been removed.
-Counter64 ttlPasses;
-Counter64 ttlSubPasses;
-Counter64 ttlDeletedDocuments;
-
-ServerStatusMetricField<Counter64> ttlPassesDisplay("ttl.passes", &ttlPasses);
-ServerStatusMetricField<Counter64> ttlSubPassesDisplay("ttl.subPasses", &ttlSubPasses);
-ServerStatusMetricField<Counter64> ttlDeletedDocumentsDisplay("ttl.deletedDocuments",
-                                                              &ttlDeletedDocuments);
+CounterMetric ttlPasses("ttl.passes");
+CounterMetric ttlSubPasses("ttl.subPasses");
+CounterMetric ttlDeletedDocuments("ttl.deletedDocuments");
+
 using MtabType = TenantMigrationAccessBlocker::BlockerType;
 
 TTLMonitor* TTLMonitor::get(ServiceContext* serviceCtx) {
diff --git a/src/mongo/db/write_concern.cpp b/src/mongo/db/write_concern.cpp
index 352deaad024..a0255dc5aa6 100644
--- a/src/mongo/db/write_concern.cpp
+++ b/src/mongo/db/write_concern.cpp
@@ -28,11 +28,8 @@
  */
 
 
-#include "mongo/platform/basic.h"
-
 #include "mongo/db/write_concern.h"
 
-#include "mongo/base/counter.h"
 #include "mongo/bson/util/bson_extract.h"
 #include "mongo/db/client.h"
 #include "mongo/db/commands/server_status_metric.h"
@@ -60,20 +57,10 @@ namespace mongo {
 using repl::OpTime;
 using std::string;
 
-static TimerStats gleWtimeStats;
-static ServerStatusMetricField<TimerStats> displayGleLatency("getLastError.wtime", &gleWtimeStats);
-
-static Counter64 gleWtimeouts;
-static ServerStatusMetricField<Counter64> gleWtimeoutsDisplay("getLastError.wtimeouts",
-                                                              &gleWtimeouts);
-
-static Counter64 gleDefaultWtimeouts;
-static ServerStatusMetricField<Counter64> gleDefaultWtimeoutsDisplay(
-    "getLastError.default.wtimeouts", &gleDefaultWtimeouts);
-
-static Counter64 gleDefaultUnsatisfiable;
-static ServerStatusMetricField<Counter64> gleDefaultUnsatisfiableDisplay(
-    "getLastError.default.unsatisfiable", &gleDefaultUnsatisfiable);
+static TimerStats& gleWtimeStats = makeServerStatusMetric<TimerStats>("getLastError.wtime");
+static CounterMetric gleWtimeouts("getLastError.wtimeouts");
+static CounterMetric gleDefaultWtimeouts("getLastError.default.wtimeouts");
+static CounterMetric gleDefaultUnsatisfiable("getLastError.default.unsatisfiable");
 
 MONGO_FAIL_POINT_DEFINE(hangBeforeWaitingForWriteConcern);
 
diff --git a/src/mongo/s/chunk_manager_targeter.cpp b/src/mongo/s/chunk_manager_targeter.cpp
index 6e6a6bf79e3..bec32dfd8c4 100644
--- a/src/mongo/s/chunk_manager_targeter.cpp
+++ b/src/mongo/s/chunk_manager_targeter.cpp
@@ -28,11 +28,8 @@
  */
 
 
-#include "mongo/platform/basic.h"
-
 #include "mongo/s/chunk_manager_targeter.h"
 
-#include "mongo/base/counter.h"
 #include "mongo/db/commands/server_status_metric.h"
 #include "mongo/db/curop.h"
 #include "mongo/db/matcher/extensions_callback_noop.h"
@@ -75,9 +72,8 @@ using UpdateType = write_ops::UpdateModification::Type;
 
 // Tracks the number of {multi:false} updates with an exact match on _id that are broadcasted to
 // multiple shards.
-Counter64 updateOneOpStyleBroadcastWithExactIDCount;
-ServerStatusMetricField<Counter64> updateOneOpStyleBroadcastWithExactIDStats(
-    "query.updateOneOpStyleBroadcastWithExactIDCount", &updateOneOpStyleBroadcastWithExactIDCount);
+CounterMetric updateOneOpStyleBroadcastWithExactIDCount(
+    "query.updateOneOpStyleBroadcastWithExactIDCount");
 
 /**
  * Update expressions are bucketed into one of two types for the purposes of shard targeting:
diff --git a/src/mongo/s/cluster_cursor_stats.cpp b/src/mongo/s/cluster_cursor_stats.cpp
index bb61b9647da..46ae32f88cd 100644
--- a/src/mongo/s/cluster_cursor_stats.cpp
+++ b/src/mongo/s/cluster_cursor_stats.cpp
@@ -27,8 +27,6 @@
  *    it in the license file.
  */
 
-#include "mongo/platform/basic.h"
-
 #include "mongo/db/commands/server_status_metric.h"
 #include "mongo/s/grid.h"
 #include "mongo/s/query/cluster_cursor_manager.h"
@@ -62,8 +60,9 @@ public:
         }
         cursorBob.done();
     }
+};
 
-} clusterCursorStats;
+ClusterCursorStats& clusterCursorStats = addMetricToTree(std::make_unique<ClusterCursorStats>());
 
 }  // namespace
 }  // namespace mongo
diff --git a/src/mongo/s/query/cluster_client_cursor_impl.cpp b/src/mongo/s/query/cluster_client_cursor_impl.cpp
index 73be5a7512a..b08a807788c 100644
--- a/src/mongo/s/query/cluster_client_cursor_impl.cpp
+++ b/src/mongo/s/query/cluster_client_cursor_impl.cpp
@@ -27,8 +27,6 @@
  *    it in the license file.
  */
 
-#include "mongo/platform/basic.h"
-
 #include "mongo/s/query/cluster_client_cursor_impl.h"
 
 #include <memory>
@@ -41,12 +39,8 @@
 
 namespace mongo {
 
-static Counter64 mongosCursorStatsTotalOpened;
-static Counter64 mongosCursorStatsMoreThanOneBatch;
-static ServerStatusMetricField<Counter64> displayMongosCursorStatsTotalOpened(
-    "mongos.cursor.totalOpened", &mongosCursorStatsTotalOpened);
-static ServerStatusMetricField<Counter64> displayMongosCursorStatsMoreThanOneBatch(
-    "mongos.cursor.moreThanOneBatch", &mongosCursorStatsMoreThanOneBatch);
+static CounterMetric mongosCursorStatsTotalOpened("mongos.cursor.totalOpened");
+static CounterMetric mongosCursorStatsMoreThanOneBatch("mongos.cursor.moreThanOneBatch");
 
 ClusterClientCursorGuard ClusterClientCursorImpl::make(
     OperationContext* opCtx,