SERVER-40811 make initializers throwy

- Consolidate init-related headers (just init.h and initializer.h)
- Factor out a separate DependencyGraph component
- Remove MONGO_DEFAULT_PREREQUISITES, MONGO_NO_PREREQUISITES, MONGO_NO_DEPENDENTS.
- Document the role of the "default" initializer.

157 files changed, 1222 insertions, 2071 deletions

diff --git a/src/mongo/SConscript b/src/mongo/SConscript
index 6f1548ddc31..df43a86dd71 100644
--- a/src/mongo/SConscript
+++ b/src/mongo/SConscript
@@ -157,13 +157,11 @@ baseEnv.Library(
         'base/data_type.cpp',
         'base/data_type_string_data.cpp',
         'base/data_type_terminated.cpp',
+        'base/dependency_graph.cpp',
         'base/error_codes.cpp',
         'base/error_extra_info.cpp',
-        'base/global_initializer.cpp',
-        'base/global_initializer_registerer.cpp',
         'base/init.cpp',
         'base/initializer.cpp',
-        'base/initializer_dependency_graph.cpp',
         'base/parse_number.cpp',
         'base/shim.cpp',
         'base/simple_string_data_comparator.cpp',
diff --git a/src/mongo/base/SConscript b/src/mongo/base/SConscript
index 643a5c1d839..7909ef0c396 100644
--- a/src/mongo/base/SConscript
+++ b/src/mongo/base/SConscript
@@ -83,8 +83,8 @@ env.CppUnitTest(
         'data_type_terminated_test.cpp',
         'data_type_validated_test.cpp',
         'data_view_test.cpp',
+        'dependency_graph_test.cpp',
         'encoded_value_storage_test.cpp',
-        'initializer_dependency_graph_test.cpp',
         'initializer_test.cpp',
         'murmurhash3_test.cpp',
         'owned_pointer_map_test.cpp',
diff --git a/src/mongo/base/deinitializer_context.h b/src/mongo/base/deinitializer_context.h
deleted file mode 100644
index 370b5c5526d..00000000000
--- a/src/mongo/base/deinitializer_context.h
+++ /dev/null
@@ -1,50 +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 "mongo/db/service_context_fwd.h"
-
-#include <map>
-#include <string>
-#include <vector>
-
-namespace mongo {
-/**
- * Context of a deinitialization process. Passed as a parameter to deinitialization functions.
- *
- * See mongo/base/initializer.h and mongo/base/initializer_dependency_graph.h for more details.
- */
-class DeinitializerContext {
-public:
-    DeinitializerContext(DeinitializerContext const&) = delete;
-    DeinitializerContext& operator=(DeinitializerContext const&) = delete;
-};
-
-}  // namespace mongo
diff --git a/src/mongo/base/initializer_dependency_graph.cpp b/src/mongo/base/dependency_graph.cpp
index 24239cb4057..8d9107b5a10 100644
--- a/src/mongo/base/initializer_dependency_graph.cpp
+++ b/src/mongo/base/dependency_graph.cpp
@@ -1,5 +1,5 @@
 /**
- *    Copyright (C) 2018-present MongoDB, Inc.
+ *    Copyright (C) 2020-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,
@@ -27,10 +27,11 @@
  *    it in the license file.
  */
 
-#include "mongo/base/initializer_dependency_graph.h"
+#include "mongo/base/dependency_graph.h"
 
 #include <algorithm>
 #include <fmt/format.h>
+#include <fmt/ranges.h>
 #include <iostream>
 #include <iterator>
 #include <random>
@@ -41,50 +42,27 @@
 
 namespace mongo {
 
-using namespace fmt::literals;
-
-InitializerDependencyGraph::InitializerDependencyGraph() {}
-InitializerDependencyGraph::~InitializerDependencyGraph() {}
-
-Status InitializerDependencyGraph::addInitializer(std::string name,
-                                                  InitializerFunction initFn,
-                                                  DeinitializerFunction deinitFn,
-                                                  std::vector<std::string> prerequisites,
-                                                  std::vector<std::string> dependents) {
-    if (!initFn)
-        return Status(ErrorCodes::BadValue, "Illegal to supply a NULL function");
-
-    invariant(!frozen());
-
-    InitializerDependencyNode& newNode = _nodes[name];
-    if (newNode.initFn) {
-        return Status(ErrorCodes::Error(50999), name);
-    }
-
-    newNode.initFn = std::move(initFn);
-    newNode.deinitFn = std::move(deinitFn);
-
-    for (size_t i = 0; i < prerequisites.size(); ++i) {
-        newNode.prerequisites.insert(prerequisites[i]);
-    }
-
-    for (size_t i = 0; i < dependents.size(); ++i) {
-        _nodes[dependents[i]].prerequisites.insert(name);
+void DependencyGraph::addNode(std::string name,
+                              std::vector<std::string> prerequisites,
+                              std::vector<std::string> dependents,
+                              std::unique_ptr<Payload> payload) {
+    if (!payload) {
+        struct DummyPayload : Payload {};
+        payload = std::make_unique<DummyPayload>();
     }
-
-    return Status::OK();
-}
-
-InitializerDependencyNode* InitializerDependencyGraph::getInitializerNode(const std::string& name) {
-    NodeMap::iterator iter = _nodes.find(name);
-    if (iter == _nodes.end())
-        return nullptr;
-
-    return &iter->second;
+    auto& newNode = _nodes[name];
+    uassert(ErrorCodes::Error(50999), name, !newNode.payload);  // collision
+    for (auto& otherNode : prerequisites)
+        newNode.prerequisites.insert(otherNode);
+    for (auto& otherNode : dependents)
+        _nodes[otherNode].prerequisites.insert(name);
+    newNode.payload = std::move(payload);
 }
 
 namespace {
 
+using namespace fmt::literals;
+
 template <typename Seq>
 void strAppendJoin(std::string& out, StringData separator, const Seq& sequence) {
     StringData currSep;
@@ -95,26 +73,28 @@ void strAppendJoin(std::string& out, StringData separator, const Seq& sequence)
     }
 }
 
-// In the case of a cycle, copy the cycle into `names`.
-// It's undocumented behavior, but it's cheap and a test wants it.
+// In the case of a cycle, copy the cycle node names into `*cycle`.
 template <typename Iter>
-void throwGraphContainsCycle(Iter first, Iter last, std::vector<std::string>& names) {
-    std::string desc = "Cycle in dependency graph: ";
+void throwGraphContainsCycle(Iter first, Iter last, std::vector<std::string>* cycle) {
+    std::vector<std::string> names;
     std::transform(first, last, std::back_inserter(names), [](auto& e) { return e->name(); });
-    names.push_back((*first)->name());  // Tests awkwardly want first element to be repeated.
-    strAppendJoin(desc, " -> ", names);
-    uasserted(ErrorCodes::GraphContainsCycle, desc);
+    if (cycle)
+        *cycle = names;
+    names.push_back((*first)->name());
+    uasserted(ErrorCodes::GraphContainsCycle,
+              format(FMT_STRING("Cycle in dependency graph: {}"), fmt::join(names, " -> ")));
 }
+
 }  // namespace
 
-Status InitializerDependencyGraph::topSort(std::vector<std::string>* sortedNames) const try {
+std::vector<std::string> DependencyGraph::topSort(std::vector<std::string>* cycle) const {
     // Topological sort via repeated depth-first traversal.
     // All nodes must have an initFn before running topSort, or we return BadValue.
     struct Element {
         const std::string& name() const {
-            return node->first;
+            return nodeIter->first;
         }
-        const Node* node;
+        stdx::unordered_map<std::string, Node>::const_iterator nodeIter;
         std::vector<Element*> children;
         std::vector<Element*>::iterator membership;  // Position of this in `elements`.
     };
@@ -131,13 +111,12 @@ Status InitializerDependencyGraph::topSort(std::vector<std::string>* sortedNames
     };
 
     elementsStore.reserve(_nodes.size());
-    std::transform(
-        _nodes.begin(), _nodes.end(), std::back_inserter(elementsStore), [](const Node& n) {
-            uassert(ErrorCodes::BadValue,
-                    "No implementation provided for initializer {}"_format(n.first),
-                    n.second.initFn);
-            return Element{&n};
-        });
+    for (auto iter = _nodes.begin(); iter != _nodes.end(); ++iter) {
+        uassert(ErrorCodes::BadValue,
+                "node {} was mentioned but never added"_format(iter->first),
+                iter->second.payload);
+        elementsStore.push_back(Element{iter});
+    }
 
     // Wire up all the child relationships by pointer rather than by string names.
     {
@@ -145,15 +124,15 @@ Status InitializerDependencyGraph::topSort(std::vector<std::string>* sortedNames
         for (Element& e : elementsStore)
             byName[e.name()] = &e;
         for (Element& element : elementsStore) {
-            const auto& prereqs = element.node->second.prerequisites;
+            const auto& prereqs = element.nodeIter->second.prerequisites;
             std::transform(prereqs.begin(),
                            prereqs.end(),
                            std::back_inserter(element.children),
                            [&](StringData childName) {
                                auto iter = byName.find(childName);
                                uassert(ErrorCodes::BadValue,
-                                       "Initializer {} depends on missing initializer {}"_format(
-                                           element.node->first, childName),
+                                       "node {} depends on missing node {}"_format(
+                                           element.nodeIter->first, childName),
                                        iter != byName.end());
                                return iter->second;
                            });
@@ -203,23 +182,25 @@ Status InitializerDependencyGraph::topSort(std::vector<std::string>* sortedNames
             if (picked->membership < unsortedBegin)
                 continue;
             if (picked->membership >= unsortedEnd) {  // O(1) cycle detection
-                sortedNames->clear();
-                throwGraphContainsCycle(unsortedEnd, elements.end(), *sortedNames);
+                throwGraphContainsCycle(unsortedEnd, elements.end(), cycle);
             }
             swapPositions(**--unsortedEnd, *picked);  // unsorted push to stack
             continue;
         }
         swapPositions(**unsortedEnd++, **unsortedBegin++);  // pop from stack to sorted
     }
-    sortedNames->clear();
-    sortedNames->reserve(_nodes.size());
+    std::vector<std::string> sortedNames;
+    sortedNames.reserve(_nodes.size());
     std::transform(elements.begin(),
                    elements.end(),
-                   std::back_inserter(*sortedNames),
+                   std::back_inserter(sortedNames),
                    [](const Element* e) { return e->name(); });
-    return Status::OK();
-} catch (const DBException& ex) {
-    return ex.toStatus();
+    return sortedNames;
+}
+
+DependencyGraph::Payload* DependencyGraph::find(const std::string& name) {
+    auto iter = _nodes.find(name);
+    return (iter == _nodes.end()) ? nullptr : iter->second.payload.get();
 }
 
 }  // namespace mongo
diff --git a/src/mongo/base/dependency_graph.h b/src/mongo/base/dependency_graph.h
new file mode 100644
index 00000000000..e734dc17f9a
--- /dev/null
+++ b/src/mongo/base/dependency_graph.h
@@ -0,0 +1,99 @@
+/**
+ *    Copyright (C) 2020-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 <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "mongo/base/status.h"
+#include "mongo/stdx/unordered_map.h"
+#include "mongo/stdx/unordered_set.h"
+
+namespace mongo {
+
+/**
+ * To separate concerns, this just captures the setup and execution of a
+ * topological sort without regard to higher-level semantics like process
+ * initialization. Each node is mapped to an abstract Data payload.
+ */
+class DependencyGraph {
+public:
+    class Payload {
+    public:
+        virtual ~Payload() = default;
+    };
+
+    /**
+     * Add a new initializer node, named `name`, to the dependency graph,
+     * having the given `prerequisites` and `dependents`, which are the names
+     * of other nodes which will be in the graph when `topSort` is called.
+     *
+     * The new node can be mapped to an abstract `payload`, which can
+     * be retrieved with `find`.
+     *
+     * Note that cycles in the dependency graph are not discovered by this function.
+     * Rather, they're discovered by `topSort`, below.
+     */
+    void addNode(std::string name,
+                 std::vector<std::string> prerequisites,
+                 std::vector<std::string> dependents,
+                 std::unique_ptr<Payload> payload = nullptr);
+
+    /**
+     * Returns a topological sort of the dependency graph, represented
+     * as an ordered vector of node names.
+     *
+     * Throws with `ErrorCodes::GraphContainsCycle` if the graph contains a cycle.
+     * If a `cycle` is given, it will be overwritten with the node sequence involved.
+     *
+     * Throws with `ErrorCodes::BadValue` if any node in the graph names a
+     * prerequisite that is missing from the graph.
+     */
+    std::vector<std::string> topSort(std::vector<std::string>* cycle = nullptr) const;
+
+    Payload* find(const std::string& name);
+
+private:
+    struct Node {
+        stdx::unordered_set<std::string> prerequisites;
+        std::unique_ptr<Payload> payload;
+    };
+
+    /**
+     * Map of all named nodes.  Nodes named as prerequisites or dependents but not explicitly
+     * added via addInitializer will either be absent from this map or be present with
+     * NodeData::fn set to a false-ish value.
+     */
+    stdx::unordered_map<std::string, Node> _nodes;
+};
+
+}  // namespace mongo
diff --git a/src/mongo/base/dependency_graph_test.cpp b/src/mongo/base/dependency_graph_test.cpp
new file mode 100644
index 00000000000..b79533bc081
--- /dev/null
+++ b/src/mongo/base/dependency_graph_test.cpp
@@ -0,0 +1,279 @@
+/**
+ *    Copyright (C) 2020-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.
+ */
+
+/**
+ * Unit tests of the DependencyGraph type.
+ */
+
+#include <algorithm>
+#include <string>
+#include <vector>
+
+#include <fmt/ranges.h>
+
+#include "mongo/base/dependency_graph.h"
+#include "mongo/base/init.h"
+#include "mongo/unittest/unittest.h"
+
+namespace mongo {
+namespace {
+
+template <typename C, typename T>
+size_t count(const C& c, const T& value) {
+    return std::count(c.begin(), c.end(), value);
+}
+
+TEST(DependencyGraphTest, InsertNullPayloadOkay) {
+    DependencyGraph graph;
+    graph.addNode("A", {}, {});
+}
+
+TEST(DependencyGraphTest, InsertSameNameTwiceFails) {
+    DependencyGraph graph;
+    graph.addNode("A", {}, {});
+    ASSERT_THROWS_CODE(graph.addNode("A", {}, {}), DBException, 50999);
+}
+
+TEST(DependencyGraphTest, TopSortEmptyGraph) {
+    DependencyGraph graph;
+    std::vector<std::string> nodeNames = graph.topSort();
+    ASSERT_EQUALS(nodeNames.size(), 0u);
+}
+
+TEST(DependencyGraphTest, TopSortGraphNoDeps) {
+    DependencyGraph graph;
+    graph.addNode("A", {}, {});
+    graph.addNode("B", {}, {});
+    graph.addNode("C", {}, {});
+    auto nodeNames = graph.topSort();
+    ASSERT_EQ(nodeNames.size(), 3);
+    ASSERT_EQ(count(nodeNames, "A"), 1);
+    ASSERT_EQ(count(nodeNames, "B"), 1);
+    ASSERT_EQ(count(nodeNames, "C"), 1);
+}
+
+/**
+ * Verify a node order for the diamond topology used in several tests.
+ * Specifically, this graph:
+ *
+ * A
+ * |
+ * +->B
+ * |  |
+ * +---->C
+ *    |  |
+ *    +--+->D
+ *
+ * `B` and `C` have no order relative to each other, but both must
+ * happen after `A` and before `D`.
+ */
+void checkDiamondTopology(const std::vector<std::string>& nodeNames) {
+    ASSERT_STRING_SEARCH_REGEX(
+        fmt::format("{}", fmt::join(nodeNames.begin(), nodeNames.end(), " ")), "^A (B C|C B) D$");
+}
+
+TEST(DependencyGraphTest, TopSortWithDiamondPrerequisites) {
+    /*
+     * Top-sorting a simple diamond specified using prerequisites.
+     * See checkDiamondTopology for topology.
+     */
+    DependencyGraph graph;
+    graph.addNode("A", {}, {});
+    graph.addNode("B", {"A"}, {});
+    graph.addNode("C", {"A"}, {});
+    graph.addNode("D", {"B", "C"}, {});
+    checkDiamondTopology(graph.topSort());
+}
+
+TEST(DependencyGraphTest, TopSortWithDiamondDependents) {
+    /*
+     * Same diamond topology as preceding test, but specified using dependents.
+     */
+    DependencyGraph graph;
+    graph.addNode("A", {}, {"B", "C"});
+    graph.addNode("B", {}, {"D"});
+    graph.addNode("C", {}, {"D"});
+    graph.addNode("D", {}, {});
+    checkDiamondTopology(graph.topSort());
+}
+
+TEST(DependencyGraphTest, TopSortWithDiamondGeneral1) {
+    /*
+     * Same diamond topology, specified completely by prerequisites and
+     * dependents declared on B and C.
+     */
+    DependencyGraph graph;
+    graph.addNode("A", {}, {});
+    graph.addNode("B", {"A"}, {"D"});
+    graph.addNode("C", {"A"}, {"D"});
+    graph.addNode("D", {}, {});
+    checkDiamondTopology(graph.topSort());
+}
+
+TEST(DependencyGraphTest, TopSortWithDiamondGeneral2) {
+    /*
+     * Same diamond topology, specified completely by prerequisites and
+     * dependents declared on A and D.
+     */
+    DependencyGraph graph;
+    graph.addNode("A", {}, {"B", "C"});
+    graph.addNode("B", {}, {});
+    graph.addNode("C", {}, {});
+    graph.addNode("D", {"C", "B"}, {});
+    checkDiamondTopology(graph.topSort());
+}
+
+TEST(DependencyGraphTest, TopSortWithDiamondGeneral3) {
+    /*
+     * Same diamond topology, specified by redundant but coherent constraints.
+     */
+    DependencyGraph graph;
+    graph.addNode("A", {}, {"B", "C"});
+    graph.addNode("B", {"A"}, {"D"});
+    graph.addNode("C", {"A"}, {"D"});
+    graph.addNode("D", {"C", "B"}, {});
+    checkDiamondTopology(graph.topSort());
+}
+
+TEST(DependencyGraphTest, TopSortWithDiamondAndCycle) {
+    /*
+     * Cyclic graph. Should fail.
+     *
+     * A
+     * |
+     * +->B<-------+
+     * |  |        |
+     * +---->C     |
+     *    |  |     |
+     *    +--+->D  |
+     *          |  |
+     *          +->E
+     */
+    DependencyGraph graph;
+    graph.addNode("A", {}, {"B", "C"});
+    graph.addNode("B", {}, {});
+    graph.addNode("C", {}, {});
+    graph.addNode("D", {"C", "B"}, {});
+    graph.addNode("E", {"D"}, {"B"});
+
+    std::vector<std::string> cycle;
+    auto check = [](auto&& ex) {
+        ASSERT_EQ(ex.code(), ErrorCodes::GraphContainsCycle) << ex.toString();
+    };
+    ASSERT_THROWS_WITH_CHECK(graph.topSort(&cycle), DBException, check);
+    ASSERT_EQ(cycle.size(), 3);
+    ASSERT_EQ(count(cycle, "B"), 1);
+    ASSERT_EQ(count(cycle, "D"), 1);
+    ASSERT_EQ(count(cycle, "E"), 1);
+}
+
+TEST(DependencyGraphTest, TopSortFailsWhenMissingPrerequisite) {
+    /*
+     * If a node names a never-declared prerequisite, topSort should fail.
+     */
+    DependencyGraph graph;
+    graph.addNode("B", {"A"}, {});
+    auto check = [&](const DBException& ex) {
+        ASSERT_EQ(ex.code(), ErrorCodes::BadValue) << ex.toString();
+        ASSERT_STRING_CONTAINS(ex.reason(), "node B depends on missing node A");
+    };
+    ASSERT_THROWS_WITH_CHECK(graph.topSort(), DBException, check);
+}
+
+TEST(DependencyGraphTest, TopSortFailsWhenMissingDependent) {
+    /*
+     * If a node names a never-declared dependent, topSort should fail.
+     */
+    DependencyGraph graph;
+    graph.addNode("A", {}, {"B"});
+    auto check = [](const DBException& ex) {
+        ASSERT_EQ(ex.code(), ErrorCodes::BadValue) << ex.toString();
+        ASSERT_STRING_CONTAINS(ex.reason(), "node B was mentioned but never added");
+    };
+    ASSERT_THROWS_WITH_CHECK(graph.topSort(), DBException, check);
+}
+
+std::vector<std::vector<std::string>> allPermutations(std::vector<std::string> vec,
+                                                      size_t first,
+                                                      size_t last) {
+    std::vector<std::vector<std::string>> out;
+    auto i1 = vec.begin() + first;
+    auto i2 = vec.begin() + last;
+    std::sort(i1, i2);
+    do {
+        out.push_back(vec);
+    } while (std::next_permutation(i1, i2));
+    return out;
+}
+
+template <typename Expectations, typename F>
+void doUntilAllSeen(const Expectations& expected, F&& f) {
+    std::vector<int> seen(expected.size(), 0);
+    while (std::find(seen.begin(), seen.end(), 0) != seen.end()) {
+        auto found = std::find(expected.begin(), expected.end(), f());
+        ASSERT_TRUE(found != expected.end());
+        ++seen[found - expected.begin()];
+    }
+}
+
+TEST(DependencyGraphTest, TopSortShufflesNodes) {
+    /*
+     * Make sure all node orderings can appear as outputs.
+     */
+    DependencyGraph graph;
+    std::vector<std::string> graphNodes;
+    for (int i = 0; i < 5; ++i) {
+        std::string s = "Node" + std::to_string(i);
+        graphNodes.push_back(s);
+        graph.addNode(s, {}, {});
+    }
+    doUntilAllSeen(allPermutations(graphNodes, 0, graphNodes.size()),
+                   [&] { return graph.topSort(); });
+}
+
+TEST(DependencyGraphTest, TopSortShufflesChildren) {
+    /*
+     * Make sure all child orderings can appear as outputs.
+     */
+    DependencyGraph graph;
+    std::vector<std::string> graphNodes;
+    graphNodes.push_back("Parent");
+    graph.addNode("Parent", {}, {});
+    for (int i = 0; i < 5; ++i) {
+        std::string s = "Child" + std::to_string(i);
+        graphNodes.push_back(s);
+        graph.addNode(s, {"Parent"}, {});
+    }
+    // Permute only the children.
+    doUntilAllSeen(allPermutations(graphNodes, 1, graphNodes.size()),
+                   [&] { return graph.topSort(); });
+}
+
+}  // namespace
+}  // namespace mongo
diff --git a/src/mongo/base/error_extra_info.h b/src/mongo/base/error_extra_info.h
index 9b64de8427d..c8a05f184ef 100644
--- a/src/mongo/base/error_extra_info.h
+++ b/src/mongo/base/error_extra_info.h
@@ -100,12 +100,10 @@ private:
  * You must separately #include "mongo/base/init.h" since including it here would create an include
  * cycle.
  */
-#define MONGO_INIT_REGISTER_ERROR_EXTRA_INFO(type)                            \
-    MONGO_INITIALIZER_GENERAL(                                                \
-        RegisterErrorExtraInfoFor##type, MONGO_NO_PREREQUISITES, ("default")) \
-    (InitializerContext * context) {                                          \
-        ErrorExtraInfo::registerType<type>();                                 \
-        return Status::OK();                                                  \
+#define MONGO_INIT_REGISTER_ERROR_EXTRA_INFO(type)                              \
+    MONGO_INITIALIZER_GENERAL(RegisterErrorExtraInfoFor##type, (), ("default")) \
+    (InitializerContext*) {                                                     \
+        ErrorExtraInfo::registerType<type>();                                   \
     }
 
 /**
diff --git a/src/mongo/base/global_initializer.cpp b/src/mongo/base/global_initializer.cpp
deleted file mode 100644
index 28639544668..00000000000
--- a/src/mongo/base/global_initializer.cpp
+++ /dev/null
@@ -1,51 +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/base/global_initializer.h"
-
-#include "mongo/base/initializer.h"
-
-namespace mongo {
-
-Initializer& getGlobalInitializer() {
-    static Initializer theGlobalInitializer;
-    return theGlobalInitializer;
-}
-
-namespace {
-
-// Make sure that getGlobalInitializer() is called at least once before main(), and so at least
-// once in a single-threaded context.  Otherwise, static initialization inside
-// getGlobalInitializer() won't be thread-safe.
-MONGO_COMPILER_VARIABLE_UNUSED const Initializer* const _theGlobalInitializer =
-    &getGlobalInitializer();
-
-}  // namespace
-
-}  // namespace mongo
diff --git a/src/mongo/base/global_initializer.h b/src/mongo/base/global_initializer.h
deleted file mode 100644
index 53c0ceacdb2..00000000000
--- a/src/mongo/base/global_initializer.h
+++ /dev/null
@@ -1,43 +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
-
-namespace mongo {
-class Initializer;
-
-/**
- * Get the process-global initializer object.
- *
- * See mongo/base/initializer.h and mongo/base/init.h for information about process
- * initialization in mongo applications.
- */
-Initializer& getGlobalInitializer();
-
-}  // namespace mongo
diff --git a/src/mongo/base/global_initializer_registerer.cpp b/src/mongo/base/global_initializer_registerer.cpp
deleted file mode 100644
index f12a05fdc58..00000000000
--- a/src/mongo/base/global_initializer_registerer.cpp
+++ /dev/null
@@ -1,68 +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/base/global_initializer_registerer.h"
-
-#include <cstdlib>
-#include <iostream>
-
-#include "mongo/base/global_initializer.h"
-#include "mongo/base/initializer.h"
-
-namespace mongo {
-
-GlobalInitializerRegisterer::GlobalInitializerRegisterer(std::string name,
-                                                         InitializerFunction initFn,
-                                                         DeinitializerFunction deinitFn,
-                                                         std::vector<std::string> prerequisites,
-                                                         std::vector<std::string> dependents) {
-    Status status = getGlobalInitializer().getInitializerDependencyGraph().addInitializer(
-        std::move(name),
-        std::move(initFn),
-        std::move(deinitFn),
-        std::move(prerequisites),
-        std::move(dependents));
-
-    if (Status::OK() != status) {
-        std::cerr << "Attempt to add global initializer failed, status: " << status << std::endl;
-        ::abort();
-    }
-}
-
-const std::string& defaultInitializerName() {
-    static const auto& s = *new std::string("default");  // Leaked to be shutdown-safe.
-    return s;
-}
-
-namespace {
-GlobalInitializerRegisterer defaultInitializerRegisterer(
-    defaultInitializerName(), [](auto) { return Status::OK(); }, nullptr, {}, {});
-}  // namespace
-
-}  // namespace mongo
diff --git a/src/mongo/base/global_initializer_registerer.h b/src/mongo/base/global_initializer_registerer.h
deleted file mode 100644
index 08b0ba625bc..00000000000
--- a/src/mongo/base/global_initializer_registerer.h
+++ /dev/null
@@ -1,100 +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 <string>
-#include <vector>
-
-#include "mongo/base/initializer_function.h"
-#include "mongo/base/status.h"
-
-namespace mongo {
-
-// The name of the "default" global initializer.
-// Global initializers with no explicit prerequisites depends on it by default.
-extern const std::string& defaultInitializerName();
-
-/**
- * Type representing the registration of a global intialization function.
- *
- * Create a nonlocal static storage duration instance of this type to register a new initializer, to
- * be run by a call to a variant of mongo::runGlobalInitializers().  See "mongo/base/initializer.h",
- * "mongo/base/init.h', and "mongo/base/initializer_dependency_graph.h" for details.
- */
-class GlobalInitializerRegisterer {
-public:
-    /**
-     * Constructor parameters:
-     *
-     *     - std::string name
-     *
-     *     - InitializerFunction initFn
-     *         Must be nonnull.
-     *         Example expression:
-     *
-     *            [](InitializerContext* context) {
-     *                // initialization code
-     *                return Status::OK();
-     *            }
-     *
-     *     - DeinitializerFunction deinitFn
-     *         A deinitialization that will execute in reverse order from initialization and
-     *         support re-initialization. If not specified, defaults to the `nullptr` function.
-     *         Example expression:
-     *
-     *            [](DeinitializerContext* context) {
-     *                // deinitialization code
-     *                return Status::OK();
-     *            }
-     *
-     *     - std::vector<std::string> prerequisites
-     *         If not specified, defaults to {"default"}.
-     *
-     *     - std::vector<std::string> dependents
-     *         If not specified, defaults to {} (no dependents).
-     *
-     *
-     * At run time, the full set of prerequisites for `name` will be computed as the union of the
-     * `prerequisites` (which can be defaulted) and all other mongo initializers that list `name` in
-     * their `dependents`.
-     *
-     * A non-null `deinitFn` will tag the initializer as supporting re-initialization.
-     */
-    GlobalInitializerRegisterer(std::string name,
-                                InitializerFunction initFn,
-                                DeinitializerFunction deinitFn = nullptr,
-                                std::vector<std::string> prerequisites = {defaultInitializerName()},
-                                std::vector<std::string> dependents = {});
-
-    GlobalInitializerRegisterer(const GlobalInitializerRegisterer&) = delete;
-    GlobalInitializerRegisterer& operator=(const GlobalInitializerRegisterer&) = delete;
-};
-
-}  // namespace mongo
diff --git a/src/mongo/base/init.cpp b/src/mongo/base/init.cpp
index c13f2529157..3708841589d 100644
--- a/src/mongo/base/init.cpp
+++ b/src/mongo/base/init.cpp
@@ -28,3 +28,35 @@
  */
 
 #include "mongo/base/init.h"
+
+#include <cstdlib>
+#include <iostream>
+
+#include "mongo/base/initializer.h"
+#include "mongo/util/assert_util.h"
+
+namespace mongo {
+
+GlobalInitializerRegisterer::GlobalInitializerRegisterer(std::string name,
+                                                         InitializerFunction initFn,
+                                                         DeinitializerFunction deinitFn,
+                                                         std::vector<std::string> prerequisites,
+                                                         std::vector<std::string> dependents) {
+    try {
+        getGlobalInitializer().addInitializer(std::move(name),
+                                              std::move(initFn),
+                                              std::move(deinitFn),
+                                              std::move(prerequisites),
+                                              std::move(dependents));
+    } catch (const DBException& ex) {
+        std::cerr << "Attempt to add global initializer failed, status: " << ex.toString()
+                  << std::endl;
+        ::abort();
+    }
+}
+
+namespace {
+GlobalInitializerRegisterer defaultInitializerRegisterer("default", [](auto) {}, nullptr, {}, {});
+}  // namespace
+
+}  // namespace mongo
diff --git a/src/mongo/base/init.h b/src/mongo/base/init.h
index 84d9ae97ddb..871d49a1905 100644
--- a/src/mongo/base/init.h
+++ b/src/mongo/base/init.h
@@ -35,39 +35,34 @@
  * Initializers are arranged in an acyclic directed dependency graph.  Declaring
  * a cycle will lead to a runtime error.
  *
- * Initializer functions take a parameter of type ::mongo::InitializerContext*, and return
- * a Status.  Any status other than Status::OK() is considered a failure that will stop further
- * intializer processing.
+ * Initializer functions take a parameter of type ::mongo::InitializerContext*.
+ * They throw to indicate failure, stopping further intializer processing.
  */
 
 #pragma once
 
-#include "mongo/base/deinitializer_context.h"
-#include "mongo/base/global_initializer.h"
-#include "mongo/base/global_initializer_registerer.h"
+#include <string>
+#include <vector>
+
 #include "mongo/base/initializer.h"
-#include "mongo/base/initializer_context.h"
-#include "mongo/base/initializer_function.h"
 #include "mongo/base/status.h"
 
 /**
- * Convenience parameter representing an empty set of prerequisites for an initializer function.
- */
-#define MONGO_NO_PREREQUISITES ()
-
-/**
- * Convenience parameter representing an empty set of dependents of an initializer function.
- */
-#define MONGO_NO_DEPENDENTS ()
-
-/**
- * Convenience parameter representing the default set of dependents for initializer functions.
- */
-#define MONGO_DEFAULT_PREREQUISITES (::mongo::defaultInitializerName().c_str())
-
-/**
- * Macro to define an initializer function named "NAME" with the default prerequisites, and
- * no explicit dependents.
+ * Macro to define an initializer function named "NAME" with the default
+ * prerequisite set, that is `("default")`, and no explicit dependents.
+ *
+ * The default set of prerequisites for initializer functions has one member,
+ * called "default". It refers to a do-nothing initializer called "default"
+ * defined by this init system, which serves as a partition point. It splits
+ * the graph into two broad phases. In practice, most initializers can omit
+ * their prerequisites and dependents, and use the MONGO_INITIALIZER macro, and
+ * such rules will be constrained to occur _after_ the "default" sequence
+ * point. Some special rules perform early preparation like options parsing,
+ * and several initializers might depend on these, so they will typically
+ * specify that they happen _before_ the "default" sequence point.
+ *
+ * The pre-"default" phase is further broken down into an orderly series of
+ * internal stages. (See util/options_parser/startup_option_init.cpp).
  *
  * See MONGO_INITIALIZER_GENERAL.
  *
@@ -76,8 +71,7 @@
  *         ...
  *     }
  */
-#define MONGO_INITIALIZER(NAME) \
-    MONGO_INITIALIZER_WITH_PREREQUISITES(NAME, MONGO_DEFAULT_PREREQUISITES)
+#define MONGO_INITIALIZER(NAME) MONGO_INITIALIZER_GENERAL(NAME, ("default"), ())
 
 /**
  * Macro to define an initializer function named "NAME" that depends on the initializers
@@ -92,7 +86,7 @@
  *    }
  */
 #define MONGO_INITIALIZER_WITH_PREREQUISITES(NAME, PREREQUISITES) \
-    MONGO_INITIALIZER_GENERAL(NAME, PREREQUISITES, MONGO_NO_DEPENDENTS)
+    MONGO_INITIALIZER_GENERAL(NAME, PREREQUISITES, ())
 
 #define MONGO_INITIALIZER_STRIP_PARENS_(...) __VA_ARGS__
 
@@ -101,12 +95,12 @@
  * dependents.
  *
  * NAME is any legitimate name for a C++ symbol.
- * PREREQUISITES is a tuple of 0 or more std::string literals, i.e., ("a", "b", "c"), or ()
- * DEPENDENTS is a tuple of 0 or more std::string literals.
+ * PREREQUISITES is a tuple of strings surrounded by parens, e.g., ("a", "b", "c"), or ().
+ * DEPENDENTS is a tuple of strings surrounded by parens.
  *
  * At run time, the full set of prerequisites for NAME will be computed as the union of the
  * explicit PREREQUISITES and the set of all other mongo initializers that name NAME in their
- * list of dependents.
+ * list of DEPENDENTS.
  *
  * Usage:
  *    MONGO_INITIALIZER_GENERAL(myInitializer,
@@ -119,17 +113,17 @@
  * A form that takes an existing function or that lets the programmer supply the name
  * of the function to declare would be options.
  */
-#define MONGO_INITIALIZER_GENERAL(NAME, PREREQUISITES, DEPENDENTS)                        \
-    ::mongo::Status MONGO_INITIALIZER_FUNCTION_NAME_(NAME)(::mongo::InitializerContext*); \
-    namespace {                                                                           \
-    ::mongo::GlobalInitializerRegisterer _mongoInitializerRegisterer_##NAME(              \
-        std::string(#NAME),                                                               \
-        mongo::InitializerFunction(MONGO_INITIALIZER_FUNCTION_NAME_(NAME)),               \
-        mongo::DeinitializerFunction(nullptr),                                            \
-        std::vector<std::string>{MONGO_INITIALIZER_STRIP_PARENS_ PREREQUISITES},          \
-        std::vector<std::string>{MONGO_INITIALIZER_STRIP_PARENS_ DEPENDENTS});            \
-    }                                                                                     \
-    ::mongo::Status MONGO_INITIALIZER_FUNCTION_NAME_(NAME)
+#define MONGO_INITIALIZER_GENERAL(NAME, PREREQUISITES, DEPENDENTS)               \
+    void MONGO_INITIALIZER_FUNCTION_NAME_(NAME)(::mongo::InitializerContext*);   \
+    namespace {                                                                  \
+    ::mongo::GlobalInitializerRegisterer _mongoInitializerRegisterer_##NAME(     \
+        std::string(#NAME),                                                      \
+        mongo::InitializerFunction(MONGO_INITIALIZER_FUNCTION_NAME_(NAME)),      \
+        mongo::DeinitializerFunction(nullptr),                                   \
+        std::vector<std::string>{MONGO_INITIALIZER_STRIP_PARENS_ PREREQUISITES}, \
+        std::vector<std::string>{MONGO_INITIALIZER_STRIP_PARENS_ DEPENDENTS});   \
+    }                                                                            \
+    void MONGO_INITIALIZER_FUNCTION_NAME_(NAME)
 
 /**
  * Macro to define an initializer group.
@@ -138,13 +132,68 @@
  * initialization steps into phases, such as "all global parameter declarations completed", "all
  * global parameters initialized".
  */
-#define MONGO_INITIALIZER_GROUP(NAME, PREREQUISITES, DEPENDENTS)                               \
-    MONGO_INITIALIZER_GENERAL(NAME, PREREQUISITES, DEPENDENTS)(::mongo::InitializerContext*) { \
-        return ::mongo::Status::OK();                                                          \
-    }
+#define MONGO_INITIALIZER_GROUP(NAME, PREREQUISITES, DEPENDENTS) \
+    MONGO_INITIALIZER_GENERAL(NAME, PREREQUISITES, DEPENDENTS)(::mongo::InitializerContext*) {}
 
 /**
  * Macro to produce a name for a mongo initializer function for an initializer operation
  * named "NAME".
  */
 #define MONGO_INITIALIZER_FUNCTION_NAME_(NAME) _mongoInitializerFunction_##NAME
+
+namespace mongo {
+
+/**
+ * Type representing the registration of a global initialization function.
+ *
+ * Create a nonlocal static storage duration instance of this type to register a new initializer, to
+ * be run by a call to a variant of mongo::runGlobalInitializers().
+ */
+class GlobalInitializerRegisterer {
+public:
+    /**
+     * Constructor parameters:
+     *
+     *     - std::string name
+     *
+     *     - InitializerFunction initFn
+     *         Must be nonnull.
+     *         Example expression:
+     *
+     *            [](InitializerContext* context) {
+     *                // initialization code
+     *            }
+     *
+     *     - DeinitializerFunction deinitFn
+     *         A deinitialization that will execute in reverse order from initialization and
+     *         support re-initialization. If not specified, defaults to `nullptr`.
+     *         Example expression:
+     *
+     *            [](DeinitializerContext* context) {
+     *                // deinitialization code
+     *            }
+     *
+     *     - std::vector<std::string> prerequisites
+     *         If not specified, defaults to {"default"}.
+     *
+     *     - std::vector<std::string> dependents
+     *         If not specified, defaults to {} (no dependents).
+     *
+     *
+     * At run time, the full set of prerequisites for `name` will be computed as the union of the
+     * `prerequisites` (which can be defaulted) and all other mongo initializers that list `name` in
+     * their `dependents`.
+     *
+     * A non-null `deinitFn` will tag the initializer as supporting re-initialization.
+     */
+    GlobalInitializerRegisterer(std::string name,
+                                InitializerFunction initFn,
+                                DeinitializerFunction deinitFn = nullptr,
+                                std::vector<std::string> prerequisites = {"default"},
+                                std::vector<std::string> dependents = {});
+
+    GlobalInitializerRegisterer(const GlobalInitializerRegisterer&) = delete;
+    GlobalInitializerRegisterer& operator=(const GlobalInitializerRegisterer&) = delete;
+};
+
+}  // namespace mongo
diff --git a/src/mongo/base/initializer.cpp b/src/mongo/base/initializer.cpp
index 89799707ce9..633067784f7 100644
--- a/src/mongo/base/initializer.cpp
+++ b/src/mongo/base/initializer.cpp
@@ -26,109 +26,212 @@
  *    exception statement from all source files in the program, then also delete
  *    it in the license file.
  */
+#define MONGO_LOGV2_DEFAULT_COMPONENT ::mongo::logv2::LogComponent::kDefault
 
 #include "mongo/platform/basic.h"
 
 #include "mongo/base/initializer.h"
 
+#include <fmt/format.h>
 #include <iostream>
+#include <string>
+#include <utility>
+#include <vector>
 
-#include "mongo/base/deinitializer_context.h"
-#include "mongo/base/global_initializer.h"
-#include "mongo/base/initializer_context.h"
+#include "mongo/base/dependency_graph.h"
+#include "mongo/base/status.h"
+#include "mongo/logv2/log.h"
 #include "mongo/util/assert_util.h"
 #include "mongo/util/quick_exit.h"
 #include "mongo/util/str.h"
 
 namespace mongo {
 
-Status Initializer::executeInitializers(const std::vector<std::string>& args) {
-    auto oldState = std::exchange(_lifecycleState, State::kInitializing);
-    invariant(oldState == State::kUninitialized, "invalid initializer state transition");
+class Initializer::Graph {
+public:
+    class Payload : public DependencyGraph::Payload {
+    public:
+        InitializerFunction initFn;
+        DeinitializerFunction deinitFn;
+        bool initialized = false;
+    };
+
+    /**
+     * Note that cycles in the dependency graph are not discovered by this
+     * function. Rather, they're discovered by `topSort`, below.
+     */
+    void add(std::string name,
+             InitializerFunction initFn,
+             DeinitializerFunction deinitFn,
+             std::vector<std::string> prerequisites,
+             std::vector<std::string> dependents) {
+        auto data = std::make_unique<Payload>();
+        data->initFn = std::move(initFn);
+        data->deinitFn = std::move(deinitFn);
+        _graph.addNode(
+            std::move(name), std::move(prerequisites), std::move(dependents), std::move(data));
+    }
 
-    if (_sortedNodes.empty()) {
-        if (Status status = _graph.topSort(&_sortedNodes); !status.isOK()) {
-            return status;
-        }
+    /**
+     * Returns the payload of the node that was added by `name`, or nullptr if no such node exists.
+     */
+    Payload* find(const std::string& name) {
+        return static_cast<Payload*>(_graph.find(name));
+    }
+
+    /**
+     * Returns a topological sort of the dependency graph, represented
+     * as an ordered vector of node names.
+     *
+     * - Throws with `ErrorCodes::GraphContainsCycle` if the graph contains a cycle.
+     *
+     * - Throws with `ErrorCodes::BadValue` if the graph is incomplete.
+     *   That is, a node named in a dependency edge was never added.
+     */
+    std::vector<std::string> topSort() const {
+        return _graph.topSort();
     }
-    _graph.freeze();
+
+private:
+    /**
+     * Map of all named nodes. Nodes named as dependency edges but not
+     * explicitly added will either be absent from this map or be present with
+     * a null-valude initFn.
+     */
+    DependencyGraph _graph;
+};
+
+Initializer::Initializer() : _graph(std::make_unique<Graph>()) {}
+Initializer::~Initializer() = default;
+
+void Initializer::_transition(State expected, State next) {
+    if (_lifecycleState != expected)
+        uasserted(
+            ErrorCodes::IllegalOperation,
+            format(
+                FMT_STRING(
+                    "Invalid initializer state transition. Expected {} -> {}, but currently at {}"),
+                expected,
+                next,
+                _lifecycleState));
+    _lifecycleState = next;
+}
+
+void Initializer::addInitializer(std::string name,
+                                 InitializerFunction initFn,
+                                 DeinitializerFunction deinitFn,
+                                 std::vector<std::string> prerequisites,
+                                 std::vector<std::string> dependents) {
+    uassert(ErrorCodes::BadValue, "Null-valued init function", initFn);
+    uassert(ErrorCodes::CannotMutateObject,
+            "Initializer dependency graph is frozen",
+            _lifecycleState == State::kNeverInitialized);
+    _graph->add(std::move(name),
+                std::move(initFn),
+                std::move(deinitFn),
+                std::move(prerequisites),
+                std::move(dependents));
+}
+
+
+void Initializer::executeInitializers(const std::vector<std::string>& args) {
+    if (_lifecycleState == State::kNeverInitialized)
+        _transition(State::kNeverInitialized, State::kUninitialized);  // freeze
+    _transition(State::kUninitialized, State::kInitializing);
+
+    if (_sortedNodes.empty())
+        _sortedNodes = _graph->topSort();
 
     InitializerContext context(args);
 
     for (const auto& nodeName : _sortedNodes) {
-        InitializerDependencyNode* node = _graph.getInitializerNode(nodeName);
-
-        // If already initialized then this node is a legacy initializer without re-initialization
-        // support.
-        if (node->isInitialized())
-            continue;
-
-        auto const& fn = node->getInitializerFunction();
-        if (!fn) {
-            return Status(ErrorCodes::InternalError,
-                          "topSort returned a node that has no associated function: \"" + nodeName +
-                              '"');
-        }
-        try {
-            if (Status status = fn(&context); !status.isOK()) {
-                return status;
-            }
-        } catch (const DBException& xcp) {
-            return xcp.toStatus();
-        }
+        auto* node = _graph->find(nodeName);
+
+        if (node->initialized)
+            continue;  // Legacy initializer without re-initialization support.
+
+        uassert(ErrorCodes::InternalError,
+                format(FMT_STRING("node has no init function: \"{}\""), nodeName),
+                node->initFn);
+        node->initFn(&context);
 
-        node->setInitialized(true);
+        node->initialized = true;
     }
 
-    oldState = std::exchange(_lifecycleState, State::kInitialized);
-    invariant(oldState == State::kInitializing, "invalid initializer state transition");
+    _transition(State::kInitializing, State::kInitialized);
 
-    return Status::OK();
+    // The order of the initializers is non-deterministic, so make it available.
+    // Must be after verbose has been parsed, or the Debug(2) severity won't be visible.
+    LOGV2_DEBUG_OPTIONS(4777800,
+                        2,
+                        {logv2::LogTruncation::Disabled},
+                        "Ran initializers",
+                        "nodes"_attr = _sortedNodes);
 }
 
-Status Initializer::executeDeinitializers() {
-    auto oldState = std::exchange(_lifecycleState, State::kDeinitializing);
-    invariant(oldState == State::kInitialized, "invalid initializer state transition");
+void Initializer::executeDeinitializers() {
+    _transition(State::kInitialized, State::kDeinitializing);
 
     DeinitializerContext context{};
 
     // Execute deinitialization in reverse order from initialization.
     for (auto it = _sortedNodes.rbegin(), end = _sortedNodes.rend(); it != end; ++it) {
-        InitializerDependencyNode* node = _graph.getInitializerNode(*it);
-        auto const& fn = node->getDeinitializerFunction();
-        if (fn) {
-            try {
-                if (Status status = fn(&context); !status.isOK()) {
-                    return status;
-                }
-            } catch (const DBException& xcp) {
-                return xcp.toStatus();
-            }
-
-            node->setInitialized(false);
+        auto* node = _graph->find(*it);
+        if (node->deinitFn) {
+            node->deinitFn(&context);
+            node->initialized = false;
         }
     }
 
-    oldState = std::exchange(_lifecycleState, State::kUninitialized);
-    invariant(oldState == State::kDeinitializing, "invalid initializer state transition");
+    _transition(State::kDeinitializing, State::kUninitialized);
+}
+
+InitializerFunction Initializer::getInitializerFunctionForTesting(const std::string& name) {
+    auto node = _graph->find(name);
+    return node ? node->initFn : nullptr;
+}
+
 
-    return Status::OK();
+Initializer& getGlobalInitializer() {
+    static auto g = new Initializer;
+    return *g;
 }
 
 Status runGlobalInitializers(const std::vector<std::string>& argv) {
-    return getGlobalInitializer().executeInitializers(argv);
+    try {
+        getGlobalInitializer().executeInitializers(argv);
+        return Status::OK();
+    } catch (const DBException& ex) {
+        return ex.toStatus();
+    }
 }
 
 Status runGlobalDeinitializers() {
-    return getGlobalInitializer().executeDeinitializers();
+    try {
+        getGlobalInitializer().executeDeinitializers();
+        return Status::OK();
+    } catch (const DBException& ex) {
+        return ex.toStatus();
+    }
 }
 
 void runGlobalInitializersOrDie(const std::vector<std::string>& argv) {
-    Status status = runGlobalInitializers(argv);
-    if (!status.isOK()) {
+    if (Status status = runGlobalInitializers(argv); !status.isOK()) {
         std::cerr << "Failed global initialization: " << status << std::endl;
         quickExit(1);
     }
 }
 
+namespace {
+
+// Make sure that getGlobalInitializer() is called at least once before main(), and so at least
+// once in a single-threaded context.  Otherwise, static initialization inside
+// getGlobalInitializer() won't be thread-safe.
+MONGO_COMPILER_VARIABLE_UNUSED const auto earlyCaller = [] {
+    getGlobalInitializer();
+    return 0;
+}();
+
+}  // namespace
+
 }  // namespace mongo
diff --git a/src/mongo/base/initializer.h b/src/mongo/base/initializer.h
index 131e3144477..12a2fa9bf7e 100644
--- a/src/mongo/base/initializer.h
+++ b/src/mongo/base/initializer.h
@@ -29,56 +29,141 @@
 
 #pragma once
 
+#include <functional>
 #include <string>
 #include <vector>
 
-#include "mongo/base/initializer_context.h"
-#include "mongo/base/initializer_dependency_graph.h"
 #include "mongo/base/status.h"
 
 namespace mongo {
 
+/** Context of an initialization process. Passed as a parameter to initialization functions. */
+class InitializerContext {
+public:
+    explicit InitializerContext(std::vector<std::string> args) : _args(std::move(args)) {}
+
+    const std::vector<std::string>& args() const {
+        return _args;
+    }
+
+private:
+    std::vector<std::string> _args;
+};
+
+/** Context of a deinitialization process. Passed as a parameter to deinitialization functions. */
+class DeinitializerContext {
+public:
+    DeinitializerContext(const DeinitializerContext&) = delete;
+    DeinitializerContext& operator=(const DeinitializerContext&) = delete;
+};
+
+/**
+ * An InitializerFunction implements the behavior of an initializer operation.
+ * It may inspect and mutate the supplied InitializerContext.
+ * Throws on failure.
+ */
+using InitializerFunction = std::function<void(InitializerContext*)>;
+
+/**
+ * A DeinitializerFunction implements the behavior of a deinitializer operation.
+ * It may inspect and mutate the supplied DeinitializerContext.
+ * Throws on failure.
+ */
+using DeinitializerFunction = std::function<void(DeinitializerContext*)>;
+
+
 /**
  * Class representing an initialization process.
  *
  * Such a process is described by a directed acyclic graph of initialization operations, the
- * InitializerDependencyGraph.  One constructs an initialization process by adding nodes and
+ * InitializerDependencyGraph. One constructs an initialization process by adding nodes and
  * edges to the graph.  Then, one executes the process, causing each initialization operation to
  * execute in an order that respects the programmer-established prerequistes.
+ *
+ * The initialize and delinitialize process can repeat, a features which
+ * supports embedded contexts.  However, the graph cannot be modified with
+ * `addInitializer` after the first initialization. Latecomers are rejected.
  */
 class Initializer {
 public:
+    Initializer();
+    ~Initializer();
+
     /**
-     * Get the initializer dependency graph, presumably for the purpose of adding more nodes.
+     * Add a new initializer node, with the specified `name`, to the dependency graph, with the
+     * given behavior, `initFn`, `deinitFn`, and with the given `prerequisites` and `dependents`,
+     * which are the names of other initializers which will be in the graph when `topSort`
+     * is called. `initFn` must be non-null, but null-valued `deinitFn` are allowed.
+     *
+     * - Throws `ErrorCodes::BadValue` if `initFn` is null-valued.
+     *
+     * - Throws with `ErrorCodes::CannotMutateObject` if the graph has been frozen
+     *   by a previous call to `executeInitializers`.
      */
-    InitializerDependencyGraph& getInitializerDependencyGraph() {
-        return _graph;
-    }
+    void addInitializer(std::string name,
+                        InitializerFunction initFn,
+                        DeinitializerFunction deinitFn,
+                        std::vector<std::string> prerequisites,
+                        std::vector<std::string> dependents);
 
     /**
-     * Execute the initializer process, using the given argv and environment data as input.
+     * Execute the initializer process, using the given args as input.
+     * This call freezes the graph, so that addInitializer will reject any latecomers.
      *
-     * Returns Status::OK on success.  All other returns constitute initialization failures,
-     * and the thing being initialized should be considered dead in the water.
+     * Throws on initialization failures, or on invalid call sequences
+     * (double-init, double-deinit, etc) and the thing being initialized should
+     * be considered dead in the water.
      */
-    Status executeInitializers(const std::vector<std::string>& args);
+    void executeInitializers(const std::vector<std::string>& args);
 
-    Status executeDeinitializers();
+    /**
+     * Executes all deinit functions in reverse order from init order.
+     * Note that this does not unfreeze the graph. Freezing is permanent.
+     */
+    void executeDeinitializers();
+
+    /**
+     * Returns the function mapped to `name`, for testing only.
+     *
+     * Throws with `ErrorCodes::BadValue` if name is not mapped to a node.
+     */
+    InitializerFunction getInitializerFunctionForTesting(const std::string& name);
 
 private:
+    class Graph;
+
+    /**
+     *  kNeverInitialized
+     *  |
+     *  +-> kUninitialized <----------+
+     *      |                         |
+     *      +-> kInitializing         |
+     *          |                     |
+     *          +-> kInitialized      |
+     *              |                 |
+     *              +-> kDeinitializing
+     */
     enum class State {
+        kNeverInitialized,  ///< still accepting addInitializer calls
         kUninitialized,
         kInitializing,
         kInitialized,
         kDeinitializing,
     };
 
-    InitializerDependencyGraph _graph;
+    void _transition(State expected, State next);
+
+    std::unique_ptr<Graph> _graph;  // pimpl
     std::vector<std::string> _sortedNodes;
-    State _lifecycleState{State::kUninitialized};
+    State _lifecycleState = State::kNeverInitialized;
 };
 
 /**
+ * Get the process-global initializer object.
+ */
+Initializer& getGlobalInitializer();
+
+/**
  * Run the global initializers.
  *
  * It's a programming error for this to fail, but if it does it will return a status other
diff --git a/src/mongo/base/initializer_context.h b/src/mongo/base/initializer_context.h
deleted file mode 100644
index 9ba23d69441..00000000000
--- a/src/mongo/base/initializer_context.h
+++ /dev/null
@@ -1,56 +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 "mongo/db/service_context_fwd.h"
-
-#include <map>
-#include <string>
-#include <vector>
-
-namespace mongo {
-/**
- * Context of an initialization process.  Passed as a parameter to initialization functions.
- *
- * See mongo/base/initializer.h and mongo/base/initializer_dependency_graph.h for more details.
- */
-class InitializerContext {
-public:
-    explicit InitializerContext(std::vector<std::string> args) : _args(std::move(args)) {}
-
-    const std::vector<std::string>& args() const {
-        return _args;
-    }
-
-private:
-    std::vector<std::string> _args;
-};
-
-}  // namespace mongo
diff --git a/src/mongo/base/initializer_dependency_graph.h b/src/mongo/base/initializer_dependency_graph.h
deleted file mode 100644
index 515f75cff26..00000000000
--- a/src/mongo/base/initializer_dependency_graph.h
+++ /dev/null
@@ -1,167 +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 <string>
-#include <utility>
-#include <vector>
-
-#include "mongo/base/initializer_function.h"
-#include "mongo/base/status.h"
-#include "mongo/stdx/unordered_map.h"
-#include "mongo/stdx/unordered_set.h"
-
-namespace mongo {
-
-class InitializerDependencyNode {
-    friend class InitializerDependencyGraph;
-
-public:
-    bool isInitialized() const {
-        return initialized;
-    }
-    void setInitialized(bool value) {
-        initialized = value;
-    };
-
-    InitializerFunction const& getInitializerFunction() const {
-        return initFn;
-    }
-    DeinitializerFunction const& getDeinitializerFunction() const {
-        return deinitFn;
-    }
-
-private:
-    InitializerFunction initFn;
-    DeinitializerFunction deinitFn;
-    stdx::unordered_set<std::string> prerequisites;
-    bool initialized{false};
-};
-
-/**
- * Representation of a dependency graph of "initialization operations."
- *
- * Each operation has a unique name, a function object implementing the operation's behavior,
- * and a set of prerequisite operations, which may be empty.  A legal graph contains no cycles.
- *
- * Instances of this class are used in two phases.  In the first phase, the graph is "unfrozen",
- * which permits it to be constructed by repeated calls to addInitializer().  In the second phase,
- * the graph is "frozen" by calling frozen(), which prevents the addition of any further
- * initializers to the graph.  A user can then call the topSort() method to produce an
- * initialization order that respects the dependencies among operations, and then uses the
- * getInitializerFunction() to get the behavior function for each operation, in turn.
- *
- * Concurrency Notes: The user is responsible for synchronization.  Multiple threads may
- * simultaneously call the const functions, getInitializerFunction and topSort, on the same instance
- * of InitializerDependencyGraph.  However, no thread may call addInitializer or freeze while any
- * thread is executing those functions, addInitializer or freeze on the same instance.
- */
-class InitializerDependencyGraph {
-    InitializerDependencyGraph(const InitializerDependencyGraph&) = delete;
-    InitializerDependencyGraph& operator=(const InitializerDependencyGraph&) = delete;
-
-public:
-    InitializerDependencyGraph();
-    ~InitializerDependencyGraph();
-
-    /**
-     * Add a new initializer node, named "name", to the dependency graph, with the given
-     * behavior, "fn", and the given "prerequisites" (input dependencies) and "dependents"
-     * (output dependencies).
-     *
-     * The graph must not be frozen.
-     *
-     * If "!fn" (fn is NULL in function pointer parlance), returns status with code
-     * ErrorCodes::badValue.  If "name" is a duplicate of a name already present in the graph,
-     * returns "ErrorCodes::duplicateKey".  Otherwise, returns Status::OK() and adds the new node
-     * to the graph.  Note that cycles in the dependency graph are not discovered in this phase.
-     * Rather, they're discovered by topSort, below.
-     */
-    Status addInitializer(std::string name,
-                          InitializerFunction initFn,
-                          DeinitializerFunction deinitFn,
-                          std::vector<std::string> prerequisites,
-                          std::vector<std::string> dependents);
-
-    /**
-     * Given a dependency operation node named "name", return its behavior function.  Returns
-     * a value that evaluates to "false" in boolean context, otherwise.
-     */
-    InitializerDependencyNode* getInitializerNode(const std::string& name);
-
-    /**
-     * Construct a topological sort of the dependency graph, and store that order into
-     * "sortedNames".  Returns Status::OK() on success.
-     *
-     * If the graph contains a cycle, returns ErrorCodes::graphContainsCycle, and "sortedNames"
-     * is an ordered sequence of nodes involved in a cycle.  In this case, the first and last
-     * element of "sortedNames" will be equal.
-     *
-     * If any node in the graph names a prerequisite that was never added to the graph via
-     * addInitializer, this function will return ErrorCodes::badValue.
-     *
-     * Any other return value indicates an internal error, and should not occur.
-     */
-    Status topSort(std::vector<std::string>* sortedNames) const;
-
-    /**
-     * Called to mark the end of the period when nodes are allowed to be added to the graph.
-     * The graph is effectively read-only after this point.
-     */
-    void freeze() {
-        _frozen = true;
-    }
-
-    /**
-     * Returns true if this graph has been frozen.
-     */
-    bool frozen() const {
-        return _frozen;
-    }
-
-private:
-    typedef stdx::unordered_map<std::string, InitializerDependencyNode> NodeMap;
-    typedef NodeMap::value_type Node;
-
-    /**
-     * Map of all named nodes.  Nodes named as prerequisites or dependents but not explicitly
-     * added via addInitializer will either be absent from this map or be present with
-     * NodeData::fn set to a false-ish value.
-     */
-    NodeMap _nodes;
-
-    /**
-     * If true, then the graph is "frozen" (ie. effectively read-only), and adding initializer nodes
-     * is not allowed.
-     */
-    bool _frozen{false};
-};
-
-}  // namespace mongo
diff --git a/src/mongo/base/initializer_dependency_graph_test.cpp b/src/mongo/base/initializer_dependency_graph_test.cpp
deleted file mode 100644
index 3194041d1a9..00000000000
--- a/src/mongo/base/initializer_dependency_graph_test.cpp
+++ /dev/null
@@ -1,405 +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.
- */
-
-/**
- * Unit tests of the InitializerDependencyGraph type.
- */
-
-#include <algorithm>
-#include <string>
-#include <vector>
-
-#include "mongo/base/init.h"
-#include "mongo/base/initializer_dependency_graph.h"
-#include "mongo/unittest/death_test.h"
-#include "mongo/unittest/unittest.h"
-
-#define STRIP_PARENS_(...) __VA_ARGS__
-
-#define ADD_INITIALIZER(GRAPH, NAME, FN, PREREQS, DEPS)                     \
-    (GRAPH).addInitializer((NAME),                                          \
-                           (FN),                                            \
-                           DeinitializerFunction(),                         \
-                           std::vector<std::string>{STRIP_PARENS_ PREREQS}, \
-                           std::vector<std::string>{STRIP_PARENS_ DEPS})
-
-#define ASSERT_ADD_INITIALIZER(GRAPH, NAME, FN, PREREQS, DEPS) \
-    ASSERT_EQUALS(Status::OK(), ADD_INITIALIZER(GRAPH, NAME, FN, PREREQS, DEPS))
-
-#define ASSERT_EXACTLY_N_IN_CONTAINER(N, CONTAINER, THING) \
-    ASSERT_EQUALS(N, std::count((CONTAINER).begin(), (CONTAINER).end(), (THING)))
-
-#define ASSERT_AT_LEAST_N_IN_CONTAINER(N, CONTAINER, THING) \
-    ASSERT_LESS_THAN_OR_EQUALS(N, std::count((CONTAINER).begin(), (CONTAINER).end(), (THING)))
-
-#define ASSERT_EXACTLY_ONE_IN_CONTAINER(CONTAINER, THING) \
-    ASSERT_EXACTLY_N_IN_CONTAINER(1, CONTAINER, THING)
-
-namespace mongo {
-namespace {
-
-Status doNothing(InitializerContext*) {
-    return Status::OK();
-}
-
-TEST(InitializerDependencyGraphTest, InsertNullFunctionFails) {
-    InitializerDependencyGraph graph;
-    ASSERT_EQUALS(
-        ErrorCodes::BadValue,
-        ADD_INITIALIZER(
-            graph, "A", InitializerFunction(), MONGO_NO_PREREQUISITES, MONGO_NO_DEPENDENTS));
-}
-
-TEST(InitializerDependencyGraphTest, InsertSameNameTwiceFails) {
-    InitializerDependencyGraph graph;
-    ASSERT_ADD_INITIALIZER(graph, "A", doNothing, MONGO_NO_PREREQUISITES, MONGO_NO_DEPENDENTS);
-    ASSERT_EQUALS(
-        50999,
-        ADD_INITIALIZER(graph, "A", doNothing, MONGO_NO_PREREQUISITES, MONGO_NO_DEPENDENTS).code());
-}
-
-TEST(InitializerDependencyGraphTest, TopSortEmptyGraph) {
-    InitializerDependencyGraph graph;
-    std::vector<std::string> nodeNames;
-    ASSERT_EQUALS(Status::OK(), graph.topSort(&nodeNames));
-    ASSERT_EQUALS(0U, nodeNames.size());
-}
-
-TEST(InitializerDependencyGraphTest, TopSortGraphNoDeps) {
-    InitializerDependencyGraph graph;
-    std::vector<std::string> nodeNames;
-    ASSERT_ADD_INITIALIZER(graph, "A", doNothing, MONGO_NO_PREREQUISITES, MONGO_NO_DEPENDENTS);
-    ASSERT_ADD_INITIALIZER(graph, "B", doNothing, MONGO_NO_PREREQUISITES, MONGO_NO_DEPENDENTS);
-    ASSERT_ADD_INITIALIZER(graph, "C", doNothing, MONGO_NO_PREREQUISITES, MONGO_NO_DEPENDENTS);
-    ASSERT_EQUALS(Status::OK(), graph.topSort(&nodeNames));
-    ASSERT_EQUALS(3U, nodeNames.size());
-    ASSERT_EXACTLY_ONE_IN_CONTAINER(nodeNames, "A");
-    ASSERT_EXACTLY_ONE_IN_CONTAINER(nodeNames, "B");
-    ASSERT_EXACTLY_ONE_IN_CONTAINER(nodeNames, "C");
-}
-
-TEST(InitializerDependencyGraphTest, TopSortWithDiamondPrerequisites) {
-    /*
-     * This tests top-sorting a simple diamond, specified using prerequisites:
-     *
-     *     B
-     *   /  ^
-     *  v    \
-     * A      D
-     *  ^   /
-     *   \ v
-     *    C
-     */
-    InitializerDependencyGraph graph;
-    std::vector<std::string> nodeNames;
-    ASSERT_ADD_INITIALIZER(graph, "A", doNothing, MONGO_NO_PREREQUISITES, MONGO_NO_DEPENDENTS);
-    ASSERT_ADD_INITIALIZER(graph, "D", doNothing, ("B", "C"), MONGO_NO_DEPENDENTS);
-    ASSERT_ADD_INITIALIZER(graph, "B", doNothing, ("A"), MONGO_NO_DEPENDENTS);
-    ASSERT_ADD_INITIALIZER(graph, "C", doNothing, ("A"), MONGO_NO_DEPENDENTS);
-    ASSERT_EQUALS(Status::OK(), graph.topSort(&nodeNames));
-    ASSERT_EQUALS(4U, nodeNames.size());
-    ASSERT_EXACTLY_ONE_IN_CONTAINER(nodeNames, "A");
-    ASSERT_EXACTLY_ONE_IN_CONTAINER(nodeNames, "B");
-    ASSERT_EXACTLY_ONE_IN_CONTAINER(nodeNames, "C");
-    ASSERT_EXACTLY_ONE_IN_CONTAINER(nodeNames, "D");
-    ASSERT_EQUALS("A", nodeNames.front());
-    ASSERT_EQUALS("D", nodeNames.back());
-}
-
-TEST(InitializerDependencyGraphTest, TopSortWithDiamondDependents) {
-    /*
-     * This tests top-sorting a simple diamond, specified using dependents:
-     *
-     *     B
-     *   /  ^
-     *  v    \
-     * A      D
-     *  ^   /
-     *   \ v
-     *    C
-     */
-    InitializerDependencyGraph graph;
-    std::vector<std::string> nodeNames;
-    ASSERT_ADD_INITIALIZER(graph, "A", doNothing, MONGO_NO_PREREQUISITES, ("B", "C"));
-    ASSERT_ADD_INITIALIZER(graph, "D", doNothing, MONGO_NO_PREREQUISITES, MONGO_NO_DEPENDENTS);
-    ASSERT_ADD_INITIALIZER(graph, "B", doNothing, MONGO_NO_PREREQUISITES, ("D"));
-    ASSERT_ADD_INITIALIZER(graph, "C", doNothing, MONGO_NO_PREREQUISITES, ("D"));
-    ASSERT_EQUALS(Status::OK(), graph.topSort(&nodeNames));
-    ASSERT_EQUALS(4U, nodeNames.size());
-    ASSERT_EXACTLY_ONE_IN_CONTAINER(nodeNames, "A");
-    ASSERT_EXACTLY_ONE_IN_CONTAINER(nodeNames, "B");
-    ASSERT_EXACTLY_ONE_IN_CONTAINER(nodeNames, "C");
-    ASSERT_EXACTLY_ONE_IN_CONTAINER(nodeNames, "D");
-    ASSERT_EQUALS("A", nodeNames.front());
-    ASSERT_EQUALS("D", nodeNames.back());
-}
-
-TEST(InitializerDependencyGraphTest, TopSortWithDiamondGeneral1) {
-    /*
-     * This tests top-sorting a simple diamond, where B and C specify all prerequisites and
-     * dependents.
-     *
-     *     B
-     *   /  ^
-     *  v    \
-     * A      D
-     *  ^   /
-     *   \ v
-     *    C
-     */
-    InitializerDependencyGraph graph;
-    std::vector<std::string> nodeNames;
-    ASSERT_ADD_INITIALIZER(graph, "A", doNothing, MONGO_NO_PREREQUISITES, MONGO_NO_DEPENDENTS);
-    ASSERT_ADD_INITIALIZER(graph, "D", doNothing, MONGO_NO_PREREQUISITES, MONGO_NO_DEPENDENTS);
-    ASSERT_ADD_INITIALIZER(graph, "B", doNothing, ("A"), ("D"));
-    ASSERT_ADD_INITIALIZER(graph, "C", doNothing, ("A"), ("D"));
-    ASSERT_EQUALS(Status::OK(), graph.topSort(&nodeNames));
-    ASSERT_EQUALS(4U, nodeNames.size());
-    ASSERT_EXACTLY_ONE_IN_CONTAINER(nodeNames, "A");
-    ASSERT_EXACTLY_ONE_IN_CONTAINER(nodeNames, "B");
-    ASSERT_EXACTLY_ONE_IN_CONTAINER(nodeNames, "C");
-    ASSERT_EXACTLY_ONE_IN_CONTAINER(nodeNames, "D");
-    ASSERT_EQUALS("A", nodeNames.front());
-    ASSERT_EQUALS("D", nodeNames.back());
-}
-
-TEST(InitializerDependencyGraphTest, TopSortWithDiamondGeneral2) {
-    /*
-     * This tests top-sorting a simple diamond, where A and D specify all prerequisites and
-     * dependents.
-     *
-     *     B
-     *   /  ^
-     *  v    \
-     * A      D
-     *  ^   /
-     *   \ v
-     *    C
-     */
-    InitializerDependencyGraph graph;
-    std::vector<std::string> nodeNames;
-    ASSERT_ADD_INITIALIZER(graph, "A", doNothing, MONGO_NO_PREREQUISITES, ("B", "C"));
-    ASSERT_ADD_INITIALIZER(graph, "D", doNothing, ("C", "B"), MONGO_NO_DEPENDENTS);
-    ASSERT_ADD_INITIALIZER(graph, "B", doNothing, MONGO_NO_PREREQUISITES, MONGO_NO_DEPENDENTS);
-    ASSERT_ADD_INITIALIZER(graph, "C", doNothing, MONGO_NO_PREREQUISITES, MONGO_NO_DEPENDENTS);
-    ASSERT_EQUALS(Status::OK(), graph.topSort(&nodeNames));
-    ASSERT_EQUALS(4U, nodeNames.size());
-    ASSERT_EXACTLY_ONE_IN_CONTAINER(nodeNames, "A");
-    ASSERT_EXACTLY_ONE_IN_CONTAINER(nodeNames, "B");
-    ASSERT_EXACTLY_ONE_IN_CONTAINER(nodeNames, "C");
-    ASSERT_EXACTLY_ONE_IN_CONTAINER(nodeNames, "D");
-    ASSERT_EQUALS("A", nodeNames.front());
-    ASSERT_EQUALS("D", nodeNames.back());
-}
-
-TEST(InitializerDependencyGraphTest, TopSortWithDiamondGeneral3) {
-    /*
-     * This tests top-sorting a simple diamond, where A and D specify all prerequisites and
-     * dependents, but so do B and C.
-     *
-     *     B
-     *   /  ^
-     *  v    \
-     * A      D
-     *  ^   /
-     *   \ v
-     *    C
-     */
-    InitializerDependencyGraph graph;
-    std::vector<std::string> nodeNames;
-    ASSERT_ADD_INITIALIZER(graph, "A", doNothing, MONGO_NO_PREREQUISITES, ("B", "C"));
-    ASSERT_ADD_INITIALIZER(graph, "D", doNothing, ("C", "B"), MONGO_NO_DEPENDENTS);
-    ASSERT_ADD_INITIALIZER(graph, "B", doNothing, ("A"), ("D"));
-    ASSERT_ADD_INITIALIZER(graph, "C", doNothing, ("A"), ("D"));
-    ASSERT_EQUALS(Status::OK(), graph.topSort(&nodeNames));
-    ASSERT_EQUALS(4U, nodeNames.size());
-    ASSERT_EXACTLY_ONE_IN_CONTAINER(nodeNames, "A");
-    ASSERT_EXACTLY_ONE_IN_CONTAINER(nodeNames, "B");
-    ASSERT_EXACTLY_ONE_IN_CONTAINER(nodeNames, "C");
-    ASSERT_EXACTLY_ONE_IN_CONTAINER(nodeNames, "D");
-    ASSERT_EQUALS("A", nodeNames.front());
-    ASSERT_EQUALS("D", nodeNames.back());
-}
-
-TEST(InitializerDependencyGraphTest, TopSortWithDiamondAndCycle) {
-    /*
-     * This tests top-sorting a graph with a cycle, which should fail..
-     *
-     *     B <- E
-     *   /  ^   ^
-     *  v    \ /
-     * A      D
-     *  ^   /
-     *   \ v
-     *    C
-     */
-    InitializerDependencyGraph graph;
-    std::vector<std::string> nodeNames;
-    ASSERT_ADD_INITIALIZER(graph, "A", doNothing, MONGO_NO_PREREQUISITES, ("B", "C"));
-    ASSERT_ADD_INITIALIZER(graph, "D", doNothing, ("C", "B"), MONGO_NO_DEPENDENTS);
-    ASSERT_ADD_INITIALIZER(graph, "B", doNothing, MONGO_NO_PREREQUISITES, MONGO_NO_DEPENDENTS);
-    ASSERT_ADD_INITIALIZER(graph, "C", doNothing, MONGO_NO_PREREQUISITES, MONGO_NO_DEPENDENTS);
-    ASSERT_ADD_INITIALIZER(graph, "E", doNothing, ("D"), ("B"));
-    ASSERT_EQUALS(ErrorCodes::GraphContainsCycle, graph.topSort(&nodeNames));
-    ASSERT_EQUALS(4U, nodeNames.size());
-    ASSERT_EQUALS(nodeNames.front(), nodeNames.back());
-    ASSERT_AT_LEAST_N_IN_CONTAINER(1, nodeNames, "D");
-    ASSERT_AT_LEAST_N_IN_CONTAINER(1, nodeNames, "E");
-    ASSERT_AT_LEAST_N_IN_CONTAINER(1, nodeNames, "B");
-    ASSERT_EXACTLY_N_IN_CONTAINER(0, nodeNames, "A");
-    ASSERT_EXACTLY_N_IN_CONTAINER(0, nodeNames, "C");
-}
-
-TEST(InitializerDependencyGraphTest, TopSortFailsWhenMissingPrerequisite) {
-    /*
-     * If a node names a never-declared prerequisite, topSort should fail.
-     */
-    InitializerDependencyGraph graph;
-    std::vector<std::string> nodeNames;
-    ASSERT_ADD_INITIALIZER(graph, "B", doNothing, ("A"), MONGO_NO_DEPENDENTS);
-    auto status = graph.topSort(&nodeNames);
-    ASSERT_EQUALS(ErrorCodes::BadValue, status);
-    ASSERT_STRING_CONTAINS(status.reason(), "depends on missing initializer A");
-}
-
-TEST(InitializerDependencyGraphTest, TopSortFailsWhenMissingDependent) {
-    /*
-     * If a node names a never-declared dependent, topSort should fail.
-     */
-    InitializerDependencyGraph graph;
-    std::vector<std::string> nodeNames;
-    ASSERT_ADD_INITIALIZER(graph, "A", doNothing, MONGO_NO_PREREQUISITES, ("B"));
-    auto status = graph.topSort(&nodeNames);
-    ASSERT_EQUALS(ErrorCodes::BadValue, status);
-    ASSERT_STRING_CONTAINS(status.reason(), "No implementation provided for initializer B");
-}
-
-std::vector<std::vector<std::string>> allPermutations(std::vector<std::string> vec,
-                                                      size_t first,
-                                                      size_t last) {
-    std::vector<std::vector<std::string>> out;
-    auto i1 = vec.begin() + first;
-    auto i2 = vec.begin() + last;
-    std::sort(i1, i2);
-    do {
-        out.push_back(vec);
-    } while (std::next_permutation(i1, i2));
-    return out;
-}
-
-template <typename Expectations, typename F>
-void doUntilAllSeen(const Expectations& expected, F&& f) {
-    std::vector<int> seen(expected.size(), 0);
-    while (std::find(seen.begin(), seen.end(), 0) != seen.end()) {
-        auto found = std::find(expected.begin(), expected.end(), f());
-        ASSERT_TRUE(found != expected.end());
-        ++seen[found - expected.begin()];
-    }
-}
-
-TEST(InitializerDependencyGraphTest, TopSortShufflesNodes) {
-    /*
-     * Make sure all node orderings can appear as outputs.
-     */
-    InitializerDependencyGraph graph;
-    std::vector<std::string> graphNodes;
-    for (int i = 0; i < 5; ++i) {
-        std::string s = "Node" + std::to_string(i);
-        graphNodes.push_back(s);
-        ASSERT_ADD_INITIALIZER(graph, s, doNothing, MONGO_NO_PREREQUISITES, MONGO_NO_DEPENDENTS);
-    }
-    std::vector<std::string> nodeNames;
-    doUntilAllSeen(allPermutations(graphNodes, 0, graphNodes.size()), [&]() -> decltype(auto) {
-        nodeNames.clear();
-        ASSERT_EQUALS(Status::OK(), graph.topSort(&nodeNames));
-        return nodeNames;
-    });
-}
-
-TEST(InitializerDependencyGraphTest, TopSortShufflesChildren) {
-    /*
-     * Make sure all child orderings can appear as outputs.
-     */
-    InitializerDependencyGraph graph;
-    std::vector<std::string> graphNodes;
-    graphNodes.push_back("Parent");
-    ASSERT_ADD_INITIALIZER(graph, "Parent", doNothing, MONGO_NO_PREREQUISITES, MONGO_NO_DEPENDENTS);
-    for (int i = 0; i < 5; ++i) {
-        std::string s = "Child" + std::to_string(i);
-        graphNodes.push_back(s);
-        ASSERT_ADD_INITIALIZER(graph, s, doNothing, ("Parent"), MONGO_NO_DEPENDENTS);
-    }
-    std::vector<std::string> nodeNames;
-    // Permute only the children.
-    doUntilAllSeen(allPermutations(graphNodes, 1, graphNodes.size()), [&]() -> decltype(auto) {
-        nodeNames.clear();
-        ASSERT_EQUALS(Status::OK(), graph.topSort(&nodeNames));
-        return nodeNames;
-    });
-}
-
-TEST(InitializerDependencyGraphTest, FreezeCausesFrozen) {
-    InitializerDependencyGraph graph;
-    ASSERT_FALSE(graph.frozen());
-    graph.freeze();
-    ASSERT_TRUE(graph.frozen());
-    graph.freeze();
-    ASSERT_TRUE(graph.frozen());
-}
-
-TEST(InitializerDependencyGraphTest, TopSortEmptyGraphWhileFrozen) {
-    InitializerDependencyGraph graph;
-    std::vector<std::string> nodeNames;
-    graph.freeze();
-    ASSERT_EQUALS(Status::OK(), graph.topSort(&nodeNames));
-    ASSERT_EQUALS(0U, nodeNames.size());
-}
-
-TEST(InitializerDependencyGraphTest, TopSortGraphNoDepsWhileFrozen) {
-    InitializerDependencyGraph graph;
-    std::vector<std::string> nodeNames;
-    ASSERT_ADD_INITIALIZER(graph, "A", doNothing, MONGO_NO_PREREQUISITES, MONGO_NO_DEPENDENTS);
-    ASSERT_ADD_INITIALIZER(graph, "B", doNothing, MONGO_NO_PREREQUISITES, MONGO_NO_DEPENDENTS);
-    ASSERT_ADD_INITIALIZER(graph, "C", doNothing, MONGO_NO_PREREQUISITES, MONGO_NO_DEPENDENTS);
-    graph.freeze();
-    ASSERT_EQUALS(Status::OK(), graph.topSort(&nodeNames));
-    ASSERT_EQUALS(3U, nodeNames.size());
-    ASSERT_EXACTLY_ONE_IN_CONTAINER(nodeNames, "A");
-    ASSERT_EXACTLY_ONE_IN_CONTAINER(nodeNames, "B");
-    ASSERT_EXACTLY_ONE_IN_CONTAINER(nodeNames, "C");
-}
-
-DEATH_TEST(InitializerDependencyGraphTest, CannotAddWhenFrozen, "!frozen()") {
-    InitializerDependencyGraph graph;
-    graph.freeze();
-    ASSERT_ADD_INITIALIZER(graph, "A", doNothing, MONGO_NO_PREREQUISITES, MONGO_NO_DEPENDENTS);
-}
-
-}  // namespace
-}  // namespace mongo
diff --git a/src/mongo/base/initializer_function.h b/src/mongo/base/initializer_function.h
deleted file mode 100644
index 05025010a87..00000000000
--- a/src/mongo/base/initializer_function.h
+++ /dev/null
@@ -1,58 +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 <functional>
-
-#include "mongo/base/status.h"
-
-namespace mongo {
-
-class InitializerContext;
-class DeinitializerContext;
-
-/**
- * An InitializerFunction implements the behavior of an initializer operation.
- *
- * On successful execution, an InitializerFunction returns Status::OK().  It may
- * inspect and mutate the supplied InitializerContext.
- */
-typedef std::function<Status(InitializerContext*)> InitializerFunction;
-
-/**
- * A DeinitializerFunction implements the behavior of a deinitializer operation.
- *
- * On successful execution, a DeinitializerFunction returns Status::OK(). It may
- * inspect and mutate the supplied DeinitializerContext.
- */
-typedef std::function<Status(DeinitializerContext*)> DeinitializerFunction;
-
-
-}  // namespace mongo
diff --git a/src/mongo/base/initializer_test.cpp b/src/mongo/base/initializer_test.cpp
index 3598e26694f..907b3881384 100644
--- a/src/mongo/base/initializer_test.cpp
+++ b/src/mongo/base/initializer_test.cpp
@@ -31,418 +31,267 @@
  * Unit tests of the Initializer type.
  */
 
+#include <fmt/format.h>
+
 #include "mongo/base/init.h"
 #include "mongo/base/initializer.h"
-#include "mongo/base/initializer_dependency_graph.h"
-#include "mongo/unittest/death_test.h"
 #include "mongo/unittest/unittest.h"
 
-/*
- * Unless otherwise specified, all tests herein use the following
- * dependency graph.
- *
- * 0 <-  3 <- 7
- *  ^   / ^    ^
- *   \ v   \     \
- *    2     5 <-  8
- *   / ^   /     /
- *  v   \ v    v
- * 1 <-  4 <- 6
- *
- */
-
-#define STRIP_PARENS_(...) __VA_ARGS__
-
-#define ADD_INITIALIZER(GRAPH, NAME, INIT_FN, DEINIT_FN, PREREQS, DEPS)     \
-    (GRAPH).addInitializer((NAME),                                          \
-                           (INIT_FN),                                       \
-                           (DEINIT_FN),                                     \
-                           std::vector<std::string>{STRIP_PARENS_ PREREQS}, \
-                           std::vector<std::string>{STRIP_PARENS_ DEPS})
-
-#define ASSERT_ADD_INITIALIZER(GRAPH, NAME, INIT_FN, DEINIT_FN, PREREQS, DEPS) \
-    ASSERT_EQUALS(Status::OK(), ADD_INITIALIZER(GRAPH, NAME, INIT_FN, DEINIT_FN, PREREQS, DEPS))
-
-
-#define CONSTRUCT_DEPENDENCY_GRAPH(GRAPH,                                                         \
-                                   INIT_FN0,                                                      \
-                                   DEINIT_FN0,                                                    \
-                                   INIT_FN1,                                                      \
-                                   DEINIT_FN1,                                                    \
-                                   INIT_FN2,                                                      \
-                                   DEINIT_FN2,                                                    \
-                                   INIT_FN3,                                                      \
-                                   DEINIT_FN3,                                                    \
-                                   INIT_FN4,                                                      \
-                                   DEINIT_FN4,                                                    \
-                                   INIT_FN5,                                                      \
-                                   DEINIT_FN5,                                                    \
-                                   INIT_FN6,                                                      \
-                                   DEINIT_FN6,                                                    \
-                                   INIT_FN7,                                                      \
-                                   DEINIT_FN7,                                                    \
-                                   INIT_FN8,                                                      \
-                                   DEINIT_FN8)                                                    \
-    do {                                                                                          \
-        InitializerDependencyGraph& _graph_ = (GRAPH);                                            \
-        ASSERT_ADD_INITIALIZER(                                                                   \
-            _graph_, "n0", INIT_FN0, DEINIT_FN0, MONGO_NO_PREREQUISITES, MONGO_NO_DEPENDENTS);    \
-        ASSERT_ADD_INITIALIZER(                                                                   \
-            _graph_, "n1", INIT_FN1, DEINIT_FN1, MONGO_NO_PREREQUISITES, MONGO_NO_DEPENDENTS);    \
-        ASSERT_ADD_INITIALIZER(                                                                   \
-            _graph_, "n2", INIT_FN2, DEINIT_FN2, ("n0", "n1"), MONGO_NO_DEPENDENTS);              \
-        ASSERT_ADD_INITIALIZER(                                                                   \
-            _graph_, "n3", INIT_FN3, DEINIT_FN3, ("n0", "n2"), MONGO_NO_DEPENDENTS);              \
-        ASSERT_ADD_INITIALIZER(                                                                   \
-            _graph_, "n4", INIT_FN4, DEINIT_FN4, ("n2", "n1"), MONGO_NO_DEPENDENTS);              \
-        ASSERT_ADD_INITIALIZER(                                                                   \
-            _graph_, "n5", INIT_FN5, DEINIT_FN5, ("n3", "n4"), MONGO_NO_DEPENDENTS);              \
-        ASSERT_ADD_INITIALIZER(_graph_, "n6", INIT_FN6, DEINIT_FN6, ("n4"), MONGO_NO_DEPENDENTS); \
-        ASSERT_ADD_INITIALIZER(_graph_, "n7", INIT_FN7, DEINIT_FN7, ("n3"), MONGO_NO_DEPENDENTS); \
-        ASSERT_ADD_INITIALIZER(                                                                   \
-            _graph_, "n8", INIT_FN8, DEINIT_FN8, ("n5", "n6", "n7"), MONGO_NO_DEPENDENTS);        \
-    } while (false)
-
 namespace mongo {
 namespace {
 
-enum State {
-    UNSET = 0,
-    INITIALIZED = 1,
-    DEINITIALIZED = 2,
+using namespace fmt::literals;
+
+class InitializerTest : public unittest::Test {
+public:
+    enum State {
+        kUnset = 0,
+        kInitialized = 1,
+        kDeinitialized = 2,
+    };
+
+    struct Graph {
+        struct Node {
+            std::string name;
+            std::vector<size_t> prereqs;
+        };
+
+        /**
+         * The dependency graph expressed as a vector of vectors.
+         * Each row is a vector of the corresponding node's dependencies.
+         */
+        auto prerequisites() const {
+            std::vector<std::vector<size_t>> result;
+            for (const auto& node : nodes)
+                result.push_back(node.prereqs);
+            return result;
+        }
+
+        /** Invert the prereq edges. */
+        auto dependents() const {
+            std::vector<std::vector<size_t>> result(nodes.size());
+            for (size_t i = 0; i != nodes.size(); ++i)
+                for (auto& r : nodes[i].prereqs)
+                    result[r].push_back(i);
+            return result;
+        }
+
+        size_t size() const {
+            return nodes.size();
+        }
+
+        std::vector<Node> nodes;
+    };
+
+    /*
+     * Unless otherwise specified, all tests herein use the following
+     * dependency graph.
+     */
+    static inline const Graph graph{{
+        {"n0", {}},         // 0
+                            // |
+        {"n1", {}},         // |  1
+                            // |  |
+        {"n2", {0, 1}},     // +--+->2
+                            // |  |  |
+        {"n3", {0, 2}},     // +-----+->3
+                            //    |  |  |
+        {"n4", {1, 2}},     //    +--+---->4
+                            //          |  |
+        {"n5", {3, 4}},     //          +--+->5
+                            //          |  |  |
+        {"n6", {4}},        //          |  +---->6
+                            //          |     |  |
+        {"n7", {3}},        //          +---------->7
+                            //                |  |  |
+        {"n8", {5, 6, 7}},  //                +--+--+->8
+    }};
+
+    /** The arguments for an addInitializer call. */
+    struct NodeSpec {
+        std::string name;
+        std::function<void(InitializerContext*)> init;
+        std::function<void(DeinitializerContext*)> deinit;
+        std::vector<std::string> prerequisites;
+        std::vector<std::string> dependents;
+    };
+
+    void initImpl(size_t idx) {
+        auto reqs = graph.prerequisites()[idx];
+        for (auto req : reqs)
+            if (states[req] != kInitialized)
+                uasserted(ErrorCodes::UnknownError,
+                          "(init{0}) {1} not already initialized"_format(idx, req));
+        states[idx] = kInitialized;
+    }
+
+    void deinitImpl(size_t idx) {
+        if (states[idx] != kInitialized)
+            uasserted(ErrorCodes::UnknownError, "(deinit{0}) {0} not initialized"_format(idx));
+        auto deps = graph.dependents()[idx];
+        for (auto dep : deps)
+            if (states[dep] != kDeinitialized)
+                uasserted(ErrorCodes::UnknownError,
+                          "(deinit{0}) {1} not already deinitialized"_format(idx, dep));
+        states[idx] = kDeinitialized;
+    }
+
+    static void initNoop(InitializerContext*) {}
+    static void deinitNoop(DeinitializerContext*) {}
+
+    std::vector<NodeSpec> makeDependencyGraphSpecs(const Graph& graph) {
+        std::vector<NodeSpec> specs;
+        for (size_t idx = 0; idx != graph.size(); ++idx) {
+            std::vector<std::string> reqNames;
+            for (auto&& req : graph.nodes[idx].prereqs)
+                reqNames.push_back(graph.nodes[req].name);
+            specs.push_back({graph.nodes[idx].name,
+                             [this, idx](InitializerContext*) { initImpl(idx); },
+                             [this, idx](DeinitializerContext*) { deinitImpl(idx); },
+                             reqNames,
+                             {}});
+        }
+        return specs;
+    }
+
+    void constructDependencyGraph(Initializer& initializer,
+                                  const std::vector<NodeSpec>& nodeSpecs) {
+        for (const auto& n : nodeSpecs)
+            initializer.addInitializer(n.name, n.init, n.deinit, n.prerequisites, n.dependents);
+    }
+
+    void constructDependencyGraph(Initializer& initializer) {
+        constructDependencyGraph(initializer, makeDependencyGraphSpecs(graph));
+    }
+
+    std::vector<State> states = std::vector<State>(graph.size(), kUnset);
 };
 
-State globalStates[9];
-
-Status initNoop(InitializerContext*) {
-    return Status::OK();
-}
-
-Status deinitNoop(DeinitializerContext*) {
-    return Status::OK();
-}
-
-Status init0(InitializerContext*) {
-    globalStates[0] = INITIALIZED;
-    return Status::OK();
-}
-
-Status init1(InitializerContext*) {
-    globalStates[1] = INITIALIZED;
-    return Status::OK();
-}
-
-Status init2(InitializerContext*) {
-    if (globalStates[0] != INITIALIZED || globalStates[1] != INITIALIZED)
-        return Status(ErrorCodes::UnknownError, "(init2) one of 0 or 1 not already initialized");
-    globalStates[2] = INITIALIZED;
-    return Status::OK();
-}
-
-Status init3(InitializerContext*) {
-    if (globalStates[0] != INITIALIZED || globalStates[2] != INITIALIZED)
-        return Status(ErrorCodes::UnknownError, "(init3) one of 0 or 2 not already initialized");
-    globalStates[3] = INITIALIZED;
-    return Status::OK();
-}
-
-Status init4(InitializerContext*) {
-    if (globalStates[1] != INITIALIZED || globalStates[2] != INITIALIZED)
-        return Status(ErrorCodes::UnknownError, "(init4) one of 1 or 2 not already initialized");
-    globalStates[4] = INITIALIZED;
-    return Status::OK();
-}
-
-Status init5(InitializerContext*) {
-    if (globalStates[3] != INITIALIZED || globalStates[4] != INITIALIZED)
-        return Status(ErrorCodes::UnknownError, "(init5) one of 3 or 4 not already initialized");
-    globalStates[5] = INITIALIZED;
-    return Status::OK();
-}
-
-Status init6(InitializerContext*) {
-    if (globalStates[4] != INITIALIZED)
-        return Status(ErrorCodes::UnknownError, "(init6) 4 not already initialized");
-    globalStates[6] = INITIALIZED;
-    return Status::OK();
-}
-
-Status init7(InitializerContext*) {
-    if (globalStates[3] != INITIALIZED)
-        return Status(ErrorCodes::UnknownError, "(init7) 3 not already initialized");
-    globalStates[7] = INITIALIZED;
-    return Status::OK();
-}
-
-Status init8(InitializerContext*) {
-    if (globalStates[5] != INITIALIZED || globalStates[6] != INITIALIZED ||
-        globalStates[7] != INITIALIZED)
-        return Status(ErrorCodes::UnknownError, "(init8) one of 5, 6, 7 not already initialized");
-    globalStates[8] = INITIALIZED;
-    return Status::OK();
-}
-
-Status deinit8(DeinitializerContext*) {
-    if (globalStates[8] != INITIALIZED)
-        return Status(ErrorCodes::UnknownError, "(deinit8) 8 not initialized");
-    globalStates[8] = DEINITIALIZED;
-    return Status::OK();
-}
-
-Status deinit7(DeinitializerContext*) {
-    if (globalStates[7] != INITIALIZED)
-        return Status(ErrorCodes::UnknownError, "(deinit7) 7 not initialized");
-    if (globalStates[8] != DEINITIALIZED)
-        return Status(ErrorCodes::UnknownError, "(deinit7) 8 not already deinitialized");
-    globalStates[7] = DEINITIALIZED;
-    return Status::OK();
-}
-
-Status deinit6(DeinitializerContext*) {
-    if (globalStates[6] != INITIALIZED)
-        return Status(ErrorCodes::UnknownError, "(deinit6) 6 not initialized");
-    if (globalStates[8] != DEINITIALIZED)
-        return Status(ErrorCodes::UnknownError, "(deinit6) 8 not already deinitialized");
-    globalStates[6] = DEINITIALIZED;
-    return Status::OK();
-}
-
-Status deinit5(DeinitializerContext*) {
-    if (globalStates[5] != INITIALIZED)
-        return Status(ErrorCodes::UnknownError, "(deinit5) 5 not initialized");
-    if (globalStates[8] != DEINITIALIZED)
-        return Status(ErrorCodes::UnknownError, "(deinit5) 8 not already deinitialized");
-    globalStates[5] = DEINITIALIZED;
-    return Status::OK();
-}
-
-Status deinit4(DeinitializerContext*) {
-    if (globalStates[4] != INITIALIZED)
-        return Status(ErrorCodes::UnknownError, "(deinit4) 4 not initialized");
-    if (globalStates[5] != DEINITIALIZED || globalStates[6] != DEINITIALIZED)
-        return Status(ErrorCodes::UnknownError,
-                      "(deinit4) one of 5 or 6 not already deinitialized");
-    globalStates[4] = DEINITIALIZED;
-    return Status::OK();
-}
-
-Status deinit3(DeinitializerContext*) {
-    if (globalStates[3] != INITIALIZED)
-        return Status(ErrorCodes::UnknownError, "(deinit3) 3 not initialized");
-    if (globalStates[5] != DEINITIALIZED || globalStates[7] != DEINITIALIZED)
-        return Status(ErrorCodes::UnknownError,
-                      "(deinit3) one of 5 or 7 not already deinitialized");
-    globalStates[3] = DEINITIALIZED;
-    return Status::OK();
-}
-
-Status deinit2(DeinitializerContext*) {
-    if (globalStates[2] != INITIALIZED)
-        return Status(ErrorCodes::UnknownError, "(deinit2) 2 not initialized");
-    if (globalStates[3] != DEINITIALIZED || globalStates[4] != DEINITIALIZED)
-        return Status(ErrorCodes::UnknownError,
-                      "(deinit2) one of 3 or 4 not already deinitialized");
-    globalStates[2] = DEINITIALIZED;
-    return Status::OK();
-}
+TEST_F(InitializerTest, SuccessfulInitializationAndDeinitialization) {
+    Initializer initializer;
+    constructDependencyGraph(initializer);
 
-Status deinit1(DeinitializerContext*) {
-    if (globalStates[1] != INITIALIZED)
-        return Status(ErrorCodes::UnknownError, "(deinit1) 1 not initialized");
-    if (globalStates[2] != DEINITIALIZED || globalStates[4] != DEINITIALIZED)
-        return Status(ErrorCodes::UnknownError,
-                      "(deinit1) one of 2 or 4 not already deinitialized");
-    globalStates[1] = DEINITIALIZED;
-    return Status::OK();
-}
+    initializer.executeInitializers({});
+    for (size_t i = 0; i != states.size(); ++i)
+        ASSERT_EQ(states[i], kInitialized) << i;
 
-Status deinit0(DeinitializerContext*) {
-    if (globalStates[0] != INITIALIZED)
-        return Status(ErrorCodes::UnknownError, "(deinit0) 0 not initialized");
-    if (globalStates[2] != DEINITIALIZED || globalStates[3] != DEINITIALIZED)
-        return Status(ErrorCodes::UnknownError,
-                      "(deinit0) one of 2 or 3 not already deinitialized");
-    globalStates[0] = DEINITIALIZED;
-    return Status::OK();
+    initializer.executeDeinitializers();
+    for (size_t i = 0; i != states.size(); ++i)
+        ASSERT_EQ(states[i], kDeinitialized) << i;
 }
 
-void clearCounts() {
-    for (size_t i = 0; i < 9; ++i)
-        globalStates[i] = UNSET;
+TEST_F(InitializerTest, Init5Misimplemented) {
+    auto specs = makeDependencyGraphSpecs(graph);
+    for (auto&& spec : specs)
+        spec.deinit = deinitNoop;
+    specs[5].init = initNoop;
+    Initializer initializer;
+    constructDependencyGraph(initializer, specs);
+
+    ASSERT_THROWS_CODE(initializer.executeInitializers({}), DBException, ErrorCodes::UnknownError);
+
+    std::vector<State> expected{
+        kInitialized,
+        kInitialized,
+        kInitialized,
+        kInitialized,
+        kInitialized,
+        kUnset,  // 5: noop init
+        kInitialized,
+        kInitialized,
+        kUnset,  // 8: depends on states[5] == kIninitialized, so fails.
+    };
+    for (size_t i = 0; i != states.size(); ++i)
+        ASSERT_EQ(states[i], expected[i]) << i;
 }
 
-void constructNormalDependencyGraph(Initializer* initializer) {
-    CONSTRUCT_DEPENDENCY_GRAPH(initializer->getInitializerDependencyGraph(),
-                               init0,
-                               deinit0,
-                               init1,
-                               deinit1,
-                               init2,
-                               deinit2,
-                               init3,
-                               deinit3,
-                               init4,
-                               deinit4,
-                               init5,
-                               deinit5,
-                               init6,
-                               deinit6,
-                               init7,
-                               deinit7,
-                               init8,
-                               deinit8);
+TEST_F(InitializerTest, Deinit2Misimplemented) {
+    auto specs = makeDependencyGraphSpecs(graph);
+    specs[2].deinit = deinitNoop;
+    Initializer initializer;
+    constructDependencyGraph(initializer, specs);
+
+    initializer.executeInitializers({});
+    for (size_t i = 0; i != states.size(); ++i)
+        ASSERT_EQ(states[i], kInitialized) << i;
+
+    ASSERT_THROWS_CODE(initializer.executeDeinitializers(), DBException, ErrorCodes::UnknownError);
+
+    // Since [2]'s deinit has been replaced with deinitNoop, it does not set states[2]
+    // to kDeinitialized. Its dependents [0] and [1] will check for this and fail
+    // with UnknownError, also remaining in the kInitialized state themselves.
+    std::vector<State> expected{
+        kInitialized,  // 0: depends on states[2] == kDeinitialized, so fails
+        kInitialized,  // 1: depends on states[2] == kDeinitialized, so fails
+        kInitialized,  // 2: noop deinit
+        kDeinitialized,
+        kDeinitialized,
+        kDeinitialized,
+        kDeinitialized,
+        kDeinitialized,
+        kDeinitialized,
+    };
+    for (size_t i = 0; i != states.size(); ++i)
+        ASSERT_EQ(states[i], expected[i]) << i;
 }
 
-TEST(InitializerTest, SuccessfulInitializationAndDeinitialization) {
+TEST_F(InitializerTest, InsertNullFunctionFails) {
     Initializer initializer;
-    constructNormalDependencyGraph(&initializer);
-    clearCounts();
-
-    ASSERT_OK(initializer.executeInitializers({}));
-
-    for (int i = 0; i < 9; ++i)
-        ASSERT_EQUALS(INITIALIZED, globalStates[i]);
-
-    ASSERT_OK(initializer.executeDeinitializers());
-
-    for (int i = 0; i < 9; ++i)
-        ASSERT_EQUALS(DEINITIALIZED, globalStates[i]);
+    ASSERT_THROWS_CODE(initializer.addInitializer("A", nullptr, nullptr, {}, {}),
+                       DBException,
+                       ErrorCodes::BadValue);
 }
 
-TEST(InitializerTest, Init5Misimplemented) {
+TEST_F(InitializerTest, CannotAddInitializerAfterInitializing) {
     Initializer initializer;
-    CONSTRUCT_DEPENDENCY_GRAPH(initializer.getInitializerDependencyGraph(),
-                               init0,
-                               deinitNoop,
-                               init1,
-                               deinitNoop,
-                               init2,
-                               deinitNoop,
-                               init3,
-                               deinitNoop,
-                               init4,
-                               deinitNoop,
-                               initNoop,
-                               deinitNoop,
-                               init6,
-                               deinitNoop,
-                               init7,
-                               deinitNoop,
-                               init8,
-                               deinitNoop);
-    clearCounts();
-
-    ASSERT_EQUALS(ErrorCodes::UnknownError, initializer.executeInitializers({}));
-
-    ASSERT_EQUALS(INITIALIZED, globalStates[0]);
-    ASSERT_EQUALS(INITIALIZED, globalStates[1]);
-    ASSERT_EQUALS(INITIALIZED, globalStates[2]);
-    ASSERT_EQUALS(INITIALIZED, globalStates[3]);
-    ASSERT_EQUALS(INITIALIZED, globalStates[4]);
-    ASSERT_EQUALS(UNSET, globalStates[5]);
-    ASSERT_EQUALS(INITIALIZED, globalStates[6]);
-    ASSERT_EQUALS(INITIALIZED, globalStates[7]);
-    ASSERT_EQUALS(UNSET, globalStates[8]);
+    constructDependencyGraph(initializer);
+    initializer.executeInitializers({});
+    ASSERT_THROWS_CODE(initializer.addInitializer("test", initNoop, deinitNoop, {}, {}),
+                       DBException,
+                       ErrorCodes::CannotMutateObject);
 }
 
-TEST(InitializerTest, Deinit2Misimplemented) {
+TEST_F(InitializerTest, CannotDoubleInitialize) {
     Initializer initializer;
-    CONSTRUCT_DEPENDENCY_GRAPH(initializer.getInitializerDependencyGraph(),
-                               init0,
-                               deinit0,
-                               init1,
-                               deinit1,
-                               init2,
-                               deinitNoop,
-                               init3,
-                               deinit3,
-                               init4,
-                               deinit4,
-                               init5,
-                               deinit5,
-                               init6,
-                               deinit6,
-                               init7,
-                               deinit7,
-                               init8,
-                               deinit8);
-    clearCounts();
-
-    ASSERT_OK(initializer.executeInitializers({}));
-
-    for (int i = 0; i < 9; ++i)
-        ASSERT_EQUALS(INITIALIZED, globalStates[i]);
-
-    ASSERT_EQUALS(ErrorCodes::UnknownError, initializer.executeDeinitializers());
-
-    ASSERT_EQUALS(DEINITIALIZED, globalStates[8]);
-    ASSERT_EQUALS(DEINITIALIZED, globalStates[7]);
-    ASSERT_EQUALS(DEINITIALIZED, globalStates[6]);
-    ASSERT_EQUALS(DEINITIALIZED, globalStates[5]);
-    ASSERT_EQUALS(DEINITIALIZED, globalStates[4]);
-    ASSERT_EQUALS(DEINITIALIZED, globalStates[3]);
-    ASSERT_EQUALS(INITIALIZED, globalStates[2]);
-    ASSERT_EQUALS(INITIALIZED, globalStates[1]);
-    ASSERT_EQUALS(INITIALIZED, globalStates[0]);
+    constructDependencyGraph(initializer);
+    initializer.executeInitializers({});
+    ASSERT_THROWS_CODE(
+        initializer.executeInitializers({}), DBException, ErrorCodes::IllegalOperation);
 }
 
-DEATH_TEST(InitializerTest, CannotAddInitializerAfterInitializing, "!frozen()") {
+TEST_F(InitializerTest, RepeatingInitializerCycle) {
     Initializer initializer;
-    constructNormalDependencyGraph(&initializer);
-    clearCounts();
-
-    ASSERT_OK(initializer.executeInitializers({}));
-
-    for (int i = 0; i < 9; ++i)
-        ASSERT_EQUALS(INITIALIZED, globalStates[i]);
-
-    ASSERT_ADD_INITIALIZER(initializer.getInitializerDependencyGraph(),
-                           "test",
-                           initNoop,
-                           deinitNoop,
-                           MONGO_NO_PREREQUISITES,
-                           MONGO_NO_DEPENDENTS);
+    constructDependencyGraph(initializer);
+    initializer.executeInitializers({});
+    initializer.executeDeinitializers();
+    initializer.executeInitializers({});
+    initializer.executeDeinitializers();
 }
 
-DEATH_TEST(InitializerTest, CannotDoubleInitialize, "invalid initializer state transition") {
+TEST_F(InitializerTest, CannotDeinitializeWithoutInitialize) {
     Initializer initializer;
-    constructNormalDependencyGraph(&initializer);
-    clearCounts();
-
-    ASSERT_OK(initializer.executeInitializers({}));
-
-    for (int i = 0; i < 9; ++i)
-        ASSERT_EQUALS(INITIALIZED, globalStates[i]);
-
-    initializer.executeInitializers({}).ignore();
+    constructDependencyGraph(initializer);
+    ASSERT_THROWS_CODE(
+        initializer.executeDeinitializers(), DBException, ErrorCodes::IllegalOperation);
 }
 
-DEATH_TEST(InitializerTest,
-           CannotDeinitializeWithoutInitialize,
-           "invalid initializer state transition") {
+TEST_F(InitializerTest, CannotDoubleDeinitialize) {
     Initializer initializer;
-    constructNormalDependencyGraph(&initializer);
-    clearCounts();
-
-    initializer.executeDeinitializers().ignore();
+    constructDependencyGraph(initializer);
+    initializer.executeInitializers({});
+    initializer.executeDeinitializers();
+    ASSERT_THROWS_CODE(
+        initializer.executeDeinitializers(), DBException, ErrorCodes::IllegalOperation);
 }
 
-DEATH_TEST(InitializerTest, CannotDoubleDeinitialize, "invalid initializer state transition") {
+TEST_F(InitializerTest, CannotAddWhenFrozen) {
     Initializer initializer;
-    constructNormalDependencyGraph(&initializer);
-    clearCounts();
-
-    ASSERT_OK(initializer.executeInitializers({}));
-
-    for (int i = 0; i < 9; ++i)
-        ASSERT_EQUALS(INITIALIZED, globalStates[i]);
-
-    ASSERT_OK(initializer.executeDeinitializers());
-
-    for (int i = 0; i < 9; ++i)
-        ASSERT_EQUALS(DEINITIALIZED, globalStates[i]);
-
-    initializer.executeDeinitializers().ignore();
+    constructDependencyGraph(initializer);
+    initializer.executeInitializers({});
+    initializer.executeDeinitializers();
+    ASSERT_THROWS_CODE(initializer.addInitializer("A", initNoop, nullptr, {}, {}),
+                       DBException,
+                       ErrorCodes::CannotMutateObject);
 }
 
 }  // namespace
diff --git a/src/mongo/base/secure_allocator.cpp b/src/mongo/base/secure_allocator.cpp
index 299751f553e..fca3e4ab82c 100644
--- a/src/mongo/base/secure_allocator.cpp
+++ b/src/mongo/base/secure_allocator.cpp
@@ -335,14 +335,12 @@ std::shared_ptr<Allocation> lastAllocation = nullptr;
 
 }  // namespace
 
-MONGO_INITIALIZER_GENERAL(SecureAllocator, MONGO_NO_PREREQUISITES, MONGO_NO_DEPENDENTS)
+MONGO_INITIALIZER_GENERAL(SecureAllocator, (), ())
 (InitializerContext* context) {
 #if _WIN32
     // Enable the increase working set size privilege in our access token.
     EnablePrivilege(SE_INC_WORKING_SET_NAME);
 #endif
-
-    return Status::OK();
 }
 
 namespace secure_allocator_details {
diff --git a/src/mongo/base/validate_locale.cpp b/src/mongo/base/validate_locale.cpp
index 6159764ba7a..7a102f5bf24 100644
--- a/src/mongo/base/validate_locale.cpp
+++ b/src/mongo/base/validate_locale.cpp
@@ -38,20 +38,18 @@
 
 namespace mongo {
 
-MONGO_INITIALIZER_GENERAL(ValidateLocale, MONGO_NO_PREREQUISITES, MONGO_DEFAULT_PREREQUISITES)
+MONGO_INITIALIZER_GENERAL(ValidateLocale, (), ("default"))
 (InitializerContext*) {
     try {
         // Validate that boost can correctly load the user's locale
         boost::filesystem::path("/").has_root_directory();
     } catch (const std::runtime_error& e) {
-        return Status(
-            ErrorCodes::BadValue,
-            str::stream()
-                << "Invalid or no user locale set. "
+        std::string extraHint;
 #ifndef _WIN32
-                << " Please ensure LANG and/or LC_* environment variables are set correctly. "
+        extraHint = " Please ensure LANG and/or LC_* environment variables are set correctly. ";
 #endif
-                << e.what());
+        uasserted(ErrorCodes::BadValue,
+                  str::stream() << "Invalid or no user locale set. " << extraHint << e.what());
     }
 
 #ifdef _WIN32
@@ -59,8 +57,6 @@ MONGO_INITIALIZER_GENERAL(ValidateLocale, MONGO_NO_PREREQUISITES, MONGO_DEFAULT_
     std::locale loc(std::locale(""), new std::codecvt_utf8_utf16<wchar_t>);
     boost::filesystem::path::imbue(loc);
 #endif
-
-    return Status::OK();
 }
 
 }  // namespace mongo
diff --git a/src/mongo/bson/oid.cpp b/src/mongo/bson/oid.cpp
index 70c8b056a70..37fed3b5831 100644
--- a/src/mongo/bson/oid.cpp
+++ b/src/mongo/bson/oid.cpp
@@ -53,12 +53,11 @@ const std::size_t kIncrementOffset = kInstanceUniqueOffset + OID::kInstanceUniqu
 OID::InstanceUnique _instanceUnique;
 }  // namespace
 
-MONGO_INITIALIZER_GENERAL(OIDGeneration, MONGO_NO_PREREQUISITES, ("default"))
+MONGO_INITIALIZER_GENERAL(OIDGeneration, (), ("default"))
 (InitializerContext* context) {
     SecureRandom entropy;
     counter = std::make_unique<AtomicWord<int64_t>>(entropy.nextInt64());
     _instanceUnique = OID::InstanceUnique::generate(entropy);
-    return Status::OK();
 }
 
 OID::Increment OID::Increment::next() {
diff --git a/src/mongo/client/connpool.cpp b/src/mongo/client/connpool.cpp
index f742a8dcef8..e3a5a925636 100644
--- a/src/mongo/client/connpool.cpp
+++ b/src/mongo/client/connpool.cpp
@@ -739,7 +739,6 @@ MONGO_INITIALIZER(SetupDBClientBaseWithConnection)(InitializerContext*) {
         cb(conn.get());
         conn.done();
     };
-    return Status::OK();
 }
 
 }  // namespace mongo
diff --git a/src/mongo/client/cyrus_sasl_client_session.cpp b/src/mongo/client/cyrus_sasl_client_session.cpp
index cf40a491f25..84ae1ab0b5a 100644
--- a/src/mongo/client/cyrus_sasl_client_session.cpp
+++ b/src/mongo/client/cyrus_sasl_client_session.cpp
@@ -114,7 +114,6 @@ MONGO_INITIALIZER(CyrusSaslAllocatorsAndMutexes)(InitializerContext*) {
     sasl_set_alloc(saslOurMalloc, saslOurCalloc, saslOurRealloc, free);
 
     sasl_set_mutex(saslMutexAlloc, saslMutexLock, saslMutexUnlock, saslMutexFree);
-    return Status::OK();
 }
 
 int saslClientLogSwallow(void* context, int priority, const char* message) throw() {
@@ -145,13 +144,12 @@ MONGO_INITIALIZER_WITH_PREREQUISITES(CyrusSaslClientContext,
     // TODO: Call sasl_client_done() at shutdown when we have a story for orderly shutdown.
     int result = sasl_client_init(saslClientGlobalCallbacks);
     if (result != SASL_OK) {
-        return Status(ErrorCodes::UnknownError,
-                      str::stream() << "Could not initialize sasl client components ("
-                                    << sasl_errstring(result, nullptr, nullptr) << ")");
+        uasserted(ErrorCodes::UnknownError,
+                  str::stream() << "Could not initialize sasl client components ("
+                                << sasl_errstring(result, nullptr, nullptr) << ")");
     }
 
     SaslClientSession::create = createCyrusSaslClientSession;
-    return Status::OK();
 }
 
 /**
diff --git a/src/mongo/client/dbclient_rs_test.cpp b/src/mongo/client/dbclient_rs_test.cpp
index 3765148e8ff..2ec975e1cb4 100644
--- a/src/mongo/client/dbclient_rs_test.cpp
+++ b/src/mongo/client/dbclient_rs_test.cpp
@@ -65,7 +65,6 @@ using std::vector;
 
 MONGO_INITIALIZER(DisableReplicaSetMonitorRefreshRetries)(InitializerContext*) {
     ScanningReplicaSetMonitor::disableRefreshRetries_forTest();
-    return Status::OK();
 }
 
 /**
diff --git a/src/mongo/client/global_conn_pool.cpp b/src/mongo/client/global_conn_pool.cpp
index d126fb87e76..0533c1a760c 100644
--- a/src/mongo/client/global_conn_pool.cpp
+++ b/src/mongo/client/global_conn_pool.cpp
@@ -43,8 +43,6 @@ MONGO_INITIALIZER_WITH_PREREQUISITES(InitializeGlobalConnectionPool, ("EndStartu
     globalConnPool.setMaxPoolSize(maxConnsPerHost);
     globalConnPool.setMaxInUse(maxInUseConnsPerHost);
     globalConnPool.setIdleTimeout(globalConnPoolIdleTimeout);
-
-    return Status::OK();
 }
 
 }  // namespace
diff --git a/src/mongo/client/native_sasl_client_session.cpp b/src/mongo/client/native_sasl_client_session.cpp
index 169cc73c6ca..3d37f9db9cc 100644
--- a/src/mongo/client/native_sasl_client_session.cpp
+++ b/src/mongo/client/native_sasl_client_session.cpp
@@ -54,7 +54,6 @@ SaslClientSession* createNativeSaslClientSession(const std::string mech) {
 
 MONGO_INITIALIZER(NativeSaslClientContext)(InitializerContext* context) {
     SaslClientSession::create = createNativeSaslClientSession;
-    return Status::OK();
 }
 
 // Global cache for SCRAM-SHA-1/256 credentials
diff --git a/src/mongo/client/sasl_client_authenticate_impl.cpp b/src/mongo/client/sasl_client_authenticate_impl.cpp
index 1e06f3ee9ff..323f7a6b321 100644
--- a/src/mongo/client/sasl_client_authenticate_impl.cpp
+++ b/src/mongo/client/sasl_client_authenticate_impl.cpp
@@ -289,7 +289,6 @@ Future<void> saslClientAuthenticateImpl(auth::RunCommandHook runCommand,
 
 MONGO_INITIALIZER(SaslClientAuthenticateFunction)(InitializerContext* context) {
     saslClientAuthenticate = saslClientAuthenticateImpl;
-    return Status::OK();
 }
 
 }  // namespace
diff --git a/src/mongo/client/sasl_sspi.cpp b/src/mongo/client/sasl_sspi.cpp
index 42963e68b0f..f904eaa24a7 100644
--- a/src/mongo/client/sasl_sspi.cpp
+++ b/src/mongo/client/sasl_sspi.cpp
@@ -476,12 +476,10 @@ MONGO_INITIALIZER_WITH_PREREQUISITES(SaslSspiClientPlugin,
 (InitializerContext*) {
     int ret = sasl_client_add_plugin(sspiPluginName, sspiClientPluginInit);
     if (SASL_OK != ret) {
-        return Status(ErrorCodes::UnknownError,
-                      str::stream() << "could not add SASL Client SSPI plugin " << sspiPluginName
-                                    << ": " << sasl_errstring(ret, nullptr, nullptr));
+        uasserted(ErrorCodes::UnknownError,
+                  str::stream() << "could not add SASL Client SSPI plugin " << sspiPluginName
+                                << ": " << sasl_errstring(ret, nullptr, nullptr));
     }
-
-    return Status::OK();
 }
 
 MONGO_INITIALIZER_WITH_PREREQUISITES(SaslPlainClientPlugin,
@@ -489,12 +487,10 @@ MONGO_INITIALIZER_WITH_PREREQUISITES(SaslPlainClientPlugin,
 (InitializerContext*) {
     int ret = sasl_client_add_plugin("PLAIN", plain_client_plug_init);
     if (SASL_OK != ret) {
-        return Status(ErrorCodes::UnknownError,
-                      str::stream() << "Could not add SASL Client PLAIN plugin " << sspiPluginName
-                                    << ": " << sasl_errstring(ret, nullptr, nullptr));
+        uasserted(ErrorCodes::UnknownError,
+                  str::stream() << "Could not add SASL Client PLAIN plugin " << sspiPluginName
+                                << ": " << sasl_errstring(ret, nullptr, nullptr));
     }
-
-    return Status::OK();
 }
 
 }  // namespace
diff --git a/src/mongo/client/sasl_sspi_options.cpp b/src/mongo/client/sasl_sspi_options.cpp
index 378ae103de0..4c548d6ebff 100644
--- a/src/mongo/client/sasl_sspi_options.cpp
+++ b/src/mongo/client/sasl_sspi_options.cpp
@@ -64,7 +64,7 @@ Status storeSASLSSPIOptions(const moe::Environment& params) {
 }
 
 MONGO_STARTUP_OPTIONS_STORE(SASLSSPIOptions)(InitializerContext* context) {
-    return storeSASLSSPIOptions(moe::startupOptionsParsed);
+    uassertStatusOK(storeSASLSSPIOptions(moe::startupOptionsParsed));
 }
 
 }  // namespace mongo
diff --git a/src/mongo/crypto/symmetric_crypto.cpp b/src/mongo/crypto/symmetric_crypto.cpp
index b03cae0cd6b..825fb21efd7 100644
--- a/src/mongo/crypto/symmetric_crypto.cpp
+++ b/src/mongo/crypto/symmetric_crypto.cpp
@@ -47,9 +47,7 @@
 namespace mongo {
 namespace crypto {
 
-MONGO_INITIALIZER(CreateKeyEntropySource)(InitializerContext* context) {
-    return Status::OK();
-}
+MONGO_INITIALIZER(CreateKeyEntropySource)(InitializerContext* context) {}
 
 size_t aesGetIVSize(crypto::aesMode mode) {
     switch (mode) {
diff --git a/src/mongo/db/auth/authorization_manager_impl.cpp b/src/mongo/db/auth/authorization_manager_impl.cpp
index 50401c7809a..729df9178a7 100644
--- a/src/mongo/db/auth/authorization_manager_impl.cpp
+++ b/src/mongo/db/auth/authorization_manager_impl.cpp
@@ -89,10 +89,8 @@ MONGO_INITIALIZER_GENERAL(SetupInternalSecurityUser,
     }
 
     internalSecurity.user = user;
-
-    return Status::OK();
 } catch (...) {
-    return exceptionToStatus();
+    uassertStatusOK(exceptionToStatus());
 }
 
 class PinnedUserSetParameter {
diff --git a/src/mongo/db/auth/builtin_roles.cpp b/src/mongo/db/auth/builtin_roles.cpp
index 622ba2f5a87..037f7765c35 100644
--- a/src/mongo/db/auth/builtin_roles.cpp
+++ b/src/mongo/db/auth/builtin_roles.cpp
@@ -259,8 +259,6 @@ MONGO_INITIALIZER(AuthorizationBuiltinRoles)(InitializerContext* context) {
         << ActionType::splitVector
         << ActionType::refineCollectionShardKey
         << ActionType::reshardCollection;
-
-    return Status::OK();
 }
 // clang-format on
 
diff --git a/src/mongo/db/auth/sasl_commands.cpp b/src/mongo/db/auth/sasl_commands.cpp
index d352eeeb082..e89dda82f7c 100644
--- a/src/mongo/db/auth/sasl_commands.cpp
+++ b/src/mongo/db/auth/sasl_commands.cpp
@@ -433,8 +433,6 @@ MONGO_INITIALIZER(PreSaslCommands)
 (InitializerContext*) {
     if (!sequenceContains(saslGlobalParams.authenticationMechanisms, kX509AuthMechanism))
         disableAuthMechanism(kX509AuthMechanism);
-
-    return Status::OK();
 }
 
 }  // namespace
diff --git a/src/mongo/db/auth/sasl_options.cpp b/src/mongo/db/auth/sasl_options.cpp
index d390ad99524..63414acc3a1 100644
--- a/src/mongo/db/auth/sasl_options.cpp
+++ b/src/mongo/db/auth/sasl_options.cpp
@@ -52,7 +52,6 @@ namespace {
 MONGO_INITIALIZER_WITH_PREREQUISITES(InitSpeculativeCounters, ("EndStartupOptionStorage"))
 (InitializerContext*) {
     authCounter.initializeMechanismMap(saslGlobalParams.authenticationMechanisms);
-    return Status::OK();
 }
 }  // namespace
 
diff --git a/src/mongo/db/auth/sasl_options_init.cpp b/src/mongo/db/auth/sasl_options_init.cpp
index 21050612cbd..6d22544af6d 100644
--- a/src/mongo/db/auth/sasl_options_init.cpp
+++ b/src/mongo/db/auth/sasl_options_init.cpp
@@ -89,7 +89,7 @@ Status storeSASLOptions(const moe::Environment& params) {
 }
 
 MONGO_INITIALIZER_GENERAL(StoreSASLOptions, ("CoreOptions_Store"), ("EndStartupOptionStorage"))
-(InitializerContext* const context) {
-    return storeSASLOptions(moe::startupOptionsParsed);
+(InitializerContext*) {
+    uassertStatusOK(storeSASLOptions(moe::startupOptionsParsed));
 }
 }  // namespace mongo
diff --git a/src/mongo/db/commands.h b/src/mongo/db/commands.h
index 9043b84612a..140d7bccee4 100644
--- a/src/mongo/db/commands.h
+++ b/src/mongo/db/commands.h
@@ -1127,19 +1127,19 @@ private:
 CommandRegistry* globalCommandRegistry();
 
 /**
- * Creates a test command object of type CmdType if test commands are enabled for this process.
- * Prefer this syntax to using MONGO_INITIALIZER directly.
- * The created Command object is "leaked" intentionally, since it will register itself.
+ * Creates a test command object of type CmdType if test commands are enabled
+ * for this process. Prefer this syntax to using MONGO_INITIALIZER directly.
+ * The created Command object is "leaked" intentionally, since it will register
+ * itself.
+ *
+ * The command objects will be created after the "default" initializer, and all
+ * startup option processing happens prior to "default" (see base/init.h).
  */
-#define MONGO_REGISTER_TEST_COMMAND(CmdType)                                     \
-    MONGO_INITIALIZER_WITH_PREREQUISITES(                                        \
-        RegisterTestCommand_##CmdType,                                           \
-        (::mongo::defaultInitializerName().c_str(), "EndStartupOptionHandling")) \
-    (InitializerContext*) {                                                      \
-        if (getTestCommandsEnabled()) {                                          \
-            new CmdType();                                                       \
-        }                                                                        \
-        return Status::OK();                                                     \
+#define MONGO_REGISTER_TEST_COMMAND(CmdType)                                \
+    MONGO_INITIALIZER(RegisterTestCommand_##CmdType)(InitializerContext*) { \
+        if (getTestCommandsEnabled()) {                                     \
+            new CmdType();                                                  \
+        }                                                                   \
     }
 
 }  // namespace mongo
diff --git a/src/mongo/db/commands/fsync.cpp b/src/mongo/db/commands/fsync.cpp
index cc50ca5bf3a..5573e813b7b 100644
--- a/src/mongo/db/commands/fsync.cpp
+++ b/src/mongo/db/commands/fsync.cpp
@@ -448,7 +448,6 @@ void FSyncLockThread::run() {
 
 MONGO_INITIALIZER(fsyncLockedForWriting)(InitializerContext* context) {
     setLockedForWritingImpl([]() { return fsyncCmd.fsyncLocked(); });
-    return Status::OK();
 }
 
 }  // namespace
diff --git a/src/mongo/db/commands/index_filter_commands.cpp b/src/mongo/db/commands/index_filter_commands.cpp
index ec7529c608e..c9a82127980 100644
--- a/src/mongo/db/commands/index_filter_commands.cpp
+++ b/src/mongo/db/commands/index_filter_commands.cpp
@@ -94,13 +94,11 @@ static Status getQuerySettingsAndPlanCache(OperationContext* opCtx,
 // available to the client.
 //
 
-MONGO_INITIALIZER_WITH_PREREQUISITES(SetupIndexFilterCommands, MONGO_NO_PREREQUISITES)
+MONGO_INITIALIZER_WITH_PREREQUISITES(SetupIndexFilterCommands, ())
 (InitializerContext* context) {
     new ListFilters();
     new ClearFilters();
     new SetFilter();
-
-    return Status::OK();
 }
 
 }  // namespace
diff --git a/src/mongo/db/commands/isself.cpp b/src/mongo/db/commands/isself.cpp
index 0a118ffa566..c2b5e716523 100644
--- a/src/mongo/db/commands/isself.cpp
+++ b/src/mongo/db/commands/isself.cpp
@@ -69,7 +69,6 @@ MONGO_INITIALIZER_WITH_PREREQUISITES(RegisterIsSelfCommand, ("GenerateInstanceId
 (InitializerContext* context) {
     // Leaked intentionally: a Command registers itself when constructed
     new IsSelfCommand();
-    return Status::OK();
 }
 
 }  // namespace mongo
diff --git a/src/mongo/db/commands/oplog_note.cpp b/src/mongo/db/commands/oplog_note.cpp
index 74aeecbbc64..2188631a109 100644
--- a/src/mongo/db/commands/oplog_note.cpp
+++ b/src/mongo/db/commands/oplog_note.cpp
@@ -154,7 +154,6 @@ public:
 
 MONGO_INITIALIZER(RegisterAppendOpLogNoteCmd)(InitializerContext* context) {
     new AppendOplogNoteCmd();
-    return Status::OK();
 }
 
 }  // namespace mongo
diff --git a/src/mongo/db/commands/test_commands.cpp b/src/mongo/db/commands/test_commands.cpp
index 382b8978400..58d75f67e71 100644
--- a/src/mongo/db/commands/test_commands.cpp
+++ b/src/mongo/db/commands/test_commands.cpp
@@ -34,7 +34,6 @@
 #include "mongo/platform/basic.h"
 
 #include "mongo/base/init.h"
-#include "mongo/base/initializer_context.h"
 #include "mongo/db/catalog/capped_utils.h"
 #include "mongo/db/catalog/collection.h"
 #include "mongo/db/client.h"
diff --git a/src/mongo/db/commands/top_command.cpp b/src/mongo/db/commands/top_command.cpp
index 328b318a73f..50999b993c1 100644
--- a/src/mongo/db/commands/top_command.cpp
+++ b/src/mongo/db/commands/top_command.cpp
@@ -88,7 +88,5 @@ public:
 
 MONGO_INITIALIZER(RegisterTopCommand)(InitializerContext* context) {
     new TopCommand();
-
-    return Status::OK();
 }
 }  // namespace
diff --git a/src/mongo/db/exec/sbe/stages/exchange.cpp b/src/mongo/db/exec/sbe/stages/exchange.cpp
index af748cb4089..a2e932d3553 100644
--- a/src/mongo/db/exec/sbe/stages/exchange.cpp
+++ b/src/mongo/db/exec/sbe/stages/exchange.cpp
@@ -45,8 +45,6 @@ MONGO_INITIALIZER(s_globalThreadPool)(InitializerContext* context) {
     options.onCreateThread = [](const std::string& name) { Client::initThread(name); };
     s_globalThreadPool = std::make_unique<ThreadPool>(options);
     s_globalThreadPool->startup();
-
-    return Status::OK();
 }
 
 ExchangePipe::ExchangePipe(size_t size) {
diff --git a/src/mongo/db/free_mon/free_mon_controller_test.cpp b/src/mongo/db/free_mon/free_mon_controller_test.cpp
index 4225e71efbb..e074e73c7f0 100644
--- a/src/mongo/db/free_mon/free_mon_controller_test.cpp
+++ b/src/mongo/db/free_mon/free_mon_controller_test.cpp
@@ -41,7 +41,6 @@
 #include "mongo/db/free_mon/free_mon_storage.h"
 
 #include "mongo/base/data_type_validated.h"
-#include "mongo/base/deinitializer_context.h"
 #include "mongo/bson/bson_validate.h"
 #include "mongo/bson/bsonmisc.h"
 #include "mongo/bson/bsonobjbuilder.h"
diff --git a/src/mongo/db/free_mon/free_mon_options.cpp b/src/mongo/db/free_mon/free_mon_options.cpp
index 173d11847e2..df1255e1200 100644
--- a/src/mongo/db/free_mon/free_mon_options.cpp
+++ b/src/mongo/db/free_mon/free_mon_options.cpp
@@ -35,7 +35,6 @@
 #include "mongo/db/free_mon/free_mon_options.h"
 
 #include "mongo/base/error_codes.h"
-#include "mongo/base/initializer_context.h"
 #include "mongo/base/status.h"
 #include "mongo/base/status_with.h"
 #include "mongo/base/string_data.h"
@@ -92,8 +91,8 @@ Status storeFreeMonitoringOptions(const moe::Environment& params) {
     return Status::OK();
 }
 
-MONGO_STARTUP_OPTIONS_STORE(FreeMonitoringOptions)(InitializerContext* /*unused*/) {
-    return storeFreeMonitoringOptions(moe::startupOptionsParsed);
+MONGO_STARTUP_OPTIONS_STORE(FreeMonitoringOptions)(InitializerContext*) {
+    uassertStatusOK(storeFreeMonitoringOptions(moe::startupOptionsParsed));
 }
 
 }  // namespace
diff --git a/src/mongo/db/ftdc/ftdc_commands.cpp b/src/mongo/db/ftdc/ftdc_commands.cpp
index bd403010ebc..aa274c1858e 100644
--- a/src/mongo/db/ftdc/ftdc_commands.cpp
+++ b/src/mongo/db/ftdc/ftdc_commands.cpp
@@ -106,8 +106,6 @@ Command* ftdcCommand;
 
 MONGO_INITIALIZER(CreateDiagnosticDataCommand)(InitializerContext* context) {
     ftdcCommand = new GetDiagnosticDataCommand();
-
-    return Status::OK();
 }
 
 }  // namespace
diff --git a/src/mongo/db/fts/fts_index_format.cpp b/src/mongo/db/fts/fts_index_format.cpp
index a6f12f6cef5..418ea2d8629 100644
--- a/src/mongo/db/fts/fts_index_format.cpp
+++ b/src/mongo/db/fts/fts_index_format.cpp
@@ -107,7 +107,6 @@ MONGO_INITIALIZER(FTSIndexFormat)(InitializerContext* context) {
     b.appendNull("");
     nullObj = b.obj();
     nullElt = nullObj.firstElement();
-    return Status::OK();
 }
 
 void FTSIndexFormat::getKeys(SharedBufferFragmentBuilder& pooledBufferBuilder,
diff --git a/src/mongo/db/fts/stop_words.cpp b/src/mongo/db/fts/stop_words.cpp
index 39be67707bc..9c415a2d262 100644
--- a/src/mongo/db/fts/stop_words.cpp
+++ b/src/mongo/db/fts/stop_words.cpp
@@ -68,7 +68,6 @@ MONGO_INITIALIZER(StopWords)(InitializerContext* context) {
     for (StringMap<std::set<std::string>>::const_iterator i = raw.begin(); i != raw.end(); ++i) {
         StopWordsMap[i->first].reset(new StopWords(i->second));
     }
-    return Status::OK();
 }
 }  // namespace fts
 }  // namespace mongo
diff --git a/src/mongo/db/geo/r2_region_coverer_test.cpp b/src/mongo/db/geo/r2_region_coverer_test.cpp
index 806fc9d4e37..0a499f2a74a 100644
--- a/src/mongo/db/geo/r2_region_coverer_test.cpp
+++ b/src/mongo/db/geo/r2_region_coverer_test.cpp
@@ -59,7 +59,6 @@ MONGO_INITIALIZER(R2CellUnion_Test)(InitializerContext* context) {
     }
     generator.seed(seed);
     LOGV2(20640, "R2CellUnion Test - Random Number Generator Seed: {seed}", "seed"_attr = seed);
-    return Status::OK();
 }
 
 // Returns an integral number in [lower, upper]
diff --git a/src/mongo/db/initialize_server_global_state.cpp b/src/mongo/db/initialize_server_global_state.cpp
index aef5a665d4f..6dd9a7ef69d 100644
--- a/src/mongo/db/initialize_server_global_state.cpp
+++ b/src/mongo/db/initialize_server_global_state.cpp
@@ -298,8 +298,8 @@ MONGO_INITIALIZER_GENERAL(ServerLogRedirection,
 
     if (serverGlobalParams.logWithSyslog) {
 #ifdef _WIN32
-        return Status(ErrorCodes::InternalError,
-                      "Syslog requested in Windows build; command line processor logic error");
+        uasserted(ErrorCodes::InternalError,
+                  "Syslog requested in Windows build; command line processor logic error");
 #else
         lv2Config.consoleEnabled = false;
         lv2Config.syslogEnabled = true;
@@ -316,16 +316,16 @@ MONGO_INITIALIZER_GENERAL(ServerLogRedirection,
         try {
             exists = boost::filesystem::exists(absoluteLogpath);
         } catch (boost::filesystem::filesystem_error& e) {
-            return Status(ErrorCodes::FileNotOpen,
-                          str::stream() << "Failed probe for \"" << absoluteLogpath
-                                        << "\": " << e.code().message());
+            uasserted(ErrorCodes::FileNotOpen,
+                      str::stream() << "Failed probe for \"" << absoluteLogpath
+                                    << "\": " << e.code().message());
         }
 
         if (exists) {
             if (boost::filesystem::is_directory(absoluteLogpath)) {
-                return Status(ErrorCodes::FileNotOpen,
-                              str::stream() << "logpath \"" << absoluteLogpath
-                                            << "\" should name a file, not a directory.");
+                uasserted(ErrorCodes::FileNotOpen,
+                          str::stream() << "logpath \"" << absoluteLogpath
+                                        << "\" should name a file, not a directory.");
             }
 
             if (!serverGlobalParams.logAppend && boost::filesystem::is_regular(absoluteLogpath)) {
@@ -339,12 +339,11 @@ MONGO_INITIALIZER_GENERAL(ServerLogRedirection,
                           "oldLogPath"_attr = absoluteLogpath,
                           "newLogPath"_attr = renameTarget);
                 } else {
-                    return Status(ErrorCodes::FileRenameFailed,
-                                  str::stream()
-                                      << "Could not rename preexisting log file \""
-                                      << absoluteLogpath << "\" to \"" << renameTarget
-                                      << "\"; run with --logappend or manually remove file: "
-                                      << ec.message());
+                    uasserted(ErrorCodes::FileRenameFailed,
+                              str::stream() << "Could not rename preexisting log file \""
+                                            << absoluteLogpath << "\" to \"" << renameTarget
+                                            << "\"; run with --logappend or manually remove file: "
+                                            << ec.message());
                 }
             }
         }
@@ -369,8 +368,7 @@ MONGO_INITIALIZER_GENERAL(ServerLogRedirection,
     if (result.isOK() && writeServerRestartedAfterLogConfig) {
         LOGV2(20698, "***** SERVER RESTARTED *****");
     }
-
-    return result;
+    uassertStatusOK(result);
 }
 
 /**
@@ -389,8 +387,7 @@ static void shortCircuitExit() {
 
 MONGO_INITIALIZER(RegisterShortCircuitExitHandler)(InitializerContext*) {
     if (std::atexit(&shortCircuitExit) != 0)
-        return Status(ErrorCodes::InternalError, "Failed setting short-circuit exit handler.");
-    return Status::OK();
+        uasserted(ErrorCodes::InternalError, "Failed setting short-circuit exit handler.");
 }
 
 bool initializeServerGlobalState(ServiceContext* service, PidFileWrite pidWrite) {
@@ -447,8 +444,6 @@ MONGO_INITIALIZER_GENERAL(MungeUmask, ("EndStartupOptionHandling"), ("ServerLogR
         // in order to pull out the user portion of the current umask.
         umask((umask(S_IRWXU | S_IRWXG | S_IRWXO) & S_IRWXU) | getUmaskOverride());
     }
-
-    return Status::OK();
 }
 }  // namespace
 #endif
diff --git a/src/mongo/db/logical_time_validator.cpp b/src/mongo/db/logical_time_validator.cpp
index d88bbbd3294..c56a3a146f0 100644
--- a/src/mongo/db/logical_time_validator.cpp
+++ b/src/mongo/db/logical_time_validator.cpp
@@ -64,7 +64,6 @@ MONGO_INITIALIZER(InitializeAdvanceClusterTimePrivilegeVector)(InitializerContex
     ActionSet actions;
     actions.addAction(ActionType::advanceClusterTime);
     advanceClusterTimePrivilege.emplace_back(ResourcePattern::forClusterResource(), actions);
-    return Status::OK();
 }
 
 Milliseconds kRefreshIntervalIfErrored(200);
diff --git a/src/mongo/db/matcher/expression_parser.cpp b/src/mongo/db/matcher/expression_parser.cpp
index e8d2acfd489..197cc481e3c 100644
--- a/src/mongo/db/matcher/expression_parser.cpp
+++ b/src/mongo/db/matcher/expression_parser.cpp
@@ -1981,7 +1981,6 @@ MONGO_INITIALIZER(PathlessOperatorMap)(InitializerContext* context) {
             {"text", &parseText},
             {"where", &parseWhere},
         });
-    return Status::OK();
 }
 
 // Maps from query operator string name to operator PathAcceptingKeyword.
@@ -2036,7 +2035,6 @@ MONGO_INITIALIZER(MatchExpressionParser)(InitializerContext* context) {
             {"type", PathAcceptingKeyword::TYPE},
             {"within", PathAcceptingKeyword::WITHIN},
         });
-    return Status::OK();
 }
 
 /**
diff --git a/src/mongo/db/mongod_main.cpp b/src/mongo/db/mongod_main.cpp
index b355becdf2a..2a3489eb2be 100644
--- a/src/mongo/db/mongod_main.cpp
+++ b/src/mongo/db/mongod_main.cpp
@@ -290,7 +290,6 @@ MONGO_INITIALIZER_WITH_PREREQUISITES(WireSpec, ("EndStartupOptionHandling"))(Ini
     spec.isInternalClient = true;
 
     WireSpec::instance().initialize(std::move(spec));
-    return Status::OK();
 }
 
 void initializeCommandHooks(ServiceContext* serviceContext) {
@@ -812,7 +811,6 @@ ExitCode initService() {
 MONGO_INITIALIZER_GENERAL(ForkServer, ("EndStartupOptionHandling"), ("default"))
 (InitializerContext* context) {
     mongo::forkServerOrDie();
-    return Status::OK();
 }
 
 /*
@@ -1022,10 +1020,9 @@ void setUpObservers(ServiceContext* serviceContext) {
 }
 
 #ifdef MONGO_CONFIG_SSL
-MONGO_INITIALIZER_GENERAL(setSSLManagerType, MONGO_NO_PREREQUISITES, ("SSLManager"))
+MONGO_INITIALIZER_GENERAL(setSSLManagerType, (), ("SSLManager"))
 (InitializerContext* context) {
     isSSLServer = true;
-    return Status::OK();
 }
 #endif
 
diff --git a/src/mongo/db/mongod_options.cpp b/src/mongo/db/mongod_options.cpp
index fbc888172cf..db09e05615f 100644
--- a/src/mongo/db/mongod_options.cpp
+++ b/src/mongo/db/mongod_options.cpp
@@ -695,7 +695,6 @@ MONGO_INITIALIZER(IgnoreEnableMajorityReadConcernWarning)
                       "Ignoring read concern override as config server requires majority read "
                       "concern");
     }
-    return Status::OK();
 }
 
 }  // namespace mongo
diff --git a/src/mongo/db/mongod_options_init.cpp b/src/mongo/db/mongod_options_init.cpp
index 8d9a28d7dfe..34d0ac03e2d 100644
--- a/src/mongo/db/mongod_options_init.cpp
+++ b/src/mongo/db/mongod_options_init.cpp
@@ -38,7 +38,7 @@
 
 namespace mongo {
 MONGO_GENERAL_STARTUP_OPTIONS_REGISTER(MongodOptions)(InitializerContext* context) {
-    return addMongodOptions(&moe::startupOptions);
+    uassertStatusOK(addMongodOptions(&moe::startupOptions));
 }
 
 MONGO_INITIALIZER_GENERAL(MongodOptions,
@@ -50,23 +50,10 @@ MONGO_INITIALIZER_GENERAL(MongodOptions,
     }
     // Run validation, but tell the Environment that we don't want it to be set as "valid",
     // since we may be making it invalid in the canonicalization process.
-    Status ret = moe::startupOptionsParsed.validate(false /*setValid*/);
-    if (!ret.isOK()) {
-        return ret;
-    }
-    ret = validateMongodOptions(moe::startupOptionsParsed);
-    if (!ret.isOK()) {
-        return ret;
-    }
-    ret = canonicalizeMongodOptions(&moe::startupOptionsParsed);
-    if (!ret.isOK()) {
-        return ret;
-    }
-    ret = moe::startupOptionsParsed.validate();
-    if (!ret.isOK()) {
-        return ret;
-    }
-    return Status::OK();
+    uassertStatusOK(moe::startupOptionsParsed.validate(false /*setValid*/));
+    uassertStatusOK(validateMongodOptions(moe::startupOptionsParsed));
+    uassertStatusOK(canonicalizeMongodOptions(&moe::startupOptionsParsed));
+    uassertStatusOK(moe::startupOptionsParsed.validate());
 }
 
 MONGO_INITIALIZER_GENERAL(CoreOptions_Store,
@@ -79,7 +66,6 @@ MONGO_INITIALIZER_GENERAL(CoreOptions_Store,
         std::cerr << "try '" << context->args()[0] << " --help' for more information" << std::endl;
         quickExit(EXIT_BADOPTIONS);
     }
-    return Status::OK();
 }
 
 }  // namespace mongo
diff --git a/src/mongo/db/pipeline/accumulation_statement.h b/src/mongo/db/pipeline/accumulation_statement.h
index 83f0ad5561c..3d1b3a69b98 100644
--- a/src/mongo/db/pipeline/accumulation_statement.h
+++ b/src/mongo/db/pipeline/accumulation_statement.h
@@ -46,13 +46,11 @@ namespace mongo {
 #define REGISTER_ACCUMULATOR(key, factory)                                            \
     MONGO_INITIALIZER(addToAccumulatorFactoryMap_##key)(InitializerContext*) {        \
         AccumulationStatement::registerAccumulator("$" #key, (factory), boost::none); \
-        return Status::OK();                                                          \
     }
 
 #define REGISTER_ACCUMULATOR_WITH_MIN_VERSION(key, factory, minVersion)                \
     MONGO_INITIALIZER(addToAccumulatorFactoryMap_##key)(InitializerContext*) {         \
         AccumulationStatement::registerAccumulator("$" #key, (factory), (minVersion)); \
-        return Status::OK();                                                           \
     }
 
 /**
diff --git a/src/mongo/db/pipeline/document_source.h b/src/mongo/db/pipeline/document_source.h
index a1c65ea48d0..8aa736d4b9f 100644
--- a/src/mongo/db/pipeline/document_source.h
+++ b/src/mongo/db/pipeline/document_source.h
@@ -90,7 +90,7 @@ class Document;
 #define REGISTER_DOCUMENT_SOURCE_CONDITIONALLY(key, liteParser, fullParser, minVersion, ...) \
     MONGO_INITIALIZER(addToDocSourceParserMap_##key)(InitializerContext*) {                  \
         if (!__VA_ARGS__) {                                                                  \
-            return Status::OK();                                                             \
+            return;                                                                          \
         }                                                                                    \
         auto fullParserWrapper = [](BSONElement stageSpec,                                   \
                                     const boost::intrusive_ptr<ExpressionContext>& expCtx) { \
@@ -99,7 +99,6 @@ class Document;
         };                                                                                   \
         LiteParsedDocumentSource::registerParser("$" #key, liteParser);                      \
         DocumentSource::registerParser("$" #key, fullParserWrapper, minVersion);             \
-        return Status::OK();                                                                 \
     }
 
 #define REGISTER_DOCUMENT_SOURCE(key, liteParser, fullParser) \
@@ -129,7 +128,6 @@ class Document;
     MONGO_INITIALIZER(addAliasToDocSourceParserMap_##key)(InitializerContext*) { \
         LiteParsedDocumentSource::registerParser("$" #key, (liteParser));        \
         DocumentSource::registerParser("$" #key, (fullParser), boost::none);     \
-        return Status::OK();                                                     \
     }
 
 class DocumentSource : public RefCountable {
diff --git a/src/mongo/db/pipeline/expression.cpp b/src/mongo/db/pipeline/expression.cpp
index 06481c5d953..9fcfad4daff 100644
--- a/src/mongo/db/pipeline/expression.cpp
+++ b/src/mongo/db/pipeline/expression.cpp
@@ -6715,7 +6715,6 @@ void ExpressionToHashedIndexKey::_doAddDependencies(DepsTracker* deps) const {
 MONGO_INITIALIZER(expressionParserMap)(InitializerContext*) {
     // Nothing to do. This initializer exists to tie together all the individual initializers
     // defined by REGISTER_EXPRESSION / REGISTER_EXPRESSION_WITH_MIN_VERSION.
-    return Status::OK();
 }
 
 }  // namespace mongo
diff --git a/src/mongo/db/pipeline/expression.h b/src/mongo/db/pipeline/expression.h
index 647f7a24527..ef95686c879 100644
--- a/src/mongo/db/pipeline/expression.h
+++ b/src/mongo/db/pipeline/expression.h
@@ -73,7 +73,6 @@ class DocumentSource;
     MONGO_INITIALIZER_GENERAL(addToExpressionParserMap_##key, (), ("expressionParserMap")) \
     (InitializerContext*) {                                                                \
         Expression::registerExpression("$" #key, (parser), boost::none);                   \
-        return Status::OK();                                                               \
     }
 
 /**
@@ -89,7 +88,6 @@ class DocumentSource;
     MONGO_INITIALIZER_GENERAL(addToExpressionParserMap_##key, (), ("expressionParserMap")) \
     (InitializerContext*) {                                                                \
         Expression::registerExpression("$" #key, (parser), (minVersion));                  \
-        return Status::OK();                                                               \
     }
 
 /**
@@ -103,7 +101,6 @@ class DocumentSource;
         if (getTestCommandsEnabled()) {                                                        \
             Expression::registerExpression("$" #key, (parser), boost::none);                   \
         }                                                                                      \
-        return Status::OK();                                                                   \
     }
 
 class Expression : public RefCountable {
diff --git a/src/mongo/db/pipeline/granularity_rounder.h b/src/mongo/db/pipeline/granularity_rounder.h
index 813e11b971e..a3cdb0c6086 100644
--- a/src/mongo/db/pipeline/granularity_rounder.h
+++ b/src/mongo/db/pipeline/granularity_rounder.h
@@ -55,7 +55,6 @@ namespace mongo {
 #define REGISTER_GRANULARITY_ROUNDER_GENERAL(name, key, rounder)               \
     MONGO_INITIALIZER(addToGranularityRounderMap_##key)(InitializerContext*) { \
         GranularityRounder::registerGranularityRounder(name, rounder);         \
-        return Status::OK();                                                   \
     }
 
 /**
diff --git a/src/mongo/db/profile_filter_impl.cpp b/src/mongo/db/profile_filter_impl.cpp
index 7f76083bd22..b010b51841b 100644
--- a/src/mongo/db/profile_filter_impl.cpp
+++ b/src/mongo/db/profile_filter_impl.cpp
@@ -83,7 +83,6 @@ MONGO_INITIALIZER_GENERAL(ProfileFilterDefault,
         if (auto expr = serverGlobalParams.defaultProfileFilter) {
             ProfileFilter::setDefault(std::make_shared<ProfileFilterImpl>(*expr));
         }
-        return Status::OK();
     } catch (AssertionException& e) {
         // Add more context to the error
         uasserted(ErrorCodes::FailedToParse,
diff --git a/src/mongo/db/query/collation/collator_factory_icu_decoration.cpp b/src/mongo/db/query/collation/collator_factory_icu_decoration.cpp
index 6eacae4c5a1..6ca6ae52ee6 100644
--- a/src/mongo/db/query/collation/collator_factory_icu_decoration.cpp
+++ b/src/mongo/db/query/collation/collator_factory_icu_decoration.cpp
@@ -36,13 +36,10 @@
 #include "mongo/db/service_context.h"
 
 namespace mongo {
-
 namespace {
-
 ServiceContext::ConstructorActionRegisterer registerIcuCollator{
     "CreateCollatorFactory", {"LoadICUData"}, [](ServiceContext* service) {
         CollatorFactoryInterface::set(service, std::make_unique<CollatorFactoryICU>());
     }};
 }  // namespace
-
 }  // namespace mongo
diff --git a/src/mongo/db/repl/data_replicator_external_state_impl.cpp b/src/mongo/db/repl/data_replicator_external_state_impl.cpp
index 31bb90785cd..8e693456799 100644
--- a/src/mongo/db/repl/data_replicator_external_state_impl.cpp
+++ b/src/mongo/db/repl/data_replicator_external_state_impl.cpp
@@ -55,10 +55,9 @@ const char kBlockingQueueOplogBufferName[] = "inMemoryBlockingQueue";
 MONGO_INITIALIZER(initialSyncOplogBuffer)(InitializerContext*) {
     if ((initialSyncOplogBuffer != kCollectionOplogBufferName) &&
         (initialSyncOplogBuffer != kBlockingQueueOplogBufferName)) {
-        return Status(ErrorCodes::BadValue,
-                      "unsupported initial sync oplog buffer option: " + initialSyncOplogBuffer);
+        uasserted(ErrorCodes::BadValue,
+                  "unsupported initial sync oplog buffer option: " + initialSyncOplogBuffer);
     }
-    return Status::OK();
 }
 
 }  // namespace
diff --git a/src/mongo/db/repl/isself.cpp b/src/mongo/db/repl/isself.cpp
index 1c561ff9f5d..85549d118d3 100644
--- a/src/mongo/db/repl/isself.cpp
+++ b/src/mongo/db/repl/isself.cpp
@@ -84,7 +84,6 @@ OID instanceId;
 
 MONGO_INITIALIZER(GenerateInstanceId)(InitializerContext*) {
     instanceId = OID::gen();
-    return Status::OK();
 }
 
 namespace {
diff --git a/src/mongo/db/s/balancer/core_options_stub.cpp b/src/mongo/db/s/balancer/core_options_stub.cpp
index 2b9c5d8b837..234d91c322a 100644
--- a/src/mongo/db/s/balancer/core_options_stub.cpp
+++ b/src/mongo/db/s/balancer/core_options_stub.cpp
@@ -35,8 +35,6 @@ namespace {
 MONGO_INITIALIZER_GENERAL(CoreOptions_Store,
                           ("BeginStartupOptionStorage"),
                           ("EndStartupOptionStorage"))
-(InitializerContext* context) {
-    return Status::OK();
-}
+(InitializerContext* context) {}
 }  // namespace
 }  // namespace mongo
diff --git a/src/mongo/db/s/config/configsvr_control_balancer_command.cpp b/src/mongo/db/s/config/configsvr_control_balancer_command.cpp
index 407828446fa..10fa0aa6739 100644
--- a/src/mongo/db/s/config/configsvr_control_balancer_command.cpp
+++ b/src/mongo/db/s/config/configsvr_control_balancer_command.cpp
@@ -148,8 +148,6 @@ MONGO_INITIALIZER(ClusterBalancerControlCommands)(InitializerContext* context) {
     new ConfigSvrBalancerStartCommand();
     new ConfigSvrBalancerStopCommand();
     new ConfigSvrBalancerStatusCommand();
-
-    return Status::OK();
 }
 
 }  // namespace
diff --git a/src/mongo/db/server_options_init.cpp b/src/mongo/db/server_options_init.cpp
index 29a278981ff..6396125dc77 100644
--- a/src/mongo/db/server_options_init.cpp
+++ b/src/mongo/db/server_options_init.cpp
@@ -36,7 +36,7 @@ MONGO_INITIALIZER_GENERAL(ServerOptions_Setup,
                           ("BeginStartupOptionSetup"),
                           ("EndStartupOptionSetup"))
 (InitializerContext* context) {
-    return setupServerOptions(context->args());
+    uassertStatusOK(setupServerOptions(context->args()));
 }
 
 }  // namespace mongo
diff --git a/src/mongo/db/server_options_test.cpp b/src/mongo/db/server_options_test.cpp
index d09cde9b797..5cc26ccd3c1 100644
--- a/src/mongo/db/server_options_test.cpp
+++ b/src/mongo/db/server_options_test.cpp
@@ -75,7 +75,6 @@ namespace moe = mongo::optionenvironment;
 MONGO_INITIALIZER(ServerLogRedirection)(mongo::InitializerContext*) {
     // ssl_options_server.cpp has an initializer which depends on logging.
     // We can stub that dependency out for unit testing purposes.
-    return Status::OK();
 }
 
 class OptionsParserTester : public moe::OptionsParser {
diff --git a/src/mongo/db/service_context.cpp b/src/mongo/db/service_context.cpp
index d69416b33b0..7fa4b4f637c 100644
--- a/src/mongo/db/service_context.cpp
+++ b/src/mongo/db/service_context.cpp
@@ -467,20 +467,16 @@ ServiceContext::ConstructorActionRegisterer::ConstructorActionRegisterer(
     DestructorAction destructor) {
     if (!destructor)
         destructor = [](ServiceContext*) {};
-    _registerer.emplace(std::move(name),
-                        [this, constructor, destructor](InitializerContext* context) {
-                            _iter = registeredConstructorActions().emplace(
-                                registeredConstructorActions().end(),
-                                std::move(constructor),
-                                std::move(destructor));
-                            return Status::OK();
-                        },
-                        [this](DeinitializerContext* context) {
-                            registeredConstructorActions().erase(_iter);
-                            return Status::OK();
-                        },
-                        std::move(prereqs),
-                        std::move(dependents));
+    _registerer.emplace(
+        std::move(name),
+        [this, constructor, destructor](InitializerContext*) {
+            _iter = registeredConstructorActions().emplace(registeredConstructorActions().end(),
+                                                           std::move(constructor),
+                                                           std::move(destructor));
+        },
+        [this](DeinitializerContext*) { registeredConstructorActions().erase(_iter); },
+        std::move(prereqs),
+        std::move(dependents));
 }
 
 ServiceContext::UniqueServiceContext ServiceContext::make() {
diff --git a/src/mongo/db/service_context.h b/src/mongo/db/service_context.h
index 4b900fa6384..1e4dffda45e 100644
--- a/src/mongo/db/service_context.h
+++ b/src/mongo/db/service_context.h
@@ -35,7 +35,6 @@
 #include <memory>
 #include <vector>
 
-#include "mongo/base/global_initializer_registerer.h"
 #include "mongo/db/logical_session_id.h"
 #include "mongo/db/storage/storage_engine.h"
 #include "mongo/platform/atomic_word.h"
diff --git a/src/mongo/db/storage/ephemeral_for_test/ephemeral_for_test_kv_engine_test.cpp b/src/mongo/db/storage/ephemeral_for_test/ephemeral_for_test_kv_engine_test.cpp
index e249daed751..76c5c843ff9 100644
--- a/src/mongo/db/storage/ephemeral_for_test/ephemeral_for_test_kv_engine_test.cpp
+++ b/src/mongo/db/storage/ephemeral_for_test/ephemeral_for_test_kv_engine_test.cpp
@@ -73,7 +73,6 @@ std::unique_ptr<mongo::KVHarnessHelper> makeHelper() {
 
 MONGO_INITIALIZER(RegisterEphemeralForTestKVHarnessFactory)(InitializerContext*) {
     KVHarnessHelper::registerFactory(makeHelper);
-    return Status::OK();
 }
 
 class EphemeralForTestKVEngineTest : public unittest::Test {
diff --git a/src/mongo/db/storage/ephemeral_for_test/ephemeral_for_test_record_store_test.cpp b/src/mongo/db/storage/ephemeral_for_test/ephemeral_for_test_record_store_test.cpp
index ec4c5db41ed..278510f7c16 100644
--- a/src/mongo/db/storage/ephemeral_for_test/ephemeral_for_test_record_store_test.cpp
+++ b/src/mongo/db/storage/ephemeral_for_test/ephemeral_for_test_record_store_test.cpp
@@ -91,9 +91,8 @@ std::unique_ptr<mongo::RecordStoreHarnessHelper> makeRecordStoreHarnessHelper()
     return std::make_unique<RecordStoreHarnessHelper>();
 }
 
-MONGO_INITIALIZER(RegisterRecordStoreHarnessFactory)(InitializerContext* const) {
+MONGO_INITIALIZER(RegisterRecordStoreHarnessFactory)(InitializerContext*) {
     mongo::registerRecordStoreHarnessHelperFactory(makeRecordStoreHarnessHelper);
-    return Status::OK();
 }
 }  // namespace
 }  // namespace ephemeral_for_test
diff --git a/src/mongo/db/storage/ephemeral_for_test/ephemeral_for_test_recovery_unit_test.cpp b/src/mongo/db/storage/ephemeral_for_test/ephemeral_for_test_recovery_unit_test.cpp
index d796c783c4e..fbcf2b5fb9d 100644
--- a/src/mongo/db/storage/ephemeral_for_test/ephemeral_for_test_recovery_unit_test.cpp
+++ b/src/mongo/db/storage/ephemeral_for_test/ephemeral_for_test_recovery_unit_test.cpp
@@ -69,7 +69,6 @@ std::unique_ptr<mongo::RecoveryUnitHarnessHelper> makeRecoveryUnitHarnessHelper(
 
 MONGO_INITIALIZER(RegisterRecoveryUnitHarnessFactory)(InitializerContext* const) {
     mongo::registerRecoveryUnitHarnessHelperFactory(makeRecoveryUnitHarnessHelper);
-    return Status::OK();
 }
 
 }  // namespace
diff --git a/src/mongo/db/storage/ephemeral_for_test/ephemeral_for_test_sorted_impl_test.cpp b/src/mongo/db/storage/ephemeral_for_test/ephemeral_for_test_sorted_impl_test.cpp
index 7b3c88a4532..be04273b3f2 100644
--- a/src/mongo/db/storage/ephemeral_for_test/ephemeral_for_test_sorted_impl_test.cpp
+++ b/src/mongo/db/storage/ephemeral_for_test/ephemeral_for_test_sorted_impl_test.cpp
@@ -104,7 +104,6 @@ std::unique_ptr<mongo::SortedDataInterfaceHarnessHelper> makeSortedDataInterface
 
 MONGO_INITIALIZER(RegisterSortedDataInterfaceHarnessFactory)(InitializerContext* const) {
     mongo::registerSortedDataInterfaceHarnessHelperFactory(makeSortedDataInterfaceHarnessHelper);
-    return Status::OK();
 }
 }  // namespace
 }  // namespace ephemeral_for_test
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_kv_engine_test.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_kv_engine_test.cpp
index 8bf3312e1c2..e5d2fda83c0 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_kv_engine_test.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_kv_engine_test.cpp
@@ -397,7 +397,6 @@ std::unique_ptr<KVHarnessHelper> makeHelper() {
 
 MONGO_INITIALIZER(RegisterKVHarnessFactory)(InitializerContext*) {
     KVHarnessHelper::registerFactory(makeHelper);
-    return Status::OK();
 }
 
 }  // namespace
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_options_init.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_options_init.cpp
index 90292778505..9773f267e05 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_options_init.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_options_init.cpp
@@ -48,6 +48,5 @@ MONGO_STARTUP_OPTIONS_STORE(WiredTigerOptions)(InitializerContext* context) {
         std::cerr << "try '" << context->args()[0] << " --help' for more information" << std::endl;
         ::_exit(EXIT_BADOPTIONS);
     }
-    return Status::OK();
 }
 }  // namespace mongo
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_prefixed_index_test.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_prefixed_index_test.cpp
index 20afb98beac..e29e7ca4b17 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_prefixed_index_test.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_prefixed_index_test.cpp
@@ -147,7 +147,6 @@ std::unique_ptr<SortedDataInterfaceHarnessHelper> makeWTPrefixedIndexHarnessHelp
 
 MONGO_INITIALIZER(RegisterSortedDataInterfaceHarnessFactory)(InitializerContext* const) {
     mongo::registerSortedDataInterfaceHarnessHelperFactory(makeWTPrefixedIndexHarnessHelper);
-    return Status::OK();
 }
 }  // namespace
 }  // namespace mongo
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_prefixed_record_store_test.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_prefixed_record_store_test.cpp
index aabe631120d..43c6e9a706e 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_prefixed_record_store_test.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_prefixed_record_store_test.cpp
@@ -203,7 +203,6 @@ std::unique_ptr<RecordStoreHarnessHelper> makeWTRSHarnessHelper() {
 
 MONGO_INITIALIZER(RegisterRecordStoreHarnessFactory)(InitializerContext* const) {
     mongo::registerRecordStoreHarnessHelperFactory(makeWTRSHarnessHelper);
-    return Status::OK();
 }
 
 TEST(WiredTigerRecordStoreTest, PrefixedTableScan) {
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit_test.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit_test.cpp
index c7ba49f4c61..0fe252a0f3a 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit_test.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit_test.cpp
@@ -127,7 +127,6 @@ std::unique_ptr<RecoveryUnitHarnessHelper> makeWTRUHarnessHelper() {
 
 MONGO_INITIALIZER(RegisterHarnessFactory)(InitializerContext* const) {
     mongo::registerRecoveryUnitHarnessHelperFactory(makeWTRUHarnessHelper);
-    return Status::OK();
 }
 
 class WiredTigerRecoveryUnitTestFixture : public unittest::Test {
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_standard_index_test.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_standard_index_test.cpp
index 05a9eb69c23..4113027a395 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_standard_index_test.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_standard_index_test.cpp
@@ -148,7 +148,6 @@ std::unique_ptr<SortedDataInterfaceHarnessHelper> makeWTIndexHarnessHelper() {
 
 MONGO_INITIALIZER(RegisterSortedDataInterfaceHarnessFactory)(InitializerContext* const) {
     mongo::registerSortedDataInterfaceHarnessHelperFactory(makeWTIndexHarnessHelper);
-    return Status::OK();
 }
 
 TEST(WiredTigerStandardIndexText, CursorInActiveTxnAfterNext) {
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_standard_record_store_test.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_standard_record_store_test.cpp
index 78b627ed40c..1f93a9fc63c 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_standard_record_store_test.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_standard_record_store_test.cpp
@@ -200,7 +200,6 @@ std::unique_ptr<RecordStoreHarnessHelper> makeWTRSHarnessHelper() {
 
 MONGO_INITIALIZER(RegisterRecordStoreHarnessFactory)(InitializerContext* const) {
     mongo::registerRecordStoreHarnessHelperFactory(makeWTRSHarnessHelper);
-    return Status::OK();
 }
 
 TEST(WiredTigerRecordStoreTest, StorageSizeStatisticsDisabled) {
diff --git a/src/mongo/db/system_index.cpp b/src/mongo/db/system_index.cpp
index b08598d0f51..c2eedda74ea 100644
--- a/src/mongo/db/system_index.cpp
+++ b/src/mongo/db/system_index.cpp
@@ -85,8 +85,6 @@ MONGO_INITIALIZER(AuthIndexKeyPatterns)(InitializerContext*) {
     v3SystemRolesIndexSpec.addKeys(v3SystemRolesKeyPattern);
     v3SystemRolesIndexSpec.unique();
     v3SystemRolesIndexSpec.name(v3SystemRolesIndexName);
-
-    return Status::OK();
 }
 
 void generateSystemIndexForExistingCollection(OperationContext* opCtx,
diff --git a/src/mongo/db/traffic_recorder.cpp b/src/mongo/db/traffic_recorder.cpp
index f13388e1892..7cbfaeef7c5 100644
--- a/src/mongo/db/traffic_recorder.cpp
+++ b/src/mongo/db/traffic_recorder.cpp
@@ -54,22 +54,20 @@ bool shouldAlwaysRecordTraffic = false;
 
 MONGO_INITIALIZER(ShouldAlwaysRecordTraffic)(InitializerContext*) {
     if (!gAlwaysRecordTraffic.size()) {
-        return Status::OK();
+        return;
     }
 
     if (gTrafficRecordingDirectory.empty()) {
         if (serverGlobalParams.logpath.empty()) {
-            return Status(ErrorCodes::BadValue,
-                          "invalid to set AlwaysRecordTraffic without a logpath or "
-                          "trafficRecordingDirectory");
+            uasserted(ErrorCodes::BadValue,
+                      "invalid to set AlwaysRecordTraffic without a logpath or "
+                      "trafficRecordingDirectory");
         } else {
             gTrafficRecordingDirectory = serverGlobalParams.logpath;
         }
     }
 
     shouldAlwaysRecordTraffic = true;
-
-    return Status::OK();
 }
 
 }  // namespace
diff --git a/src/mongo/db/update/modifier_table.cpp b/src/mongo/db/update/modifier_table.cpp
index ed054989547..9e181b40dc1 100644
--- a/src/mongo/db/update/modifier_table.cpp
+++ b/src/mongo/db/update/modifier_table.cpp
@@ -123,8 +123,6 @@ MONGO_INITIALIZER(ModifierTable)(InitializerContext* context) {
     MODIFIER_NAME_MAP = new NameMap(
         SimpleStringDataComparator::kInstance.makeStringDataUnorderedMap<ModifierEntry*>());
     init(MODIFIER_NAME_MAP);
-
-    return Status::OK();
 }
 
 ModifierType getType(StringData typeStr) {
diff --git a/src/mongo/dbtests/dbtests.cpp b/src/mongo/dbtests/dbtests.cpp
index c083e433558..76529854f12 100644
--- a/src/mongo/dbtests/dbtests.cpp
+++ b/src/mongo/dbtests/dbtests.cpp
@@ -85,7 +85,6 @@ MONGO_INITIALIZER_WITH_PREREQUISITES(WireSpec, ("EndStartupOptionHandling"))(Ini
     spec.outgoing.maxWireVersion = LATEST_WIRE_VERSION;
 
     WireSpec::instance().initialize(std::move(spec));
-    return Status::OK();
 }
 
 Status createIndex(OperationContext* opCtx, StringData ns, const BSONObj& keys, bool unique) {
diff --git a/src/mongo/dbtests/framework_options_init.cpp b/src/mongo/dbtests/framework_options_init.cpp
index 9ecf7993499..ebabe8f329a 100644
--- a/src/mongo/dbtests/framework_options_init.cpp
+++ b/src/mongo/dbtests/framework_options_init.cpp
@@ -39,18 +39,14 @@
 
 namespace mongo {
 MONGO_GENERAL_STARTUP_OPTIONS_REGISTER(FrameworkOptions)(InitializerContext* context) {
-    return addTestFrameworkOptions(&moe::startupOptions);
+    uassertStatusOK(addTestFrameworkOptions(&moe::startupOptions));
 }
 
 MONGO_STARTUP_OPTIONS_VALIDATE(FrameworkOptions)(InitializerContext* context) {
     if (!handlePreValidationTestFrameworkOptions(moe::startupOptionsParsed, context->args())) {
         quickExit(EXIT_SUCCESS);
     }
-    Status ret = moe::startupOptionsParsed.validate();
-    if (!ret.isOK()) {
-        return ret;
-    }
-    return Status::OK();
+    uassertStatusOK(moe::startupOptionsParsed.validate());
 }
 
 MONGO_STARTUP_OPTIONS_STORE(FrameworkOptions)(InitializerContext* context) {
@@ -60,11 +56,8 @@ MONGO_STARTUP_OPTIONS_STORE(FrameworkOptions)(InitializerContext* context) {
         std::cerr << "try '" << context->args()[0] << " --help' for more information" << std::endl;
         quickExit(EXIT_BADOPTIONS);
     }
-    return Status::OK();
 }
 
-MONGO_INITIALIZER_GENERAL(CoreOptions_Store, MONGO_NO_PREREQUISITES, MONGO_NO_DEPENDENTS)
-(InitializerContext* context) {
-    return Status::OK();
-}
+MONGO_INITIALIZER_GENERAL(CoreOptions_Store, (), ())
+(InitializerContext* context) {}
 }  // namespace mongo
diff --git a/src/mongo/dbtests/mock/mock_conn_registry.cpp b/src/mongo/dbtests/mock/mock_conn_registry.cpp
index 37d9df06ceb..018cc8ba7b2 100644
--- a/src/mongo/dbtests/mock/mock_conn_registry.cpp
+++ b/src/mongo/dbtests/mock/mock_conn_registry.cpp
@@ -41,7 +41,7 @@ using std::string;
 std::unique_ptr<MockConnRegistry> MockConnRegistry::_instance;
 
 MONGO_INITIALIZER(MockConnRegistry)(InitializerContext* context) {
-    return MockConnRegistry::init();
+    uassertStatusOK(MockConnRegistry::init());
 }
 
 Status MockConnRegistry::init() {
diff --git a/src/mongo/embedded/embedded.cpp b/src/mongo/embedded/embedded.cpp
index 215a99a8c9c..d8301a76ead 100644
--- a/src/mongo/embedded/embedded.cpp
+++ b/src/mongo/embedded/embedded.cpp
@@ -94,14 +94,11 @@ MONGO_INITIALIZER_WITH_PREREQUISITES(WireSpec, ("EndStartupOptionHandling"))(Ini
     spec.isInternalClient = true;
 
     WireSpec::instance().initialize(std::move(spec));
-    return Status::OK();
 }
 
 // Noop, to fulfill dependencies for other initializers.
 MONGO_INITIALIZER_GENERAL(ForkServer, ("EndStartupOptionHandling"), ("default"))
-(InitializerContext* context) {
-    return Status::OK();
-}
+(InitializerContext* context) {}
 
 void setUpCatalog(ServiceContext* serviceContext) {
     DatabaseHolder::set(serviceContext, std::make_unique<DatabaseHolderImpl>());
@@ -124,7 +121,6 @@ ServiceContext::ConstructorActionRegisterer replicationManagerInitializer(
 
 MONGO_INITIALIZER(fsyncLockedForWriting)(InitializerContext* context) {
     setLockedForWritingImpl([]() { return false; });
-    return Status::OK();
 }
 
 GlobalInitializerRegisterer filterAllowedIndexFieldNamesEmbeddedInitializer(
@@ -135,7 +131,6 @@ GlobalInitializerRegisterer filterAllowedIndexFieldNamesEmbeddedInitializer(
                 allowedIndexFieldNames.erase(IndexDescriptor::kBackgroundFieldName);
                 allowedIndexFieldNames.erase(IndexDescriptor::kExpireAfterSecondsFieldName);
             };
-        return Status::OK();
     },
     DeinitializerFunction(nullptr),
     {},
diff --git a/src/mongo/embedded/embedded_options_init.cpp b/src/mongo/embedded/embedded_options_init.cpp
index dcb40582c9e..d2c69d2200f 100644
--- a/src/mongo/embedded/embedded_options_init.cpp
+++ b/src/mongo/embedded/embedded_options_init.cpp
@@ -36,7 +36,7 @@ namespace mongo {
 namespace embedded {
 
 MONGO_GENERAL_STARTUP_OPTIONS_REGISTER(EmbeddedOptions)(InitializerContext* context) {
-    return addOptions(&optionenvironment::startupOptions);
+    uassertStatusOK(addOptions(&optionenvironment::startupOptions));
 }
 
 GlobalInitializerRegisterer embeddedOptionsInitializer(
diff --git a/src/mongo/executor/network_interface_thread_pool_test.cpp b/src/mongo/executor/network_interface_thread_pool_test.cpp
index b6847284985..88a69a8b9fc 100644
--- a/src/mongo/executor/network_interface_thread_pool_test.cpp
+++ b/src/mongo/executor/network_interface_thread_pool_test.cpp
@@ -82,7 +82,6 @@ private:
 MONGO_INITIALIZER(ThreadPoolCommonTests)(InitializerContext*) {
     addTestsForThreadPool("ThreadPoolCommon",
                           []() { return std::make_unique<NetworkInterfaceThreadPoolWithASIO>(); });
-    return Status::OK();
 }
 
 }  // namespace
diff --git a/src/mongo/executor/thread_pool_task_executor_test.cpp b/src/mongo/executor/thread_pool_task_executor_test.cpp
index 556d9ee95f0..826f76a7c01 100644
--- a/src/mongo/executor/thread_pool_task_executor_test.cpp
+++ b/src/mongo/executor/thread_pool_task_executor_test.cpp
@@ -53,7 +53,6 @@ MONGO_INITIALIZER(ThreadPoolExecutorCommonTests)(InitializerContext*) {
     addTestsForExecutor("ThreadPoolExecutorCommon", [](std::unique_ptr<NetworkInterfaceMock> net) {
         return makeSharedThreadPoolTestExecutor(std::move(net));
     });
-    return Status::OK();
 }
 
 TEST_F(ThreadPoolExecutorTest, TimelyCancelationOfScheduleWorkAt) {
diff --git a/src/mongo/idl/config_option_test.cpp b/src/mongo/idl/config_option_test.cpp
index 78bdf0df513..cdc56cb0138 100644
--- a/src/mongo/idl/config_option_test.cpp
+++ b/src/mongo/idl/config_option_test.cpp
@@ -93,7 +93,7 @@ MONGO_STARTUP_OPTIONS_PARSE(ConfigOption)(InitializerContext*) {
         "--testConfigOpt14",
         "set14",
     };
-    return parseArgv(argv, &moe::startupOptionsParsed);
+    uassertStatusOK(parseArgv(argv, &moe::startupOptionsParsed));
 }
 
 template <typename T>
diff --git a/src/mongo/idl/server_parameter.cpp b/src/mongo/idl/server_parameter.cpp
index b0cd8c6d16e..05db8b9c856 100644
--- a/src/mongo/idl/server_parameter.cpp
+++ b/src/mongo/idl/server_parameter.cpp
@@ -36,9 +36,7 @@
 namespace mongo {
 using SPT = ServerParameterType;
 
-MONGO_INITIALIZER_GROUP(BeginServerParameterRegistration,
-                        MONGO_NO_PREREQUISITES,
-                        ("EndServerParameterRegistration"))
+MONGO_INITIALIZER_GROUP(BeginServerParameterRegistration, (), ("EndServerParameterRegistration"))
 MONGO_INITIALIZER_GROUP(EndServerParameterRegistration,
                         ("BeginServerParameterRegistration"),
                         ("BeginStartupOptionHandling"))
diff --git a/src/mongo/logv2/console.cpp b/src/mongo/logv2/console.cpp
index 48fc9a16b84..4691b332d47 100644
--- a/src/mongo/logv2/console.cpp
+++ b/src/mongo/logv2/console.cpp
@@ -235,7 +235,6 @@ std::ostream* windowsOutputStream = getWindowsOutputStream();
 // the initalizer chain.
 MONGO_INITIALIZER(EnsureIosBaseInitConstructedV2)(InitializerContext*) {
     Console forInitializationOnly;
-    return Status::OK();
 }
 
 }  // namespace
diff --git a/src/mongo/logv2/log_manager.cpp b/src/mongo/logv2/log_manager.cpp
index 4794636ea45..e75b2f155bc 100644
--- a/src/mongo/logv2/log_manager.cpp
+++ b/src/mongo/logv2/log_manager.cpp
@@ -104,7 +104,6 @@ MONGO_INITIALIZER(GlobalLogRotator)(InitializerContext*) {
     addLogRotator([](bool renameFiles, StringData suffix) {
         return LogManager::global().getGlobalDomainInternal().rotate(renameFiles, suffix);
     });
-    return Status::OK();
 }
 
 }  // namespace mongo::logv2
diff --git a/src/mongo/logv2/ramlog.cpp b/src/mongo/logv2/ramlog.cpp
index eb2a01b72e1..fd024403d42 100644
--- a/src/mongo/logv2/ramlog.cpp
+++ b/src/mongo/logv2/ramlog.cpp
@@ -31,6 +31,8 @@
 
 #include "mongo/logv2/ramlog.h"
 
+#include <map>
+
 #include "mongo/base/init.h"
 #include "mongo/base/status.h"
 #include "mongo/util/str.h"
@@ -193,15 +195,12 @@ void RamLog::getNames(std::vector<string>& names) {
 MONGO_INITIALIZER(RamLogCatalogV2)(InitializerContext*) {
     if (!_namedLock) {
         if (_named) {
-            return Status(ErrorCodes::InternalError,
-                          "Inconsistent intiailization of RamLogCatalog.");
+            uasserted(ErrorCodes::InternalError, "Inconsistent intiailization of RamLogCatalog.");
         }
 
         _namedLock = new stdx::mutex();  // NOLINT
         _named = new RM();
     }
-
-    return Status::OK();
 }
 
 }  // namespace mongo::logv2
diff --git a/src/mongo/platform/mutex.cpp b/src/mongo/platform/mutex.cpp
index b913cd0d152..eb2501000c2 100644
--- a/src/mongo/platform/mutex.cpp
+++ b/src/mongo/platform/mutex.cpp
@@ -155,8 +155,6 @@ void Mutex::_onUnlock() noexcept {
 MONGO_INITIALIZER(FinalizeDiagnosticListeners)(InitializerContext* context) {
     auto& state = latch_detail::getDiagnosticListenerState();
     state.isFinalized.store(true);
-
-    return Status::OK();
 }
 
 }  // namespace mongo::latch_detail
diff --git a/src/mongo/platform/posix_fadvise.cpp b/src/mongo/platform/posix_fadvise.cpp
index 689d5de94b0..a9b605dc185 100644
--- a/src/mongo/platform/posix_fadvise.cpp
+++ b/src/mongo/platform/posix_fadvise.cpp
@@ -54,14 +54,13 @@ int posix_fadvise(int fd, off_t offset, off_t len, int advice) {
 
 // 'posix_fadvise()' on Solaris will call the emulation if the symbol is not found
 //
-MONGO_INITIALIZER_GENERAL(SolarisPosixFadvise, MONGO_NO_PREREQUISITES, ("default"))
+MONGO_INITIALIZER_GENERAL(SolarisPosixFadvise, (), ("default"))
 (InitializerContext* context) {
     void* functionAddress = dlsym(RTLD_DEFAULT, "posix_fadvise");
     if (functionAddress != nullptr) {
         mongo::pal::posix_fadvise_switcher =
             reinterpret_cast<mongo::pal::PosixFadviseFunc>(functionAddress);
     }
-    return Status::OK();
 }
 
 }  // namespace mongo
diff --git a/src/mongo/platform/strcasestr.cpp b/src/mongo/platform/strcasestr.cpp
index 9c5ffe23a3c..1d0f4b5a006 100644
--- a/src/mongo/platform/strcasestr.cpp
+++ b/src/mongo/platform/strcasestr.cpp
@@ -93,14 +93,13 @@ namespace mongo {
 
 // 'strcasestr()' on Solaris will call the emulation if the symbol is not found
 //
-MONGO_INITIALIZER_GENERAL(SolarisStrCaseCmp, MONGO_NO_PREREQUISITES, ("default"))
+MONGO_INITIALIZER_GENERAL(SolarisStrCaseCmp, (), ("default"))
 (InitializerContext* context) {
     void* functionAddress = dlsym(RTLD_DEFAULT, "strcasestr");
     if (functionAddress != nullptr) {
         mongo::pal::strcasestr_switcher =
             reinterpret_cast<mongo::pal::StrCaseStrFunc>(functionAddress);
     }
-    return Status::OK();
 }
 
 }  // namespace mongo
diff --git a/src/mongo/s/chunk_manager_refresh_bm.cpp b/src/mongo/s/chunk_manager_refresh_bm.cpp
index 9b0e05dc2cd..28f36dd07fd 100644
--- a/src/mongo/s/chunk_manager_refresh_bm.cpp
+++ b/src/mongo/s/chunk_manager_refresh_bm.cpp
@@ -402,8 +402,6 @@ MONGO_INITIALIZER(RegisterBenchmarks)(InitializerContext* context) {
             ->Args({1000, 50000})
             ->Args({2, 2});
     }
-
-    return Status::OK();
 }
 
 }  // namespace
diff --git a/src/mongo/s/commands/cluster_command_test_fixture.cpp b/src/mongo/s/commands/cluster_command_test_fixture.cpp
index 8c8813a3b11..76f294518b5 100644
--- a/src/mongo/s/commands/cluster_command_test_fixture.cpp
+++ b/src/mongo/s/commands/cluster_command_test_fixture.cpp
@@ -309,8 +309,6 @@ void ClusterCommandTestFixture::appendTxnResponseMetadata(BSONObjBuilder& bob) {
 }
 
 // Satisfies dependency from StoreSASLOPtions.
-MONGO_STARTUP_OPTIONS_STORE(CoreOptions)(InitializerContext*) {
-    return Status::OK();
-}
+MONGO_STARTUP_OPTIONS_STORE(CoreOptions)(InitializerContext*) {}
 
 }  // namespace mongo
diff --git a/src/mongo/s/commands/cluster_control_balancer_cmd.cpp b/src/mongo/s/commands/cluster_control_balancer_cmd.cpp
index 5ded533666b..a4b2b2c9d48 100644
--- a/src/mongo/s/commands/cluster_control_balancer_cmd.cpp
+++ b/src/mongo/s/commands/cluster_control_balancer_cmd.cpp
@@ -141,8 +141,6 @@ MONGO_INITIALIZER(ClusterBalancerControlCommands)(InitializerContext* context) {
     new BalancerStartCommand();
     new BalancerStopCommand();
     new BalancerStatusCommand();
-
-    return Status::OK();
 }
 
 }  // namespace
diff --git a/src/mongo/s/commands/cluster_ftdc_commands.cpp b/src/mongo/s/commands/cluster_ftdc_commands.cpp
index 26694115c7c..3b2ac9e0a16 100644
--- a/src/mongo/s/commands/cluster_ftdc_commands.cpp
+++ b/src/mongo/s/commands/cluster_ftdc_commands.cpp
@@ -111,8 +111,6 @@ Command* ftdcCommand;
 
 MONGO_INITIALIZER(CreateDiagnosticDataCommand)(InitializerContext* context) {
     ftdcCommand = new GetDiagnosticDataCommand();
-
-    return Status::OK();
 }
 
 }  // namespace
diff --git a/src/mongo/s/mongos_main.cpp b/src/mongo/s/mongos_main.cpp
index b2a7cb15b77..861c3c830d1 100644
--- a/src/mongo/s/mongos_main.cpp
+++ b/src/mongo/s/mongos_main.cpp
@@ -485,7 +485,6 @@ MONGO_INITIALIZER_WITH_PREREQUISITES(WireSpec, ("EndStartupOptionHandling"))(Ini
     spec.isInternalClient = true;
 
     WireSpec::instance().initialize(std::move(spec));
-    return Status::OK();
 }
 
 class ShardingReplicaSetChangeListener final
@@ -876,7 +875,6 @@ ExitCode main(ServiceContext* serviceContext) {
 MONGO_INITIALIZER_GENERAL(ForkServer, ("EndStartupOptionHandling"), ("default"))
 (InitializerContext* context) {
     forkServerOrDie();
-    return Status::OK();
 }
 
 // Initialize the featureCompatibilityVersion server parameter since mongos does not have a
@@ -890,14 +888,12 @@ MONGO_INITIALIZER_WITH_PREREQUISITES(SetFeatureCompatibilityVersionLatest,
 (InitializerContext* context) {
     serverGlobalParams.mutableFeatureCompatibility.setVersion(
         ServerGlobalParams::FeatureCompatibility::kLatest);
-    return Status::OK();
 }
 
 #ifdef MONGO_CONFIG_SSL
-MONGO_INITIALIZER_GENERAL(setSSLManagerType, MONGO_NO_PREREQUISITES, ("SSLManager"))
+MONGO_INITIALIZER_GENERAL(setSSLManagerType, (), ("SSLManager"))
 (InitializerContext* context) {
     isSSLServer = true;
-    return Status::OK();
 }
 #endif
 
diff --git a/src/mongo/s/mongos_options_init.cpp b/src/mongo/s/mongos_options_init.cpp
index cf139b81b92..b0c96991f52 100644
--- a/src/mongo/s/mongos_options_init.cpp
+++ b/src/mongo/s/mongos_options_init.cpp
@@ -44,22 +44,10 @@
 
 namespace mongo {
 MONGO_GENERAL_STARTUP_OPTIONS_REGISTER(MongosOptions)(InitializerContext* context) {
-    auto status = addGeneralServerOptions(&moe::startupOptions);
-    if (!status.isOK()) {
-        return status;
-    }
-
-    status = addKeyfileServerOption(&moe::startupOptions);
-    if (!status.isOK()) {
-        return status;
-    }
-
-    status = addClusterAuthModeServerOption(&moe::startupOptions);
-    if (!status.isOK()) {
-        return status;
-    }
-
-    return addNonGeneralServerOptions(&moe::startupOptions);
+    uassertStatusOK(addGeneralServerOptions(&moe::startupOptions));
+    uassertStatusOK(addKeyfileServerOption(&moe::startupOptions));
+    uassertStatusOK(addClusterAuthModeServerOption(&moe::startupOptions));
+    uassertStatusOK(addNonGeneralServerOptions(&moe::startupOptions));
 }
 
 MONGO_INITIALIZER_GENERAL(MongosOptions,
@@ -71,23 +59,10 @@ MONGO_INITIALIZER_GENERAL(MongosOptions,
     }
     // Run validation, but tell the Environment that we don't want it to be set as "valid",
     // since we may be making it invalid in the canonicalization process.
-    Status ret = moe::startupOptionsParsed.validate(false /*setValid*/);
-    if (!ret.isOK()) {
-        return ret;
-    }
-    ret = validateMongosOptions(moe::startupOptionsParsed);
-    if (!ret.isOK()) {
-        return ret;
-    }
-    ret = canonicalizeMongosOptions(&moe::startupOptionsParsed);
-    if (!ret.isOK()) {
-        return ret;
-    }
-    ret = moe::startupOptionsParsed.validate();
-    if (!ret.isOK()) {
-        return ret;
-    }
-    return Status::OK();
+    uassertStatusOK(moe::startupOptionsParsed.validate(false /*setValid*/));
+    uassertStatusOK(validateMongosOptions(moe::startupOptionsParsed));
+    uassertStatusOK(canonicalizeMongosOptions(&moe::startupOptionsParsed));
+    uassertStatusOK(moe::startupOptionsParsed.validate());
 }
 
 MONGO_INITIALIZER_GENERAL(CoreOptions_Store,
@@ -100,7 +75,6 @@ MONGO_INITIALIZER_GENERAL(CoreOptions_Store,
         std::cerr << "try '" << context->args()[0] << " --help' for more information" << std::endl;
         quickExit(EXIT_BADOPTIONS);
     }
-    return Status::OK();
 }
 
 }  // namespace mongo
diff --git a/src/mongo/s/mongos_topology_coordinator.cpp b/src/mongo/s/mongos_topology_coordinator.cpp
index 2cc3d230690..8b0cec8c2fa 100644
--- a/src/mongo/s/mongos_topology_coordinator.cpp
+++ b/src/mongo/s/mongos_topology_coordinator.cpp
@@ -51,7 +51,6 @@ OID instanceId;
 
 MONGO_INITIALIZER(GenerateMongosInstanceId)(InitializerContext*) {
     instanceId = OID::gen();
-    return Status::OK();
 }
 
 // Signals that a hello request has started waiting.
diff --git a/src/mongo/shell/encrypted_dbclient_base.cpp b/src/mongo/shell/encrypted_dbclient_base.cpp
index 688484c4769..dd20a63e9cf 100644
--- a/src/mongo/shell/encrypted_dbclient_base.cpp
+++ b/src/mongo/shell/encrypted_dbclient_base.cpp
@@ -787,7 +787,6 @@ std::unique_ptr<DBClientBase> createEncryptedDBClientBase(std::unique_ptr<DBClie
 
 MONGO_INITIALIZER(setCallbacksForEncryptedDBClientBase)(InitializerContext*) {
     mongo::mozjs::setEncryptedDBClientCallback(createEncryptedDBClientBase);
-    return Status::OK();
 }
 
 }  // namespace
diff --git a/src/mongo/shell/kms_aws.cpp b/src/mongo/shell/kms_aws.cpp
index 4b2364fe3d7..2cc3b2ee2bd 100644
--- a/src/mongo/shell/kms_aws.cpp
+++ b/src/mongo/shell/kms_aws.cpp
@@ -334,7 +334,6 @@ MONGO_INITIALIZER(KMSRegister)(::mongo::InitializerContext* context) {
     kms_message_init();
     KMSServiceController::registerFactory(KMSProviderEnum::aws,
                                           std::make_unique<AWSKMSServiceFactory>());
-    return Status::OK();
 }
 
 }  // namespace mongo
diff --git a/src/mongo/shell/kms_local.cpp b/src/mongo/shell/kms_local.cpp
index 1430596c18e..10fcb46f2a8 100644
--- a/src/mongo/shell/kms_local.cpp
+++ b/src/mongo/shell/kms_local.cpp
@@ -141,7 +141,6 @@ public:
 MONGO_INITIALIZER(LocalKMSRegister)(::mongo::InitializerContext* context) {
     KMSServiceController::registerFactory(KMSProviderEnum::local,
                                           std::make_unique<LocalKMSServiceFactory>());
-    return Status::OK();
 }
 
 }  // namespace mongo
diff --git a/src/mongo/shell/kms_shell.cpp b/src/mongo/shell/kms_shell.cpp
index f05fbdf3c8e..673fe7fb921 100644
--- a/src/mongo/shell/kms_shell.cpp
+++ b/src/mongo/shell/kms_shell.cpp
@@ -45,7 +45,6 @@ void callback_fn(Scope& scope) {
 
 MONGO_INITIALIZER(setKeyvaultCallback)(InitializerContext*) {
     shell_utils::setEnterpriseShellCallback(mongo::callback_fn);
-    return Status::OK();
 }
 
 }  // namespace
diff --git a/src/mongo/shell/mongo_main.cpp b/src/mongo/shell/mongo_main.cpp
index 6d0ff876265..32328dbe682 100644
--- a/src/mongo/shell/mongo_main.cpp
+++ b/src/mongo/shell/mongo_main.cpp
@@ -120,12 +120,10 @@ MONGO_INITIALIZER_WITH_PREREQUISITES(SetFeatureCompatibilityVersionLatest,
 (InitializerContext* context) {
     mongo::serverGlobalParams.mutableFeatureCompatibility.setVersion(
         ServerGlobalParams::FeatureCompatibility::kLatest);
-    return Status::OK();
 }
 
 MONGO_INITIALIZER_WITH_PREREQUISITES(WireSpec, ("EndStartupOptionSetup"))(InitializerContext*) {
     WireSpec::instance().initialize(WireSpec::Specification{});
-    return Status::OK();
 }
 
 const auto kAuthParam = "authSource"s;
diff --git a/src/mongo/shell/mongodbcr.cpp b/src/mongo/shell/mongodbcr.cpp
index b177a316426..e90320c527e 100644
--- a/src/mongo/shell/mongodbcr.cpp
+++ b/src/mongo/shell/mongodbcr.cpp
@@ -138,7 +138,6 @@ Future<void> authMongoCRImpl(RunCommandHook runCommand, const BSONObj& params) {
 
 MONGO_INITIALIZER(RegisterAuthMongoCR)(InitializerContext* context) {
     authMongoCR = authMongoCRImpl;
-    return Status::OK();
 }
 
 }  // namespace
diff --git a/src/mongo/shell/shell_options_init.cpp b/src/mongo/shell/shell_options_init.cpp
index 2ea64570bc8..b89b024a2b6 100644
--- a/src/mongo/shell/shell_options_init.cpp
+++ b/src/mongo/shell/shell_options_init.cpp
@@ -42,12 +42,7 @@ MONGO_STARTUP_OPTIONS_VALIDATE(MongoShellOptions)(InitializerContext* context) {
     if (!handlePreValidationMongoShellOptions(moe::startupOptionsParsed, context->args())) {
         quickExit(EXIT_SUCCESS);
     }
-    Status ret = moe::startupOptionsParsed.validate();
-    if (!ret.isOK()) {
-        return ret;
-    }
-
-    return Status::OK();
+    uassertStatusOK(moe::startupOptionsParsed.validate());
 }
 
 MONGO_STARTUP_OPTIONS_STORE(MongoShellOptions)(InitializerContext* context) {
@@ -57,6 +52,5 @@ MONGO_STARTUP_OPTIONS_STORE(MongoShellOptions)(InitializerContext* context) {
         std::cerr << "try '" << context->args()[0] << " --help' for more information" << std::endl;
         quickExit(EXIT_BADOPTIONS);
     }
-    return Status::OK();
 }
 }  // namespace mongo
diff --git a/src/mongo/tools/bridge_commands.cpp b/src/mongo/tools/bridge_commands.cpp
index aa3bc583a15..6ff96970e7e 100644
--- a/src/mongo/tools/bridge_commands.cpp
+++ b/src/mongo/tools/bridge_commands.cpp
@@ -167,7 +167,6 @@ MONGO_INITIALIZER(RegisterBridgeCommands)(InitializerContext* context) {
     bridgeCommandMap["acceptConnectionsFrom"] = new CmdAcceptConnectionsFrom();
     bridgeCommandMap["rejectConnectionsFrom"] = new CmdRejectConnectionsFrom();
     bridgeCommandMap["discardMessagesFrom"] = new CmdDiscardMessagesFrom();
-    return Status::OK();
 }
 
 }  // namespace
diff --git a/src/mongo/tools/mongobridge_options_init.cpp b/src/mongo/tools/mongobridge_options_init.cpp
index d1373ccd7a2..f27a73c6aeb 100644
--- a/src/mongo/tools/mongobridge_options_init.cpp
+++ b/src/mongo/tools/mongobridge_options_init.cpp
@@ -43,11 +43,7 @@ MONGO_STARTUP_OPTIONS_VALIDATE(MongoBridgeOptions)(InitializerContext* context)
     if (!handlePreValidationMongoBridgeOptions(moe::startupOptionsParsed)) {
         quickExit(EXIT_SUCCESS);
     }
-    Status ret = moe::startupOptionsParsed.validate();
-    if (!ret.isOK()) {
-        return ret;
-    }
-    return Status::OK();
+    uassertStatusOK(moe::startupOptionsParsed.validate());
 }
 
 MONGO_STARTUP_OPTIONS_STORE(MongoBridgeOptions)(InitializerContext* context) {
@@ -66,7 +62,5 @@ MONGO_STARTUP_OPTIONS_STORE(MongoBridgeOptions)(InitializerContext* context) {
             quickExit(EXIT_BADOPTIONS);
         }
     }
-
-    return Status::OK();
 }
 }  // namespace mongo
diff --git a/src/mongo/transport/message_compressor_registry.cpp b/src/mongo/transport/message_compressor_registry.cpp
index 90a89855048..cbb77606b92 100644
--- a/src/mongo/transport/message_compressor_registry.cpp
+++ b/src/mongo/transport/message_compressor_registry.cpp
@@ -134,13 +134,12 @@ MONGO_INITIALIZER_GENERAL(NoopMessageCompressorInit,
 (InitializerContext* context) {
     auto& compressorRegistry = MessageCompressorRegistry::get();
     compressorRegistry.registerImplementation(std::make_unique<NoopMessageCompressor>());
-    return Status::OK();
 }
 
 // This cleans up any compressors that were requested by the user, but weren't registered by
 // any compressor. It must be run after all the compressors have registered themselves with
 // the global registry.
 MONGO_INITIALIZER(AllCompressorsRegistered)(InitializerContext* context) {
-    return MessageCompressorRegistry::get().finalizeSupportedCompressors();
+    uassertStatusOK(MessageCompressorRegistry::get().finalizeSupportedCompressors());
 }
 }  // namespace mongo
diff --git a/src/mongo/transport/message_compressor_snappy.cpp b/src/mongo/transport/message_compressor_snappy.cpp
index 56384ce8854..1d926174cf5 100644
--- a/src/mongo/transport/message_compressor_snappy.cpp
+++ b/src/mongo/transport/message_compressor_snappy.cpp
@@ -82,6 +82,5 @@ MONGO_INITIALIZER_GENERAL(SnappyMessageCompressorInit,
 (InitializerContext* context) {
     auto& compressorRegistry = MessageCompressorRegistry::get();
     compressorRegistry.registerImplementation(std::make_unique<SnappyMessageCompressor>());
-    return Status::OK();
 }
 }  // namespace mongo
diff --git a/src/mongo/transport/message_compressor_zlib.cpp b/src/mongo/transport/message_compressor_zlib.cpp
index 599a2f5e40f..878431b2824 100644
--- a/src/mongo/transport/message_compressor_zlib.cpp
+++ b/src/mongo/transport/message_compressor_zlib.cpp
@@ -84,6 +84,5 @@ MONGO_INITIALIZER_GENERAL(ZlibMessageCompressorInit,
 (InitializerContext* context) {
     auto& compressorRegistry = MessageCompressorRegistry::get();
     compressorRegistry.registerImplementation(std::make_unique<ZlibMessageCompressor>());
-    return Status::OK();
 }
 }  // namespace mongo
diff --git a/src/mongo/transport/message_compressor_zstd.cpp b/src/mongo/transport/message_compressor_zstd.cpp
index 79ce2a5b0f1..22721c6e16c 100644
--- a/src/mongo/transport/message_compressor_zstd.cpp
+++ b/src/mongo/transport/message_compressor_zstd.cpp
@@ -82,6 +82,5 @@ MONGO_INITIALIZER_GENERAL(ZstdMessageCompressorInit,
 (InitializerContext* context) {
     auto& compressorRegistry = MessageCompressorRegistry::get();
     compressorRegistry.registerImplementation(std::make_unique<ZstdMessageCompressor>());
-    return Status::OK();
 }
 }  // namespace mongo
diff --git a/src/mongo/unittest/integration_test_main.cpp b/src/mongo/unittest/integration_test_main.cpp
index 6fb5a68fb5e..43173c361b9 100644
--- a/src/mongo/unittest/integration_test_main.cpp
+++ b/src/mongo/unittest/integration_test_main.cpp
@@ -63,7 +63,6 @@ ConnectionString fixtureConnectionString{};
 
 MONGO_INITIALIZER(WireSpec)(InitializerContext*) {
     WireSpec::instance().initialize(WireSpec::Specification{});
-    return Status::OK();
 }
 
 }  // namespace
@@ -95,60 +94,40 @@ MONGO_INITIALIZER_GENERAL(ForkServer, ("EndStartupOptionHandling"), ("default"))
 (InitializerContext* context) {
     // Integration tests do not fork, however the init graph requires a deliberate initializer that
     // _could_ fork and here choses not to do so.
-    return Status::OK();
 }
 
 MONGO_GENERAL_STARTUP_OPTIONS_REGISTER(IntegrationTestOptions)(InitializerContext*) {
     uassertStatusOK(addBaseServerOptions(&moe::startupOptions));
-
-    return Status::OK();
 }
 
 MONGO_STARTUP_OPTIONS_VALIDATE(IntegrationTestOptions)(InitializerContext*) {
     auto& env = moe::startupOptionsParsed;
     auto& opts = moe::startupOptions;
 
-    if (auto ret = env.validate(); !ret.isOK()) {
-        return ret;
-    }
-
-    if (auto ret = validateBaseOptions(env); !ret.isOK()) {
-        return ret;
-    }
+    uassertStatusOK(env.validate());
+    uassertStatusOK(validateBaseOptions(env));
 
     if (env.count("help")) {
         std::cout << opts.helpString() << std::endl;
         quickExit(EXIT_SUCCESS);
     }
-
-    return Status::OK();
 }
 
 MONGO_STARTUP_OPTIONS_STORE(IntegrationTestOptions)(InitializerContext*) {
     auto& env = moe::startupOptionsParsed;
 
-    if (auto ret = canonicalizeBaseOptions(&env); !ret.isOK()) {
-        return ret;
-    }
-
-    if (auto ret = storeBaseOptions(env); !ret.isOK()) {
-        return ret;
-    }
+    uassertStatusOK(canonicalizeBaseOptions(&env));
+    uassertStatusOK(storeBaseOptions(env));
 
     std::string connectionString = env["connectionString"].as<std::string>();
 
     auto swConnectionString = ConnectionString::parse(connectionString);
-    if (!swConnectionString.isOK()) {
-        return swConnectionString.getStatus();
-    }
+    uassertStatusOK(swConnectionString);
 
     fixtureConnectionString = std::move(swConnectionString.getValue());
     LOGV2(23050,
           "Using test fixture with connection string = {connectionString}",
           "connectionString"_attr = connectionString);
-
-
-    return Status::OK();
 }
 
 }  // namespace
diff --git a/src/mongo/unittest/temp_dir.cpp b/src/mongo/unittest/temp_dir.cpp
index ab8ec61f548..88b274883f9 100644
--- a/src/mongo/unittest/temp_dir.cpp
+++ b/src/mongo/unittest/temp_dir.cpp
@@ -61,17 +61,16 @@ MONGO_INITIALIZER(SetTempDirDefaultRoot)(InitializerContext* context) {
     }
 
     if (!boost::filesystem::exists(defaultRoot)) {
-        return Status(ErrorCodes::BadValue,
-                      str::stream() << "Attempted to use a tempPath (" << defaultRoot.string()
-                                    << ") that doesn't exist");
+        uasserted(ErrorCodes::BadValue,
+                  str::stream() << "Attempted to use a tempPath (" << defaultRoot.string()
+                                << ") that doesn't exist");
     }
 
     if (!boost::filesystem::is_directory(defaultRoot)) {
-        return Status(ErrorCodes::BadValue,
-                      str::stream() << "Attempted to use a tempPath (" << defaultRoot.string()
-                                    << ") that exists, but isn't a directory");
+        uasserted(ErrorCodes::BadValue,
+                  str::stream() << "Attempted to use a tempPath (" << defaultRoot.string()
+                                << ") that exists, but isn't a directory");
     }
-    return Status::OK();
 }
 }  // namespace
 
diff --git a/src/mongo/unittest/unittest_main.cpp b/src/mongo/unittest/unittest_main.cpp
index 1056198a04f..f64d8d4d688 100644
--- a/src/mongo/unittest/unittest_main.cpp
+++ b/src/mongo/unittest/unittest_main.cpp
@@ -56,7 +56,6 @@ namespace {
 
 MONGO_INITIALIZER(WireSpec)(InitializerContext*) {
     WireSpec::instance().initialize(WireSpec::Specification{});
-    return Status::OK();
 }
 
 }  // namespace
diff --git a/src/mongo/util/cmdline_utils/censor_cmdline.cpp b/src/mongo/util/cmdline_utils/censor_cmdline.cpp
index 526414b21e9..fa1d93d7087 100644
--- a/src/mongo/util/cmdline_utils/censor_cmdline.cpp
+++ b/src/mongo/util/cmdline_utils/censor_cmdline.cpp
@@ -77,10 +77,7 @@ MONGO_INITIALIZER_GENERAL(GatherReadctionOptions,
     };
 
     std::vector<optionenvironment::OptionDescription> options;
-    auto status = optionenvironment::startupOptions.getAllOptions(&options);
-    if (!status.isOK()) {
-        return status;
-    }
+    uassertStatusOK(optionenvironment::startupOptions.getAllOptions(&options));
 
     for (const auto& opt : options) {
         if (!opt._redact) {
@@ -91,21 +88,14 @@ MONGO_INITIALIZER_GENERAL(GatherReadctionOptions,
         gRedactedDottedNames.insert(opt._deprecatedDottedNames.begin(),
                                     opt._deprecatedDottedNames.end());
         if (!opt._singleName.empty()) {
-            auto status = insertSingleName(opt._singleName);
-            if (!status.isOK()) {
-                return status;
-            }
+            uassertStatusOK(insertSingleName(opt._singleName));
         }
         for (const auto& name : opt._deprecatedSingleNames) {
-            auto status = insertSingleName(name);
-            if (!status.isOK()) {
-                return status;
-            }
+            uassertStatusOK(insertSingleName(name));
         }
     }
 
     gGatherOptionsDone = true;
-    return Status::OK();
 }
 
 bool _isPasswordArgument(const std::string& name) {
diff --git a/src/mongo/util/concurrency/thread_pool_test.cpp b/src/mongo/util/concurrency/thread_pool_test.cpp
index 0b456c6abc1..c5eb7771eb5 100644
--- a/src/mongo/util/concurrency/thread_pool_test.cpp
+++ b/src/mongo/util/concurrency/thread_pool_test.cpp
@@ -55,7 +55,6 @@ using namespace fmt::literals;
 MONGO_INITIALIZER(ThreadPoolCommonTests)(InitializerContext*) {
     addTestsForThreadPool("ThreadPoolCommon",
                           []() { return std::make_unique<ThreadPool>(ThreadPool::Options()); });
-    return Status::OK();
 }
 
 class ThreadPoolTest : public unittest::Test {
diff --git a/src/mongo/util/diagnostic_info.cpp b/src/mongo/util/diagnostic_info.cpp
index 49076e76c91..bb65abd4a4a 100644
--- a/src/mongo/util/diagnostic_info.cpp
+++ b/src/mongo/util/diagnostic_info.cpp
@@ -216,8 +216,6 @@ MONGO_INITIALIZER_GENERAL(DiagnosticInfo, (/* NO PREREQS */), ("FinalizeDiagnost
     };
 
     latch_detail::installDiagnosticListener<DiagnosticListener>();
-
-    return Status::OK();
 }
 
 MONGO_INITIALIZER(InterruptibleWaitListener)(InitializerContext* context) {
@@ -258,8 +256,6 @@ MONGO_INITIALIZER(InterruptibleWaitListener)(InitializerContext* context) {
     };
 
     Interruptible::installWaitListener<WaitListener>();
-
-    return Status::OK();
 }
 
 }  // namespace
diff --git a/src/mongo/util/fail_point.cpp b/src/mongo/util/fail_point.cpp
index 34a5cb7454e..745983c107e 100644
--- a/src/mongo/util/fail_point.cpp
+++ b/src/mongo/util/fail_point.cpp
@@ -58,7 +58,6 @@ MONGO_FAIL_POINT_DEFINE(dummy);  // used by tests in jstests/fail_point
 MONGO_INITIALIZER_GENERAL(AllFailPointsRegistered, (), ())
 (InitializerContext* context) {
     globalFailPointRegistry().freeze();
-    return Status::OK();
 }
 
 /** The per-thread PRNG used by fail-points. */
diff --git a/src/mongo/util/generate_icu_init_cpp.py b/src/mongo/util/generate_icu_init_cpp.py
index 2d339660c78..f606a2ee800 100755
--- a/src/mongo/util/generate_icu_init_cpp.py
+++ b/src/mongo/util/generate_icu_init_cpp.py
@@ -103,12 +103,11 @@ alignas(16) const uint8_t kRawData[] = {%(decimal_encoded_data)s};
 
 }  // namespace
 
-MONGO_INITIALIZER_GENERAL(LoadICUData, MONGO_NO_PREREQUISITES, ("BeginStartupOptionHandling"))(
+MONGO_INITIALIZER_GENERAL(LoadICUData, (), ("BeginStartupOptionHandling"))(
         InitializerContext* context) {
     UErrorCode status = U_ZERO_ERROR;
     udata_setCommonData(kRawData, &status);
     fassert(40088, U_SUCCESS(status));
-    return Status::OK();
 }
 
 }  // namespace mongo
diff --git a/src/mongo/util/heap_profiler.cpp b/src/mongo/util/heap_profiler.cpp
index 9d0e91ae536..7c39be5e84d 100644
--- a/src/mongo/util/heap_profiler.cpp
+++ b/src/mongo/util/heap_profiler.cpp
@@ -713,7 +713,6 @@ MONGO_INITIALIZER_GENERAL(StartHeapProfiling, ("EndStartupOptionHandling"), ("de
 (InitializerContext* context) {
     if (HeapProfilingEnabled)
         HeapProfiler::heapProfiler = new HeapProfiler();
-    return Status::OK();
 }
 
 }  // namespace
diff --git a/src/mongo/util/icu_init_stub.cpp b/src/mongo/util/icu_init_stub.cpp
index 29838c88b63..70c641fdcc3 100644
--- a/src/mongo/util/icu_init_stub.cpp
+++ b/src/mongo/util/icu_init_stub.cpp
@@ -36,9 +36,7 @@ namespace {
 
 // This initializer provides a no-op definition of the LoadICUData MONGO_INITIALIZER, for use when
 // the system version of ICU is used instead of the vendored version.
-MONGO_INITIALIZER(LoadICUData)(InitializerContext* context) {
-    return Status::OK();
-}
+MONGO_INITIALIZER(LoadICUData)(InitializerContext* context) {}
 
 }  // namespace
 }  // namespace mongo
diff --git a/src/mongo/util/latch_analyzer.cpp b/src/mongo/util/latch_analyzer.cpp
index 266f610d83d..a77c21d847e 100644
--- a/src/mongo/util/latch_analyzer.cpp
+++ b/src/mongo/util/latch_analyzer.cpp
@@ -95,8 +95,6 @@ public:
 MONGO_INITIALIZER_GENERAL(LatchAnalysis, (/* NO PREREQS */), ("FinalizeDiagnosticListeners"))
 (InitializerContext* context) {
     latch_detail::installDiagnosticListener<DiagnosticListener>();
-
-    return Status::OK();
 }
 
 // Create a FailPoint to analyze latches more seriously for diagnostic purposes. This can be used
diff --git a/src/mongo/util/net/openssl_init.cpp b/src/mongo/util/net/openssl_init.cpp
index c4980bb0042..0f2c439e5f9 100644
--- a/src/mongo/util/net/openssl_init.cpp
+++ b/src/mongo/util/net/openssl_init.cpp
@@ -177,8 +177,6 @@ MONGO_INITIALIZER(SetupOpenSSL)(InitializerContext*) {
 
     // Setup OpenSSL multithreading callbacks and mutexes
     SSLThreadInfo::init();
-
-    return Status::OK();
 }
 
 }  // namespace
diff --git a/src/mongo/util/net/ssl/detail/impl/schannel.ipp b/src/mongo/util/net/ssl/detail/impl/schannel.ipp
index 99ccf211c2f..b46cffd0cd7 100644
--- a/src/mongo/util/net/ssl/detail/impl/schannel.ipp
+++ b/src/mongo/util/net/ssl/detail/impl/schannel.ipp
@@ -817,8 +817,6 @@ MONGO_INITIALIZER(InitializeSchannelGetServerIdentityFn)(mongo::InitializerConte
 
     SSLHandshakeManager::setSslGetServerIdentityFn(
         sc->getFunctionAs<SslGetServerIdentityFn>("SslGetServerIdentity").getValue());
-
-    return mongo::Status::OK();
 }
 
 }  // namespace detail
diff --git a/src/mongo/util/net/ssl_manager.cpp b/src/mongo/util/net/ssl_manager.cpp
index 87772d303c8..39228cdfb8c 100644
--- a/src/mongo/util/net/ssl_manager.cpp
+++ b/src/mongo/util/net/ssl_manager.cpp
@@ -633,8 +633,6 @@ MONGO_INITIALIZER_WITH_PREREQUISITES(SSLManagerLogger, ("SSLManager"))
                         "expiration"_attr = config.serverCertificateExpirationDate);
         }
     }
-
-    return Status::OK();
 }
 
 Status SSLX509Name::normalizeStrings() {
diff --git a/src/mongo/util/net/ssl_manager_apple.cpp b/src/mongo/util/net/ssl_manager_apple.cpp
index 6a20c9bbeda..c4547bf28d5 100644
--- a/src/mongo/util/net/ssl_manager_apple.cpp
+++ b/src/mongo/util/net/ssl_manager_apple.cpp
@@ -38,7 +38,6 @@
 
 #include "mongo/base/checked_cast.h"
 #include "mongo/base/init.h"
-#include "mongo/base/initializer_context.h"
 #include "mongo/base/status.h"
 #include "mongo/base/status_with.h"
 #include "mongo/crypto/sha1_block.h"
@@ -1836,7 +1835,6 @@ MONGO_INITIALIZER_WITH_PREREQUISITES(SSLManager, ("EndStartupOptionHandling"))
     if (!isSSLServer || (sslGlobalParams.sslMode.load() != SSLParams::SSLMode_disabled)) {
         theSSLManagerCoordinator = new SSLManagerCoordinator();
     }
-    return Status::OK();
 }
 
 }  // namespace mongo
diff --git a/src/mongo/util/net/ssl_manager_none.cpp b/src/mongo/util/net/ssl_manager_none.cpp
index 696ff2f95a5..178975b2654 100644
--- a/src/mongo/util/net/ssl_manager_none.cpp
+++ b/src/mongo/util/net/ssl_manager_none.cpp
@@ -33,10 +33,8 @@
 
 namespace mongo {
 namespace {
-MONGO_INITIALIZER(SSLManager)(InitializerContext*) {
-    // we need a no-op initializer so that we can depend on SSLManager as a prerequisite in
-    // non-SSL builds.
-    return Status::OK();
-}
+// we need a no-op initializer so that we can depend on SSLManager as a prerequisite in
+// non-SSL builds.
+MONGO_INITIALIZER(SSLManager)(InitializerContext*) {}
 }  // namespace
 }  // namespace mongo
diff --git a/src/mongo/util/net/ssl_manager_openssl.cpp b/src/mongo/util/net/ssl_manager_openssl.cpp
index cbd75b964f2..1cba80be3a4 100644
--- a/src/mongo/util/net/ssl_manager_openssl.cpp
+++ b/src/mongo/util/net/ssl_manager_openssl.cpp
@@ -1430,7 +1430,6 @@ MONGO_INITIALIZER_WITH_PREREQUISITES(SSLManager, ("SetupOpenSSL", "EndStartupOpt
     if (!isSSLServer || (sslGlobalParams.sslMode.load() != SSLParams::SSLMode_disabled)) {
         theSSLManagerCoordinator = new SSLManagerCoordinator();
     }
-    return Status::OK();
 }
 
 std::shared_ptr<SSLManagerInterface> SSLManagerInterface::create(const SSLParams& params,
diff --git a/src/mongo/util/net/ssl_manager_windows.cpp b/src/mongo/util/net/ssl_manager_windows.cpp
index 8d434e52416..c8cf3f1339d 100644
--- a/src/mongo/util/net/ssl_manager_windows.cpp
+++ b/src/mongo/util/net/ssl_manager_windows.cpp
@@ -43,7 +43,6 @@
 #include <winhttp.h>
 
 #include "mongo/base/init.h"
-#include "mongo/base/initializer_context.h"
 #include "mongo/bson/bsonobjbuilder.h"
 #include "mongo/bson/util/builder.h"
 #include "mongo/config.h"
diff --git a/src/mongo/util/net/ssl_options_client.cpp b/src/mongo/util/net/ssl_options_client.cpp
index fb40ebb2bc7..6422a37d9e3 100644
--- a/src/mongo/util/net/ssl_options_client.cpp
+++ b/src/mongo/util/net/ssl_options_client.cpp
@@ -51,11 +51,8 @@ MONGO_STARTUP_OPTIONS_STORE(SSLClientOptions)(InitializerContext*) {
     }
 
     if (params.count("tls.disabledProtocols")) {
-        const auto status =
-            storeSSLDisabledProtocols(params["tls.disabledProtocols"].as<std::string>());
-        if (!status.isOK()) {
-            return status;
-        }
+        uassertStatusOK(
+            storeSSLDisabledProtocols(params["tls.disabledProtocols"].as<std::string>()));
 #if ((MONGO_CONFIG_SSL_PROVIDER != MONGO_CONFIG_SSL_PROVIDER_OPENSSL) || \
      (OPENSSL_VERSION_NUMBER >= 0x100000cf)) /* 1.0.0l */
     } else {
@@ -72,17 +69,12 @@ MONGO_STARTUP_OPTIONS_STORE(SSLClientOptions)(InitializerContext*) {
 
 #ifdef MONGO_CONFIG_SSL_CERTIFICATE_SELECTORS
     if (params.count("tls.certificateSelector")) {
-        const auto status =
+        uassertStatusOK(
             parseCertificateSelector(&sslGlobalParams.sslCertificateSelector,
                                      "tls.certificateSelector",
-                                     params["tls.certificateSelector"].as<std::string>());
-        if (!status.isOK()) {
-            return status;
-        }
+                                     params["tls.certificateSelector"].as<std::string>()));
     }
 #endif
-
-    return Status::OK();
 }
 
 }  // namespace
diff --git a/src/mongo/util/net/ssl_options_server.cpp b/src/mongo/util/net/ssl_options_server.cpp
index 1e21f2d7b22..0b0f0b4e955 100644
--- a/src/mongo/util/net/ssl_options_server.cpp
+++ b/src/mongo/util/net/ssl_options_server.cpp
@@ -95,7 +95,7 @@ MONGO_STARTUP_OPTIONS_POST(SSLServerOptions)(InitializerContext*) {
         if (swMode.isOK()) {
             sslGlobalParams.sslMode.store(swMode.getValue());
         } else {
-            return {ErrorCodes::BadValue, "unsupported value for tlsMode " + sslModeParam};
+            uasserted(ErrorCodes::BadValue, "unsupported value for tlsMode " + sslModeParam);
         }
     } else if (params.count("net.ssl.mode")) {
         std::string sslModeParam = params["net.ssl.mode"].as<string>();
@@ -103,7 +103,7 @@ MONGO_STARTUP_OPTIONS_POST(SSLServerOptions)(InitializerContext*) {
         if (swMode.isOK()) {
             sslGlobalParams.sslMode.store(swMode.getValue());
         } else {
-            return {ErrorCodes::BadValue, "unsupported value for sslMode " + sslModeParam};
+            uasserted(ErrorCodes::BadValue, "unsupported value for sslMode " + sslModeParam);
         }
     }
 
@@ -142,9 +142,9 @@ MONGO_STARTUP_OPTIONS_POST(SSLServerOptions)(InitializerContext*) {
             23286,
             "net.tls.tlsCipherConfig is deprecated. It will be removed in a future release.");
         if (sslGlobalParams.sslCipherConfig != kSSLCipherConfigDefault) {
-            return {ErrorCodes::BadValue,
-                    "net.tls.tlsCipherConfig is incompatible with the openTLSCipherConfig "
-                    "setParameter"};
+            uasserted(ErrorCodes::BadValue,
+                      "net.tls.tlsCipherConfig is incompatible with the openTLSCipherConfig "
+                      "setParameter");
         }
         sslGlobalParams.sslCipherConfig = params["net.tls.tlsCipherConfig"].as<string>();
     }
@@ -153,9 +153,7 @@ MONGO_STARTUP_OPTIONS_POST(SSLServerOptions)(InitializerContext*) {
         const auto status =
             storeSSLDisabledProtocols(params["net.tls.disabledProtocols"].as<string>(),
                                       SSLDisabledProtocolsMode::kAcceptNegativePrefix);
-        if (!status.isOK()) {
-            return status;
-        }
+        uassertStatusOK(status);
 #if (MONGO_CONFIG_SSL_PROVIDER != MONGO_CONFIG_SSL_PROVIDER_OPENSSL) || \
     (OPENSSL_VERSION_NUMBER >= 0x100000cf) /* 1.0.0l */
     } else {
@@ -170,10 +168,7 @@ MONGO_STARTUP_OPTIONS_POST(SSLServerOptions)(InitializerContext*) {
     }
 
     if (params.count("net.tls.logVersions")) {
-        const auto status = storeTLSLogVersion(params["net.tls.logVersions"].as<string>());
-        if (!status.isOK()) {
-            return status;
-        }
+        uassertStatusOK(storeTLSLogVersion(params["net.tls.logVersions"].as<string>()));
     }
 
 #ifdef MONGO_CONFIG_SSL_CERTIFICATE_SELECTORS
@@ -182,9 +177,7 @@ MONGO_STARTUP_OPTIONS_POST(SSLServerOptions)(InitializerContext*) {
             parseCertificateSelector(&sslGlobalParams.sslCertificateSelector,
                                      "net.tls.certificateSelector",
                                      params["net.tls.certificateSelector"].as<std::string>());
-        if (!status.isOK()) {
-            return status;
-        }
+        uassertStatusOK(status);
     }
 
     if (params.count("net.tls.clusterCertificateSelector")) {
@@ -192,9 +185,7 @@ MONGO_STARTUP_OPTIONS_POST(SSLServerOptions)(InitializerContext*) {
             &sslGlobalParams.sslClusterCertificateSelector,
             "net.tls.clusterCertificateSelector",
             params["net.tls.clusterCertificateSelector"].as<std::string>());
-        if (!status.isOK()) {
-            return status;
-        }
+        uassertStatusOK(status);
     }
 #endif
 
@@ -202,11 +193,11 @@ MONGO_STARTUP_OPTIONS_POST(SSLServerOptions)(InitializerContext*) {
     if (sslGlobalParams.sslMode.load() != SSLParams::SSLMode_disabled) {
         bool usingCertifiateSelectors = params.count("net.tls.certificateSelector");
         if (sslGlobalParams.sslPEMKeyFile.size() == 0 && !usingCertifiateSelectors) {
-            return {ErrorCodes::BadValue,
-                    "need tlsCertificateKeyFile or certificateSelector when TLS is enabled"};
+            uasserted(ErrorCodes::BadValue,
+                      "need tlsCertificateKeyFile or certificateSelector when TLS is enabled");
         }
         if (!sslGlobalParams.sslCRLFile.empty() && sslGlobalParams.sslCAFile.empty()) {
-            return {ErrorCodes::BadValue, "need tlsCAFile with tlsCRLFile"};
+            uasserted(ErrorCodes::BadValue, "need tlsCAFile with tlsCRLFile");
         }
 
         std::string sslCANotFoundError(
@@ -218,7 +209,7 @@ MONGO_STARTUP_OPTIONS_POST(SSLServerOptions)(InitializerContext*) {
         // X.509 certificates for auth instead of relying on a CA file.
         if (sslGlobalParams.sslCAFile.empty() && !usingCertifiateSelectors &&
             clusterAuthMode == ServerGlobalParams::ClusterAuthMode_x509) {
-            return {ErrorCodes::BadValue, sslCANotFoundError};
+            uasserted(ErrorCodes::BadValue, sslCANotFoundError);
         }
     } else if (sslGlobalParams.sslPEMKeyFile.size() || sslGlobalParams.sslPEMKeyPassword.size() ||
                sslGlobalParams.sslClusterFile.size() || sslGlobalParams.sslClusterPassword.size() ||
@@ -230,16 +221,16 @@ MONGO_STARTUP_OPTIONS_POST(SSLServerOptions)(InitializerContext*) {
                params.count("net.tls.clusterCertificateSelector") ||
 #endif
                sslGlobalParams.sslWeakCertificateValidation) {
-        return {ErrorCodes::BadValue,
-                "need to enable TLS via the sslMode/tlsMode flag when "
-                "using TLS configuration parameters"};
+        uasserted(ErrorCodes::BadValue,
+                  "need to enable TLS via the sslMode/tlsMode flag when "
+                  "using TLS configuration parameters");
     }
 
     if (clusterAuthMode == ServerGlobalParams::ClusterAuthMode_sendKeyFile ||
         clusterAuthMode == ServerGlobalParams::ClusterAuthMode_sendX509 ||
         clusterAuthMode == ServerGlobalParams::ClusterAuthMode_x509) {
         if (sslGlobalParams.sslMode.load() == SSLParams::SSLMode_disabled) {
-            return {ErrorCodes::BadValue, "need to enable TLS via the tlsMode flag"};
+            uasserted(ErrorCodes::BadValue, "need to enable TLS via the tlsMode flag");
         }
     }
 
@@ -248,12 +239,10 @@ MONGO_STARTUP_OPTIONS_POST(SSLServerOptions)(InitializerContext*) {
         if (clusterAuthMode == ServerGlobalParams::ClusterAuthMode_sendX509 ||
             (clusterAuthMode == ServerGlobalParams::ClusterAuthMode_x509 &&
              !serverGlobalParams.transitionToAuth)) {
-            return {ErrorCodes::BadValue,
-                    "cannot have x.509 cluster authentication in allowTLS mode"};
+            uasserted(ErrorCodes::BadValue,
+                      "cannot have x.509 cluster authentication in allowTLS mode");
         }
     }
-
-    return Status::OK();
 }
 
 // Alias --tlsOnNormalPorts as --tlsMode=requireTLS
@@ -295,9 +284,7 @@ Status canonicalizeSSLServerOptions(moe::Environment* params) {
 
 MONGO_STARTUP_OPTIONS_VALIDATE(SSLServerOptions)(InitializerContext*) {
     auto status = canonicalizeSSLServerOptions(&moe::startupOptionsParsed);
-    if (!status.isOK()) {
-        return status;
-    }
+    uassertStatusOK(status);
 
 #ifdef _WIN32
     const auto& params = moe::startupOptionsParsed;
@@ -306,31 +293,29 @@ MONGO_STARTUP_OPTIONS_VALIDATE(SSLServerOptions)(InitializerContext*) {
         if (params.count("net.tls.certificateKeyFile") &&
             !boost::filesystem::path(params["net.tls.certificateKeyFile"].as<string>())
                  .is_absolute()) {
-            return {ErrorCodes::BadValue,
-                    "PEMKeyFile requires an absolute file path with Windows services"};
+            uasserted(ErrorCodes::BadValue,
+                      "PEMKeyFile requires an absolute file path with Windows services");
         }
 
         if (params.count("net.tls.clusterFile") &&
             !boost::filesystem::path(params["net.tls.clusterFile"].as<string>()).is_absolute()) {
-            return {ErrorCodes::BadValue,
-                    "clusterFile requires an absolute file path with Windows services"};
+            uasserted(ErrorCodes::BadValue,
+                      "clusterFile requires an absolute file path with Windows services");
         }
 
         if (params.count("net.tls.CAFile") &&
             !boost::filesystem::path(params["net.tls.CAFile"].as<string>()).is_absolute()) {
-            return {ErrorCodes::BadValue,
-                    "CAFile requires an absolute file path with Windows services"};
+            uasserted(ErrorCodes::BadValue,
+                      "CAFile requires an absolute file path with Windows services");
         }
 
         if (params.count("net.tls.CRLFile") &&
             !boost::filesystem::path(params["net.tls.CRLFile"].as<string>()).is_absolute()) {
-            return {ErrorCodes::BadValue,
-                    "CRLFile requires an absolute file path with Windows services"};
+            uasserted(ErrorCodes::BadValue,
+                      "CRLFile requires an absolute file path with Windows services");
         }
     }
 #endif
-
-    return Status::OK();
 }
 
 // This warning must be deferred until after
@@ -343,7 +328,6 @@ MONGO_INITIALIZER_WITH_PREREQUISITES(ImplicitDisableTLS10Warning, ("ServerLogRed
               "Automatically disabling TLS 1.0, to force-enable TLS 1.0 "
               "specify --sslDisabledProtocols 'none'");
     }
-    return Status::OK();
 }
 
 }  // namespace
diff --git a/src/mongo/util/net/ssl_options_test.cpp b/src/mongo/util/net/ssl_options_test.cpp
index 76ad7f48d0b..c666d9636c2 100644
--- a/src/mongo/util/net/ssl_options_test.cpp
+++ b/src/mongo/util/net/ssl_options_test.cpp
@@ -36,7 +36,6 @@
 #include <boost/range/size.hpp>
 #include <ostream>
 
-#include "mongo/base/global_initializer.h"
 #include "mongo/base/init.h"
 #include "mongo/base/initializer.h"
 #include "mongo/db/server_options_base.h"
@@ -54,27 +53,18 @@ namespace moe = mongo::optionenvironment;
 namespace mongo {
 namespace {
 
-MONGO_INITIALIZER(ServerLogRedirection)(InitializerContext*) {
-    // ssl_options_server.cpp has an initializer which depends on logging.
-    // We can stub that dependency out for unit testing purposes.
-    return Status::OK();
-}
+// ssl_options_server.cpp has an initializer which depends on logging.
+// We can stub that dependency out for unit testing purposes.
+MONGO_INITIALIZER(ServerLogRedirection)(InitializerContext*) {}
 
 Status executeInitializer(const std::string& name) try {
-    const auto* node =
-        getGlobalInitializer().getInitializerDependencyGraph().getInitializerNode(name);
-    if (!node) {
-        return {ErrorCodes::BadValue, str::stream() << "Unknown initializer: '" << name << "'"};
-    }
-
-    const auto& fn = node->getInitializerFunction();
-    if (!fn) {
-        return {ErrorCodes::InternalError,
-                str::stream() << "Initializer node '" << name << "' has no associated function."};
-    }
-
-    // The initializers we call don't actually need a context currently.
-    return fn(nullptr);
+    InitializerFunction fn = getGlobalInitializer().getInitializerFunctionForTesting(name);
+    uassert(ErrorCodes::InternalError,
+            str::stream() << "Initializer node '" << name << "' has no associated function.",
+            fn);
+    InitializerContext initContext({});
+    fn(&initContext);
+    return Status::OK();
 } catch (const DBException& ex) {
     return ex.toStatus();
 }
diff --git a/src/mongo/util/options_parser/options_parser.cpp b/src/mongo/util/options_parser/options_parser.cpp
index 5a0e5ab8fdb..a01d229514c 100644
--- a/src/mongo/util/options_parser/options_parser.cpp
+++ b/src/mongo/util/options_parser/options_parser.cpp
@@ -85,12 +85,9 @@ bool shouldUseStrict() {
     return true;
 }
 
-MONGO_INITIALIZER_GENERAL(OptionsParseUseStrict,
-                          MONGO_NO_PREREQUISITES,
-                          ("BeginStartupOptionParsing"))
+MONGO_INITIALIZER_GENERAL(OptionsParseUseStrict, (), ("BeginStartupOptionParsing"))
 (InitializerContext* context) {
     OptionsParser::useStrict = shouldUseStrict;
-    return Status::OK();
 }
 
 // The following section contains utility functions that convert between the various objects
diff --git a/src/mongo/util/options_parser/options_parser_init.cpp b/src/mongo/util/options_parser/options_parser_init.cpp
index 304a6d1d152..73272cb8ab5 100644
--- a/src/mongo/util/options_parser/options_parser_init.cpp
+++ b/src/mongo/util/options_parser/options_parser_init.cpp
@@ -51,8 +51,6 @@ MONGO_STARTUP_OPTIONS_PARSE(StartupOptions)(InitializerContext* context) {
         std::cerr << "try '" << context->args()[0] << " --help' for more information" << std::endl;
         quickExit(EXIT_BADOPTIONS);
     }
-
-    return Status::OK();
 }
 
 MONGO_INITIALIZER_GENERAL(OutputConfig,
@@ -61,16 +59,12 @@ MONGO_INITIALIZER_GENERAL(OutputConfig,
 (InitializerContext*) {
     if (startupOptionsParsed.count("outputConfig")) {
         bool output = false;
-        auto status = startupOptionsParsed.get(Key("outputConfig"), &output);
-        if (!status.isOK()) {
-            return status;
-        }
+        uassertStatusOK(startupOptionsParsed.get(Key("outputConfig"), &output));
         if (output) {
             std::cout << startupOptionsParsed.toYAML() << std::endl;
             quickExit(EXIT_CLEAN);
         }
     }
-    return Status::OK();
 }
 
 }  // namespace
diff --git a/src/mongo/util/options_parser/startup_option_init.cpp b/src/mongo/util/options_parser/startup_option_init.cpp
index efc1ed82567..6ac10f6098c 100644
--- a/src/mongo/util/options_parser/startup_option_init.cpp
+++ b/src/mongo/util/options_parser/startup_option_init.cpp
@@ -44,12 +44,8 @@ namespace {
 std::string makeInitializer(const std::string& name,
                             const std::vector<std::string>& after,
                             const std::vector<std::string>& before) {
-    uassertStatusOK(getGlobalInitializer().getInitializerDependencyGraph().addInitializer(
-        name,
-        [](InitializerContext*) { return Status::OK(); },
-        [](DeinitializerContext*) { return Status::OK(); },
-        after,
-        before));
+    getGlobalInitializer().addInitializer(
+        name, [](InitializerContext*) {}, [](DeinitializerContext*) {}, after, before);
     return name;
 }
 
diff --git a/src/mongo/util/perfctr_collect.cpp b/src/mongo/util/perfctr_collect.cpp
index 8ee4067b146..6e9ae1dc0f2 100644
--- a/src/mongo/util/perfctr_collect.cpp
+++ b/src/mongo/util/perfctr_collect.cpp
@@ -55,12 +55,10 @@ MONGO_INITIALIZER(PdhInit)(InitializerContext* context) {
     hPdhLibrary = LoadLibraryW(L"pdh.dll");
     if (nullptr == hPdhLibrary) {
         DWORD gle = GetLastError();
-        return {ErrorCodes::WindowsPdhError,
-                str::stream() << "LoadLibrary of pdh.dll failed with "
-                              << errnoWithDescription(gle)};
+        uasserted(ErrorCodes::WindowsPdhError,
+                  str::stream() << "LoadLibrary of pdh.dll failed with "
+                                << errnoWithDescription(gle));
     }
-
-    return Status::OK();
 }
 
 /**
diff --git a/src/mongo/util/platform_init.cpp b/src/mongo/util/platform_init.cpp
index ac75975440f..28cfd6cb9f9 100644
--- a/src/mongo/util/platform_init.cpp
+++ b/src/mongo/util/platform_init.cpp
@@ -113,8 +113,6 @@ MONGO_INITIALIZER(Behaviors_Win32)(InitializerContext*) {
             std::min(std::max(int(tc.wPeriodMin), targetResolution), int(tc.wPeriodMax));
         invariant(timeBeginPeriod(timerResolution) == TIMERR_NOERROR);
     }
-
-    return Status::OK();
 }
 
 }  // namespace mongo
diff --git a/src/mongo/util/processinfo.cpp b/src/mongo/util/processinfo.cpp
index 558415a1705..197ebe00848 100644
--- a/src/mongo/util/processinfo.cpp
+++ b/src/mongo/util/processinfo.cpp
@@ -46,7 +46,6 @@ namespace mongo {
 namespace {
 MONGO_INITIALIZER(initApplicationInfo)(InitializerContext* context) {
     ProcessInfo().appInfo().init(context->args());
-    return Status::OK();
 }
 }  // namespace
 
diff --git a/src/mongo/util/stacktrace_somap.cpp b/src/mongo/util/stacktrace_somap.cpp
index 767bd42a521..947114affae 100644
--- a/src/mongo/util/stacktrace_somap.cpp
+++ b/src/mongo/util/stacktrace_somap.cpp
@@ -349,7 +349,6 @@ SharedObjectMapInfo& mutableGlobalSharedObjectMapInfo() {
 MONGO_INITIALIZER(ExtractSOMap)(InitializerContext*) {
     // Call buildObj() again now that there is better VersionInfo.
     mutableGlobalSharedObjectMapInfo().setObj(buildObj());
-    return Status::OK();
 }
 
 const bool dummyToForceEarlyInitializationOfSharedObjectMapInfo = [] {
diff --git a/src/mongo/util/stacktrace_windows.cpp b/src/mongo/util/stacktrace_windows.cpp
index c95911d112c..99ceea9e937 100644
--- a/src/mongo/util/stacktrace_windows.cpp
+++ b/src/mongo/util/stacktrace_windows.cpp
@@ -142,9 +142,6 @@ MONGO_INITIALIZER(IntializeSymbolHandler)(::mongo::InitializerContext* ctx) {
     // context. The constructor of SymbolHandler does all the error handling, so we don't need to
     // do anything with the return value. Just make sure it gets called.
     SymbolHandler::instance();
-
-    // Initializing the symbol handler is not a fatal error, so we always return Status::OK() here.
-    return Status::OK();
 }
 
 /**
diff --git a/src/mongo/util/system_tick_source.cpp b/src/mongo/util/system_tick_source.cpp
index 12defed767c..a11de88fd16 100644
--- a/src/mongo/util/system_tick_source.cpp
+++ b/src/mongo/util/system_tick_source.cpp
@@ -142,7 +142,6 @@ void initTickSource() {}
 MONGO_INITIALIZER(SystemTickSourceInit)(InitializerContext* context) {
     initTickSource();
     SystemTickSource::get();
-    return Status::OK();
 }
 
 TickSource::Tick SystemTickSource::getTicks() {
diff --git a/src/mongo/util/tcmalloc_set_parameter.cpp b/src/mongo/util/tcmalloc_set_parameter.cpp
index 898d9af9abd..d8ab1f3939f 100644
--- a/src/mongo/util/tcmalloc_set_parameter.cpp
+++ b/src/mongo/util/tcmalloc_set_parameter.cpp
@@ -123,14 +123,12 @@ TCMALLOC_SP_METHODS(AggressiveMemoryDecommit)
 
 namespace {
 
-MONGO_INITIALIZER_GENERAL(TcmallocConfigurationDefaults,
-                          MONGO_NO_PREREQUISITES,
-                          ("BeginStartupOptionHandling"))
+MONGO_INITIALIZER_GENERAL(TcmallocConfigurationDefaults, (), ("BeginStartupOptionHandling"))
 (InitializerContext*) {
     // Before processing the command line options, if the user has not specified a value in via
     // the environment, set tcmalloc.max_total_thread_cache_bytes to its default value.
     if (getenv("TCMALLOC_MAX_TOTAL_THREAD_CACHE_BYTES")) {
-        return Status::OK();
+        return;
     }
 
     ProcessInfo pi;
@@ -140,7 +138,7 @@ MONGO_INITIALIZER_GENERAL(TcmallocConfigurationDefaults,
         (systemMemorySizeMB / 8) * 1024 * 1024;  // 1/8 of system memory in bytes
     size_t cacheSize = std::min(defaultTcMallocCacheSize, derivedTcMallocCacheSize);
 
-    return setProperty(kMaxTotalThreadCacheBytesPropertyName, cacheSize);
+    uassertStatusOK(setProperty(kMaxTotalThreadCacheBytesPropertyName, cacheSize));
 }
 
 }  // namespace
diff --git a/src/mongo/util/testing_options.cpp b/src/mongo/util/testing_options.cpp
index dcf98b10a11..32ca0896ef7 100644
--- a/src/mongo/util/testing_options.cpp
+++ b/src/mongo/util/testing_options.cpp
@@ -58,8 +58,6 @@ MONGO_INITIALIZER_GENERAL(TestingDiagnostics,
                       "Testing behaviors are enabled. This has serious implications for both "
                       "performance and security.");
     }
-
-    return Status::OK();
 }
 
 }  // namespace
diff --git a/src/mongo/util/testing_proctor.cpp b/src/mongo/util/testing_proctor.cpp
index f9f378fb687..416d482ab62 100644
--- a/src/mongo/util/testing_proctor.cpp
+++ b/src/mongo/util/testing_proctor.cpp
@@ -73,7 +73,6 @@ MONGO_INITIALIZER(DisableTestingDiagnosticsByDefault)(InitializerContext*) {
     if (!TestingProctor::instance().isInitialized()) {
         TestingProctor::instance().setEnabled(false);
     }
-    return Status::OK();
 }
 
 }  // namespace
diff --git a/src/mongo/util/thread_context.cpp b/src/mongo/util/thread_context.cpp
index 3bcde4a9fdf..e08122a4405 100644
--- a/src/mongo/util/thread_context.cpp
+++ b/src/mongo/util/thread_context.cpp
@@ -43,7 +43,6 @@ thread_local ThreadContext::Handle ThreadContext::_handle;
 
 MONGO_INITIALIZER(ThreadContextsInitialized)(InitializerContext*) {
     ThreadContext::initializeMain();
-    return Status::OK();
 }
 
 void ThreadContext::initializeMain() {
diff --git a/src/mongo/util/time_support_test.cpp b/src/mongo/util/time_support_test.cpp
index 635e468692c..17dc35f58f3 100644
--- a/src/mongo/util/time_support_test.cpp
+++ b/src/mongo/util/time_support_test.cpp
@@ -59,10 +59,9 @@ char tzEnvString[] = "TZ=America/New_York";
 #pragma warning(disable : 4996)
 MONGO_INITIALIZER(SetTimeZoneToEasternForTest)(InitializerContext*) {
     if (-1 == putenv(tzEnvString)) {
-        return Status(ErrorCodes::BadValue, errnoWithDescription());
+        uasserted(ErrorCodes::BadValue, errnoWithDescription());
     }
     tzset();
-    return Status::OK();
 }
 #pragma warning(pop)
 
diff --git a/src/mongo/util/version_impl.cpp b/src/mongo/util/version_impl.cpp
index c729751f0b9..d28459aae90 100644
--- a/src/mongo/util/version_impl.cpp
+++ b/src/mongo/util/version_impl.cpp
@@ -99,12 +99,9 @@ public:
 
 const InterpolatedVersionInfo interpolatedVersionInfo;
 
-MONGO_INITIALIZER_GENERAL(EnableVersionInfo,
-                          MONGO_NO_PREREQUISITES,
-                          ("BeginStartupOptionRegistration"))
+MONGO_INITIALIZER_GENERAL(EnableVersionInfo, (), ("BeginStartupOptionRegistration"))
 (InitializerContext*) {
     VersionInfoInterface::enable(&interpolatedVersionInfo);
-    return Status::OK();
 }
 
 }  // namespace