SERVER-53423: Make ConnectString::connect return a status instead of setting error message

14 files changed, 128 insertions, 175 deletions

diff --git a/src/mongo/client/connection_string.h b/src/mongo/client/connection_string.h
index d505e1e5d24..f6ee47df22b 100644
--- a/src/mongo/client/connection_string.h
+++ b/src/mongo/client/connection_string.h
@@ -146,9 +146,8 @@ public:
     bool operator==(const ConnectionString& other) const;
     bool operator!=(const ConnectionString& other) const;
 
-    std::unique_ptr<DBClientBase> connect(
+    StatusWith<std::unique_ptr<DBClientBase>> connect(
         StringData applicationName,
-        std::string& errmsg,
         double socketTimeout = 0,
         const MongoURI* uri = nullptr,
         const ClientAPIVersionParameters* apiParameters = nullptr,
diff --git a/src/mongo/client/connection_string_connect.cpp b/src/mongo/client/connection_string_connect.cpp
index 28cc448639c..a4fa3eafd91 100644
--- a/src/mongo/client/connection_string_connect.cpp
+++ b/src/mongo/client/connection_string_connect.cpp
@@ -46,9 +46,8 @@ namespace mongo {
 Mutex ConnectionString::_connectHookMutex = MONGO_MAKE_LATCH();
 ConnectionString::ConnectionHook* ConnectionString::_connectHook = nullptr;
 
-std::unique_ptr<DBClientBase> ConnectionString::connect(
+StatusWith<std::unique_ptr<DBClientBase>> ConnectionString::connect(
     StringData applicationName,
-    std::string& errmsg,
     double socketTimeout,
     const MongoURI* uri,
     const ClientAPIVersionParameters* apiParameters,
@@ -60,6 +59,9 @@ std::unique_ptr<DBClientBase> ConnectionString::connect(
 
     switch (_type) {
         case ConnectionType::kStandalone: {
+            Status lastError =
+                Status(ErrorCodes::BadValue,
+                       "Invalid standalone connection string with empty server list.");
             for (const auto& server : _servers) {
                 auto c = std::make_unique<DBClientConnection>(
                     true, 0, newURI, DBClientConnection::HandshakeValidationHook(), apiParameters);
@@ -70,17 +72,17 @@ std::unique_ptr<DBClientBase> ConnectionString::connect(
                             "Creating new connection to: {hostAndPort}",
                             "Creating new connection",
                             "hostAndPort"_attr = server);
-                if (!c->connect(server,
-                                applicationName,
-                                errmsg,
-                                transientSSLParams ? boost::make_optional(*transientSSLParams)
-                                                   : boost::none)) {
+                lastError = c->connect(
+                    server,
+                    applicationName,
+                    transientSSLParams ? boost::make_optional(*transientSSLParams) : boost::none);
+                if (!lastError.isOK()) {
                     continue;
                 }
                 LOGV2_DEBUG(20110, 1, "Connected connection!");
                 return std::move(c);
             }
-            return nullptr;
+            return lastError;
         }
 
         case ConnectionType::kReplicaSet: {
@@ -90,10 +92,9 @@ std::unique_ptr<DBClientBase> ConnectionString::connect(
                                                             socketTimeout,
                                                             std::move(newURI),
                                                             apiParameters);
-            if (!set->connect()) {
-                errmsg = "connect failed to replica set ";
-                errmsg += toString();
-                return nullptr;
+            auto status = set->connect();
+            if (!status.isOK()) {
+                return status.withReason(status.reason() + ", " + toString());
             }
             return std::move(set);
         }
@@ -110,6 +111,7 @@ std::unique_ptr<DBClientBase> ConnectionString::connect(
                     _connectHook);
 
             // Double-checked lock, since this will never be active during normal operation
+            std::string errmsg;
             auto replacementConn =
                 _connectHook->connect(*this, errmsg, socketTimeout, apiParameters);
 
@@ -120,7 +122,10 @@ std::unique_ptr<DBClientBase> ConnectionString::connect(
                   "newConnString"_attr =
                       (replacementConn ? replacementConn->getServerAddress() : "(empty)"));
 
-            return replacementConn;
+            if (replacementConn) {
+                return std::move(replacementConn);
+            }
+            return Status(ErrorCodes::HostUnreachable, "Connection hook error: " + errmsg);
         }
 
         case ConnectionType::kLocal:
diff --git a/src/mongo/client/connpool.cpp b/src/mongo/client/connpool.cpp
index e3a5a925636..946c5b8741d 100644
--- a/src/mongo/client/connpool.cpp
+++ b/src/mongo/client/connpool.cpp
@@ -389,10 +389,12 @@ DBClientBase* DBConnectionPool::_finishCreate(const string& ident,
 
 DBClientBase* DBConnectionPool::get(const ConnectionString& url, double socketTimeout) {
     auto connect = [&]() {
-        string errmsg;
-        auto c = url.connect(StringData(), errmsg, socketTimeout).release();
-        uassert(13328, _name + ": connect failed " + url.toString() + " : " + errmsg, c);
-        return c;
+        auto c = url.connect(StringData(), socketTimeout);
+        uassert(13328,
+                fmt::format(
+                    "{}: connect failed {} : {}", _name, url.toString(), c.getStatus().reason()),
+                c.isOK());
+        return c.getValue().release();
     };
 
     return Detail::get(this, url.toString(), socketTimeout, connect);
@@ -402,15 +404,14 @@ DBClientBase* DBConnectionPool::get(const string& host, double socketTimeout) {
     auto connect = [&] {
         const ConnectionString cs(uassertStatusOK(ConnectionString::parse(host)));
 
-        string errmsg;
-        auto c = cs.connect(StringData(), errmsg, socketTimeout).release();
-        if (!c) {
+        auto swConn = cs.connect(StringData(), socketTimeout);
+        if (!swConn.isOK()) {
             throwSocketError(SocketErrorKind::CONNECT_ERROR,
                              host,
-                             str::stream() << _name << " error: " << errmsg);
+                             fmt::format("{} error: {}", _name, swConn.getStatus().reason()));
         }
 
-        return c;
+        return swConn.getValue().release();
     };
 
     return Detail::get(this, host, socketTimeout, connect);
@@ -420,7 +421,7 @@ DBClientBase* DBConnectionPool::get(const MongoURI& uri, double socketTimeout) {
     auto connect = [&] {
         string errmsg;
         std::unique_ptr<DBClientBase> c(uri.connect(uri.getAppName().get(), errmsg, socketTimeout));
-        uassert(40356, _name + ": connect failed " + uri.toString() + " : " + errmsg, c);
+        uassert(40356, fmt::format("{}: connect failed {} : {}", _name, uri.toString(), errmsg), c);
         return c.release();
     };
 
diff --git a/src/mongo/client/dbclient_connection_integration_test.cpp b/src/mongo/client/dbclient_connection_integration_test.cpp
index 0635047dd33..a8a84643a0d 100644
--- a/src/mongo/client/dbclient_connection_integration_test.cpp
+++ b/src/mongo/client/dbclient_connection_integration_test.cpp
@@ -45,15 +45,11 @@ constexpr StringData kAppName = "DBClientConnectionTest"_sd;
 class DBClientConnectionFixture : public unittest::Test {
 public:
     static std::unique_ptr<DBClientConnection> makeConn(StringData name = kAppName) {
-        std::string errMsg;
-        auto connHolder = std::unique_ptr<DBClientBase>(
-            unittest::getFixtureConnectionString().connect(name, errMsg));
-        uassert(ErrorCodes::SocketException, errMsg, connHolder);
-
-        auto conn = dynamic_cast<DBClientConnection*>(connHolder.get());
-        invariant(conn);
-        connHolder.release();
-        return std::unique_ptr<DBClientConnection>(conn);
+        auto swConn = unittest::getFixtureConnectionString().connect(name);
+        uassertStatusOK(swConn.getStatus());
+
+        auto conn = dynamic_cast<DBClientConnection*>(swConn.getValue().release());
+        return std::unique_ptr<DBClientConnection>{conn};
     }
 
     void tearDown() override {
diff --git a/src/mongo/client/dbclient_rs.cpp b/src/mongo/client/dbclient_rs.cpp
index acd2f116d7f..c0aa64f50d5 100644
--- a/src/mongo/client/dbclient_rs.cpp
+++ b/src/mongo/client/dbclient_rs.cpp
@@ -419,13 +419,13 @@ DBClientConnection& DBClientReplicaSet::secondaryConn() {
     return *conn;
 }
 
-bool DBClientReplicaSet::connect() {
+Status DBClientReplicaSet::connect() {
     // Returns true if there are any up hosts.
     const ReadPreferenceSetting anyUpHost(ReadPreference::Nearest, TagSet());
     return _getMonitor()
         ->getHostOrRefresh(anyUpHost, CancelationToken::uncancelable())
         .getNoThrow()
-        .isOK();
+        .getStatus();
 }
 
 template <typename Authenticate>
diff --git a/src/mongo/client/dbclient_rs.h b/src/mongo/client/dbclient_rs.h
index 733eddb0dc3..414e5190226 100644
--- a/src/mongo/client/dbclient_rs.h
+++ b/src/mongo/client/dbclient_rs.h
@@ -71,11 +71,11 @@ public:
                        const ClientAPIVersionParameters* apiParameters = nullptr);
 
     /**
-     * Returns false if no member of the set were reachable. This object
-     * can still be used even when false was returned as it will try to
+     * Returns a non-OK status if no member of the set were reachable. This object
+     * can still be used even when non-OK status was returned as it will try to
      * reconnect when you use it later.
      */
-    bool connect();
+    Status connect();
 
     Status authenticateInternalUser(auth::StepDownBehavior stepDownBehavior) override;
 
diff --git a/src/mongo/client/mongo_uri_connect.cpp b/src/mongo/client/mongo_uri_connect.cpp
index fc11a7eb9ce..331ec055119 100644
--- a/src/mongo/client/mongo_uri_connect.cpp
+++ b/src/mongo/client/mongo_uri_connect.cpp
@@ -51,27 +51,29 @@ DBClientBase* MongoURI::connect(StringData applicationName,
         }
     }
 
-    auto ret = std::unique_ptr<DBClientBase>(_connectString.connect(
-        applicationName, errmsg, socketTimeoutSecs.value_or(0.0), this, apiParameters));
-    if (!ret) {
+    auto swConn = _connectString.connect(
+        applicationName, socketTimeoutSecs.value_or(0.0), this, apiParameters);
+    if (!swConn.isOK()) {
+        errmsg = swConn.getStatus().reason();
         return nullptr;
     }
 
     if (!getSetName().empty()) {
         // When performing initial topology discovery, don't bother authenticating
         // since we will be immediately restarting our connect loop to a single node.
-        return ret.release();
+        return swConn.getValue().release();
     }
 
-    if (!ret->authenticatedDuringConnect()) {
-        auto optAuthObj =
-            makeAuthObjFromOptions(ret->getMaxWireVersion(), ret->getIsPrimarySaslMechanisms());
+    auto connection = std::move(swConn.getValue());
+    if (!connection->authenticatedDuringConnect()) {
+        auto optAuthObj = makeAuthObjFromOptions(connection->getMaxWireVersion(),
+                                                 connection->getIsPrimarySaslMechanisms());
         if (optAuthObj) {
-            ret->auth(optAuthObj.get());
+            connection->auth(optAuthObj.get());
         }
     }
 
-    return ret.release();
+    return connection.release();
 }
 
 }  // namespace mongo
diff --git a/src/mongo/db/cloner.cpp b/src/mongo/db/cloner.cpp
index 20fd51253cf..a9b766af99e 100644
--- a/src/mongo/db/cloner.cpp
+++ b/src/mongo/db/cloner.cpp
@@ -462,11 +462,11 @@ Status Cloner::copyDb(OperationContext* opCtx,
     }
 
     // Set up connection.
-    std::string errmsg;
-    std::unique_ptr<DBClientBase> conn(cs.connect(StringData(), errmsg));
-    if (!conn.get()) {
-        return Status(ErrorCodes::HostUnreachable, errmsg);
+    auto swConn = cs.connect(StringData());
+    if (!swConn.isOK()) {
+        return swConn.getStatus();
     }
+    auto& conn = swConn.getValue();
 
     if (auth::isInternalAuthSet()) {
         auto authStatus = conn->authenticateInternalUser();
diff --git a/src/mongo/db/exhaust_cursor_currentop_integration_test.cpp b/src/mongo/db/exhaust_cursor_currentop_integration_test.cpp
index a9f12041aad..600b7e465f7 100644
--- a/src/mongo/db/exhaust_cursor_currentop_integration_test.cpp
+++ b/src/mongo/db/exhaust_cursor_currentop_integration_test.cpp
@@ -53,10 +53,9 @@ const NamespaceString testNSS{"exhaust_cursor_currentop.testColl"};
 
 const StringData testAppName = "curop_exhaust_cursor_test";
 std::unique_ptr<DBClientBase> connect(StringData appName = testAppName) {
-    std::string errMsg;
-    auto conn = unittest::getFixtureConnectionString().connect(appName.toString(), errMsg);
-    uassert(ErrorCodes::SocketException, errMsg, conn);
-    return conn;
+    auto swConn = unittest::getFixtureConnectionString().connect(appName.toString());
+    uassertStatusOK(swConn.getStatus());
+    return std::move(swConn.getValue());
 }
 const StringData testBackgroundAppName = "curop_exhaust_cursor_test_bg";
 
diff --git a/src/mongo/db/ops/write_ops_document_stream_integration_test.cpp b/src/mongo/db/ops/write_ops_document_stream_integration_test.cpp
index 4cd0a41a7d7..e27bc4fd5d3 100644
--- a/src/mongo/db/ops/write_ops_document_stream_integration_test.cpp
+++ b/src/mongo/db/ops/write_ops_document_stream_integration_test.cpp
@@ -39,10 +39,9 @@
 namespace mongo {
 
 TEST(WriteOpsDocSeq, InsertDocStreamWorks) {
-    std::string errMsg;
-    auto conn = std::unique_ptr<DBClientBase>(
-        unittest::getFixtureConnectionString().connect("integration_test", errMsg));
-    uassert(ErrorCodes::SocketException, errMsg, conn);
+    auto swConn = unittest::getFixtureConnectionString().connect("integration_test");
+    uassertStatusOK(swConn.getStatus());
+    auto conn = std::move(swConn.getValue());
 
     NamespaceString ns("test", "doc_seq");
     conn->dropCollection(ns.ns());
diff --git a/src/mongo/db/repl/tenant_migration_recipient_service.cpp b/src/mongo/db/repl/tenant_migration_recipient_service.cpp
index e2cf7f52888..854192436bc 100644
--- a/src/mongo/db/repl/tenant_migration_recipient_service.cpp
+++ b/src/mongo/db/repl/tenant_migration_recipient_service.cpp
@@ -271,34 +271,27 @@ std::unique_ptr<DBClientConnection> TenantMigrationRecipientService::Instance::_
     const HostAndPort& serverAddress,
     StringData applicationName,
     const TransientSSLParams* transientSSLParams) {
-    std::string errMsg;
     auto clientBase = ConnectionString(serverAddress)
                           .connect(applicationName,
-                                   errMsg,
                                    0 /* socketTimeout */,
                                    nullptr /* uri */,
                                    nullptr /* apiParameters */,
                                    transientSSLParams);
-    if (!clientBase) {
+    if (!clientBase.isOK()) {
         LOGV2_ERROR(4880400,
                     "Failed to connect to migration donor",
                     "tenantId"_attr = getTenantId(),
                     "migrationId"_attr = getMigrationUUID(),
                     "serverAddress"_attr = serverAddress,
                     "applicationName"_attr = applicationName,
-                    "error"_attr = errMsg);
-        // TODO (SERVER-53423): Make ConnectString::connect return a status instead of setting error
-        // message
-        uasserted(errMsg.find("InvalidSSLConfiguration") != std::string::npos
-                      ? ErrorCodes::InvalidSSLConfiguration
-                      : ErrorCodes::HostUnreachable,
-                  errMsg);
+                    "error"_attr = clientBase.getStatus());
+        uassertStatusOK(clientBase.getStatus());
     }
 
     // ConnectionString::connect() always returns a DBClientConnection in a unique_ptr of
     // DBClientBase type.
     std::unique_ptr<DBClientConnection> client(
-        checked_cast<DBClientConnection*>(clientBase.release()));
+        checked_cast<DBClientConnection*>(clientBase.getValue().release()));
 
     if (MONGO_likely(!skipTenantMigrationRecipientAuth.shouldFail())) {
         client->auth(auth::createInternalX509AuthDocument());
diff --git a/src/mongo/executor/task_executor_cursor_integration_test.cpp b/src/mongo/executor/task_executor_cursor_integration_test.cpp
index f5ad9b62397..f145d67826e 100644
--- a/src/mongo/executor/task_executor_cursor_integration_test.cpp
+++ b/src/mongo/executor/task_executor_cursor_integration_test.cpp
@@ -73,8 +73,9 @@ TEST_F(TaskExecutorCursorFixture, Basic) {
     auto opCtx = client->makeOperationContext();
 
     // Write 100 documents to "test.test" via dbclient
-    std::string err;
-    auto dbclient = unittest::getFixtureConnectionString().connect("TaskExecutorCursorTest", err);
+    auto swConn = unittest::getFixtureConnectionString().connect("TaskExecutorCursorTest");
+    uassertStatusOK(swConn.getStatus());
+    auto dbclient = std::move(swConn.getValue());
 
     const size_t numDocs = 100;
 
diff --git a/src/mongo/rpc/op_msg_integration_test.cpp b/src/mongo/rpc/op_msg_integration_test.cpp
index c3f285e46c5..6d3bb094720 100644
--- a/src/mongo/rpc/op_msg_integration_test.cpp
+++ b/src/mongo/rpc/op_msg_integration_test.cpp
@@ -46,6 +46,7 @@
 #include "mongo/util/scopeguard.h"
 
 namespace mongo {
+namespace {
 
 template <typename F>
 bool waitForCondition(F&& f) {
@@ -63,6 +64,13 @@ bool waitForCondition(F&& f) {
     return false;
 }
 
+std::unique_ptr<DBClientBase> getIntegrationTestConnection() {
+    auto swConn = unittest::getFixtureConnectionString().connect("integration_test");
+    uassertStatusOK(swConn.getStatus());
+    return std::move(swConn.getValue());
+}
+
+
 // Returns the connection name by filtering on the appName of a $currentOp command. If no result is
 // found, return an empty string.
 std::string getThreadNameByAppName(DBClientBase* conn, StringData appName) {
@@ -78,10 +86,7 @@ std::string getThreadNameByAppName(DBClientBase* conn, StringData appName) {
 }
 
 TEST(OpMsg, UnknownRequiredFlagClosesConnection) {
-    std::string errMsg;
-    auto conn = std::unique_ptr<DBClientBase>(
-        unittest::getFixtureConnectionString().connect("integration_test", errMsg));
-    uassert(ErrorCodes::SocketException, errMsg, conn);
+    auto conn = getIntegrationTestConnection();
 
     auto request = OpMsgRequest::fromDBAndBody("admin", BSON("ping" << 1)).serialize();
     OpMsg::setFlag(&request, 1u << 15);  // This should be the last required flag to be assigned.
@@ -91,10 +96,7 @@ TEST(OpMsg, UnknownRequiredFlagClosesConnection) {
 }
 
 TEST(OpMsg, UnknownOptionalFlagIsIgnored) {
-    std::string errMsg;
-    auto conn = std::unique_ptr<DBClientBase>(
-        unittest::getFixtureConnectionString().connect("integration_test", errMsg));
-    uassert(ErrorCodes::SocketException, errMsg, conn);
+    auto conn = getIntegrationTestConnection();
 
     auto request = OpMsgRequest::fromDBAndBody("admin", BSON("ping" << 1)).serialize();
     OpMsg::setFlag(&request, 1u << 31);  // This should be the last optional flag to be assigned.
@@ -106,10 +108,7 @@ TEST(OpMsg, UnknownOptionalFlagIsIgnored) {
 }
 
 TEST(OpMsg, FireAndForgetInsertWorks) {
-    std::string errMsg;
-    auto conn = std::unique_ptr<DBClientBase>(
-        unittest::getFixtureConnectionString().connect("integration_test", errMsg));
-    uassert(ErrorCodes::SocketException, errMsg, conn);
+    auto conn = getIntegrationTestConnection();
 
     conn->dropCollection("test.collection");
 
@@ -125,10 +124,7 @@ TEST(OpMsg, FireAndForgetInsertWorks) {
 }
 
 TEST(OpMsg, DocumentSequenceLargeDocumentMultiInsertWorks) {
-    std::string errMsg;
-    auto conn = std::unique_ptr<DBClientBase>(
-        unittest::getFixtureConnectionString().connect("integration_test", errMsg));
-    uassert(ErrorCodes::SocketException, errMsg, conn);
+    auto conn = getIntegrationTestConnection();
 
     conn->dropCollection("test.collection");
 
@@ -159,10 +155,7 @@ TEST(OpMsg, DocumentSequenceLargeDocumentMultiInsertWorks) {
 }
 
 TEST(OpMsg, DocumentSequenceMaxWriteBatchWorks) {
-    std::string errMsg;
-    auto conn = std::unique_ptr<DBClientBase>(
-        unittest::getFixtureConnectionString().connect("integration_test", errMsg));
-    uassert(ErrorCodes::SocketException, errMsg, conn);
+    auto conn = getIntegrationTestConnection();
 
     conn->dropCollection("test.collection");
 
@@ -282,10 +275,7 @@ TEST(OpMsg, CloseConnectionOnFireAndForgetNotWritablePrimaryError) {
 }
 
 TEST(OpMsg, DocumentSequenceReturnsWork) {
-    std::string errMsg;
-    auto conn = std::unique_ptr<DBClientBase>(
-        unittest::getFixtureConnectionString().connect("integration_test", errMsg));
-    uassert(ErrorCodes::SocketException, errMsg, conn);
+    auto conn = getIntegrationTestConnection();
 
     auto opMsgRequest = OpMsgRequest::fromDBAndBody("admin", BSON("echo" << 1));
     opMsgRequest.sequences.push_back({"example", {BSON("a" << 1), BSON("b" << 2)}});
@@ -326,10 +316,7 @@ void enableClientChecksum() {
 }
 
 void exhaustGetMoreTest(bool enableChecksum) {
-    std::string errMsg;
-    auto conn = std::unique_ptr<DBClientBase>(
-        unittest::getFixtureConnectionString().connect("integration_test", errMsg));
-    uassert(ErrorCodes::SocketException, errMsg, conn);
+    auto conn = getIntegrationTestConnection();
 
     // Only test exhaust against a standalone.
     if (conn->isReplicaSetMember() || conn->isMongos()) {
@@ -421,10 +408,7 @@ TEST(OpMsg, ServerHandlesExhaustGetMoreCorrectlyWithChecksum) {
 }
 
 TEST(OpMsg, FindIgnoresExhaust) {
-    std::string errMsg;
-    auto conn = std::unique_ptr<DBClientBase>(
-        unittest::getFixtureConnectionString().connect("integration_test", errMsg));
-    uassert(ErrorCodes::SocketException, errMsg, conn);
+    auto conn = getIntegrationTestConnection();
 
     // Only test exhaust against a standalone.
     if (conn->isReplicaSetMember() || conn->isMongos()) {
@@ -456,10 +440,7 @@ TEST(OpMsg, FindIgnoresExhaust) {
 }
 
 TEST(OpMsg, ServerDoesNotSetMoreToComeOnErrorInGetMore) {
-    std::string errMsg;
-    auto conn = std::unique_ptr<DBClientBase>(
-        unittest::getFixtureConnectionString().connect("integration_test", errMsg));
-    uassert(ErrorCodes::SocketException, errMsg, conn);
+    auto conn = getIntegrationTestConnection();
 
     // Only test exhaust against a standalone.
     if (conn->isReplicaSetMember() || conn->isMongos()) {
@@ -506,10 +487,7 @@ TEST(OpMsg, ServerDoesNotSetMoreToComeOnErrorInGetMore) {
 }
 
 TEST(OpMsg, MongosIgnoresExhaustForGetMore) {
-    std::string errMsg;
-    auto conn = std::unique_ptr<DBClientBase>(
-        unittest::getFixtureConnectionString().connect("integration_test", errMsg));
-    uassert(ErrorCodes::SocketException, errMsg, conn);
+    auto conn = getIntegrationTestConnection();
 
     if (!conn->isMongos()) {
         return;
@@ -558,10 +536,9 @@ TEST(OpMsg, MongosIgnoresExhaustForGetMore) {
 }
 
 TEST(OpMsg, ServerHandlesExhaustIsMasterCorrectly) {
-    std::string errMsg;
-    auto fixtureConn = std::unique_ptr<DBClientBase>(
-        unittest::getFixtureConnectionString().connect("integration_test", errMsg));
-    uassert(ErrorCodes::SocketException, errMsg, fixtureConn);
+    auto swConn = unittest::getFixtureConnectionString().connect("integration_test");
+    uassertStatusOK(swConn.getStatus());
+    auto fixtureConn = std::move(swConn.getValue());
     DBClientBase* conn = fixtureConn.get();
 
     if (fixtureConn->isReplicaSetMember()) {
@@ -621,10 +598,9 @@ TEST(OpMsg, ServerHandlesExhaustIsMasterCorrectly) {
 }
 
 TEST(OpMsg, ServerHandlesExhaustIsMasterWithTopologyChange) {
-    std::string errMsg;
-    auto fixtureConn = std::unique_ptr<DBClientBase>(
-        unittest::getFixtureConnectionString().connect("integration_test", errMsg));
-    uassert(ErrorCodes::SocketException, errMsg, fixtureConn);
+    auto swConn = unittest::getFixtureConnectionString().connect("integration_test");
+    uassertStatusOK(swConn.getStatus());
+    auto fixtureConn = std::move(swConn.getValue());
     DBClientBase* conn = fixtureConn.get();
 
     if (fixtureConn->isReplicaSetMember()) {
@@ -687,10 +663,9 @@ TEST(OpMsg, ServerHandlesExhaustIsMasterWithTopologyChange) {
 }
 
 TEST(OpMsg, ServerRejectsExhaustIsMasterWithoutMaxAwaitTimeMS) {
-    std::string errMsg;
-    auto fixtureConn = std::unique_ptr<DBClientBase>(
-        unittest::getFixtureConnectionString().connect("integration_test", errMsg));
-    uassert(ErrorCodes::SocketException, errMsg, fixtureConn);
+    auto swConn = unittest::getFixtureConnectionString().connect("integration_test");
+    uassertStatusOK(swConn.getStatus());
+    auto fixtureConn = std::move(swConn.getValue());
     DBClientBase* conn = fixtureConn.get();
 
     if (fixtureConn->isReplicaSetMember()) {
@@ -712,10 +687,7 @@ TEST(OpMsg, ServerRejectsExhaustIsMasterWithoutMaxAwaitTimeMS) {
 }
 
 void serverStatusCorrectlyShowsExhaustMetrics(std::string commandName) {
-    std::string errMsg;
-    auto conn = std::unique_ptr<DBClientBase>(
-        unittest::getFixtureConnectionString().connect("integration_test", errMsg));
-    uassert(ErrorCodes::SocketException, errMsg, conn);
+    auto conn = getIntegrationTestConnection();
 
     if (conn->isReplicaSetMember()) {
         // Don't run on replica sets as the RSM will use the streamable hello or isMaster protocol
@@ -757,10 +729,9 @@ void serverStatusCorrectlyShowsExhaustMetrics(std::string commandName) {
     ASSERT_OK(getStatusFromCommandResult(res));
 
     // Start a new connection to the server to check the serverStatus metrics.
-    std::string newErrMsg;
-    auto conn2 = std::unique_ptr<DBClientBase>(
-        unittest::getFixtureConnectionString().connect("integration_test", newErrMsg));
-    uassert(ErrorCodes::SocketException, newErrMsg, conn2);
+    auto conn2 =
+        std::move(unittest::getFixtureConnectionString().connect("integration_test").getValue());
+    uassert(ErrorCodes::SocketException, "connection failed", conn2);
 
     auto serverStatusCmd = BSON("serverStatus" << 1);
     BSONObj serverStatusReply;
@@ -788,11 +759,10 @@ TEST(OpMsg, ServerStatusCorrectlyShowsExhaustIsMasterMetricsWithIsMasterAlias) {
 }
 
 void exhaustMetricSwitchingCommandNames(bool useLegacyCommandNameAtStart) {
-    std::string errMsg;
     const auto conn1AppName = "integration_test";
-    auto conn1 = std::unique_ptr<DBClientBase>(
-        unittest::getFixtureConnectionString().connect(conn1AppName, errMsg));
-    uassert(ErrorCodes::SocketException, errMsg, conn1);
+    auto swConn1 = unittest::getFixtureConnectionString().connect(conn1AppName);
+    uassertStatusOK(swConn1.getStatus());
+    auto conn1 = std::move(swConn1.getValue());
 
     if (conn1->isReplicaSetMember()) {
         // Don't run on replica sets as the RSM will use the streamable hello or isMaster protocol
@@ -839,10 +809,9 @@ void exhaustMetricSwitchingCommandNames(bool useLegacyCommandNameAtStart) {
     ASSERT_OK(getStatusFromCommandResult(res));
 
     // Start a new connection to the server to check the serverStatus metrics.
-    std::string newErrMsg;
-    auto conn2 = std::unique_ptr<DBClientBase>(
-        unittest::getFixtureConnectionString().connect("integration_test2", newErrMsg));
-    uassert(ErrorCodes::SocketException, newErrMsg, conn2);
+    auto conn2 =
+        std::move(unittest::getFixtureConnectionString().connect("integration_test2").getValue());
+    uassert(ErrorCodes::SocketException, "connection failed", conn2);
 
     std::string threadName;
     ASSERT(waitForCondition([&] {
@@ -927,11 +896,10 @@ TEST(OpMsg, ExhaustHelloMetricSwitchingCommandNames) {
 
 
 void exhaustMetricDecrementsOnNewOpAfterTerminatingExhaustStream(bool useLegacyCommandName) {
-    std::string errMsg;
     const auto conn1AppName = "integration_test";
-    auto conn1 = std::unique_ptr<DBClientBase>(
-        unittest::getFixtureConnectionString().connect(conn1AppName, errMsg));
-    uassert(ErrorCodes::SocketException, errMsg, conn1);
+    auto swConn1 = unittest::getFixtureConnectionString().connect(conn1AppName);
+    uassertStatusOK(swConn1.getStatus());
+    auto conn1 = std::move(swConn1.getValue());
 
     if (conn1->isReplicaSetMember()) {
         // Don't run on replica sets as the RSM will use the streamable hello or isMaster protocol
@@ -977,10 +945,9 @@ void exhaustMetricDecrementsOnNewOpAfterTerminatingExhaustStream(bool useLegacyC
     ASSERT_OK(getStatusFromCommandResult(res));
 
     // Start a new connection to the server to check the serverStatus metrics.
-    std::string newErrMsg;
-    auto conn2 = std::unique_ptr<DBClientBase>(
-        unittest::getFixtureConnectionString().connect("integration_test2", newErrMsg));
-    uassert(ErrorCodes::SocketException, newErrMsg, conn2);
+    auto conn2 =
+        std::move(unittest::getFixtureConnectionString().connect("integration_test2").getValue());
+    uassert(ErrorCodes::SocketException, "connection 2 failed", conn2);
 
     std::string threadName;
     ASSERT(waitForCondition([&] {
@@ -1042,11 +1009,10 @@ TEST(OpMsg, ExhaustHelloMetricDecrementsOnNewOpAfterTerminatingExhaustStream) {
 }
 
 void exhaustMetricOnNewExhaustAfterTerminatingExhaustStream(bool useLegacyCommandName) {
-    std::string errMsg;
     const auto conn1AppName = "integration_test";
-    auto conn1 = std::unique_ptr<DBClientBase>(
-        unittest::getFixtureConnectionString().connect(conn1AppName, errMsg));
-    uassert(ErrorCodes::SocketException, errMsg, conn1);
+    auto swConn1 = unittest::getFixtureConnectionString().connect(conn1AppName);
+    uassertStatusOK(swConn1.getStatus());
+    auto conn1 = std::move(swConn1.getValue());
 
     if (conn1->isReplicaSetMember()) {
         // Don't run on replica sets as the RSM will use the streamable hello or isMaster protocol
@@ -1092,10 +1058,9 @@ void exhaustMetricOnNewExhaustAfterTerminatingExhaustStream(bool useLegacyComman
     ASSERT_OK(getStatusFromCommandResult(res));
 
     // Start a new connection to the server to check the serverStatus metrics.
-    std::string newErrMsg;
-    auto conn2 = std::unique_ptr<DBClientBase>(
-        unittest::getFixtureConnectionString().connect("integration_test2", newErrMsg));
-    uassert(ErrorCodes::SocketException, newErrMsg, conn2);
+    auto conn2 =
+        std::move(unittest::getFixtureConnectionString().connect("integration_test2").getValue());
+    uassert(ErrorCodes::SocketException, "connection failed", conn2);
 
     std::string threadName;
     ASSERT(waitForCondition([&] {
@@ -1175,10 +1140,7 @@ TEST(OpMsg, ExhaustWithDBClientCursorBehavesCorrectly) {
     // correctly. The externally visible behavior should technically be the same as a non-exhaust
     // cursor. The exhaust cursor should ideally provide a performance win over non-exhaust, but we
     // don't measure that here.
-    std::string errMsg;
-    auto conn = std::unique_ptr<DBClientBase>(
-        unittest::getFixtureConnectionString().connect("integration_test", errMsg));
-    uassert(ErrorCodes::SocketException, errMsg, conn);
+    auto conn = getIntegrationTestConnection();
 
     // Only test exhaust against a standalone.
     if (conn->isReplicaSetMember() || conn->isMongos()) {
@@ -1228,10 +1190,7 @@ TEST(OpMsg, ExhaustWithDBClientCursorBehavesCorrectly) {
 
 void checksumTest(bool enableChecksum) {
     // The server replies with a checksum if and only if the request has a checksum.
-    std::string errMsg;
-    auto conn = std::unique_ptr<DBClientBase>(
-        unittest::getFixtureConnectionString().connect("integration_test", errMsg));
-    uassert(ErrorCodes::SocketException, errMsg, conn);
+    auto conn = getIntegrationTestConnection();
 
     if (!enableChecksum) {
         disableClientChecksum();
@@ -1258,9 +1217,7 @@ TEST(OpMsg, ServerRepliesWithChecksumToRequestWithChecksum) {
 }
 
 TEST(OpMsg, ServerHandlesReallyLargeMessagesGracefully) {
-    std::string errMsg;
-    auto conn = unittest::getFixtureConnectionString().connect("integration_test", errMsg);
-    uassert(ErrorCodes::SocketException, errMsg, conn);
+    auto conn = getIntegrationTestConnection();
 
     auto buildInfo = conn->runCommand(OpMsgRequest::fromDBAndBody("admin", BSON("buildInfo" << 1)))
                          ->getCommandReply();
@@ -1299,9 +1256,10 @@ public:
             uri.setHelloOk(helloOk.get());
         }
 
-        std::string errMsg;
-        auto conn = connStr.connect(_appName, errMsg, 0, &uri);
-        uassert(ErrorCodes::SocketException, errMsg, conn);
+        auto swConn = connStr.connect(_appName, 0, &uri);
+        uassertStatusOK(swConn.getStatus());
+        auto conn = std::move(swConn.getValue());
+        uassert(ErrorCodes::SocketException, "connection failed", conn);
 
         _configureFailPoint(conn.get());
         return conn;
@@ -1360,4 +1318,5 @@ TEST(OpMsg, HelloOkCanBeDisabled) {
     ASSERT(!isHelloOk);
 }
 
+}  // namespace
 }  // namespace mongo
diff --git a/src/mongo/shell/shell_utils.cpp b/src/mongo/shell/shell_utils.cpp
index 4fe70659c20..c6e0126b4ff 100644
--- a/src/mongo/shell/shell_utils.cpp
+++ b/src/mongo/shell/shell_utils.cpp
@@ -131,10 +131,9 @@ namespace {
 std::unique_ptr<DBClientBase> benchRunConfigCreateConnectionImplProvider(
     const BenchRunConfig& config) {
     const ConnectionString connectionString = uassertStatusOK(ConnectionString::parse(config.host));
-    std::string errorMessage;
-    std::unique_ptr<DBClientBase> connection(connectionString.connect("BenchRun", errorMessage));
-    uassert(16158, errorMessage, connection);
-    return connection;
+    auto swConn{connectionString.connect("BenchRun")};
+    uassert(16158, swConn.getStatus().reason(), swConn.isOK());
+    return std::move(swConn.getValue());
 }
 
 auto benchRunConfigCreateConnectionImplRegistration = MONGO_WEAK_FUNCTION_REGISTRATION(