Change curl defaults on MacOS (#645)

* changed curl config to match the default from vcpkg (i.e `CURL_CA_FALLBACK=ON`) 
* disables use of Secure Transport for Mac since it's deprecated
* Also worked around an issue (with `CURL_CA_BUNDLE`) where cross compiling curl on Mac would not configure curl in the same way as when compiling natively. This meant builds would not download on ARM macs when the CI build machine architecture was x86. The workaround should be redundant if we upgrade to 8.17 and use Apple SecTrust for cert validation. This should happen soon.
* Also added various verbose logging to facilitate trouble shooting

14 files changed, 149 insertions, 31 deletions

diff --git a/VERSION.txt b/VERSION.txt
index aceef462c..370d5210a 100644
--- a/VERSION.txt
+++ b/VERSION.txt
@@ -1 +1 @@
-5.7.9-pre15
\ No newline at end of file
+5.7.9-pre18
\ No newline at end of file
diff --git a/repo/packages/l/libcurl/xmake.lua b/repo/packages/l/libcurl/xmake.lua
index 16dfaf398..3c789e7f2 100644
--- a/repo/packages/l/libcurl/xmake.lua
+++ b/repo/packages/l/libcurl/xmake.lua
@@ -110,7 +110,7 @@ package("libcurl")
     on_install("windows", "mingw", "linux", "bsd", "macosx", "iphoneos", "cross", "android", function (package)
         local version = package:version()
 
-        local configs = {"-DBUILD_TESTING=OFF", "-DENABLE_MANUAL=OFF", "-DENABLE_CURL_MANUAL=OFF"}
+        local configs = {"-DBUILD_TESTING=OFF", "-DENABLE_MANUAL=OFF", "-DENABLE_CURL_MANUAL=OFF", "-DCURL_CA_FALLBACK=ON"}
         table.insert(configs, "-DCMAKE_BUILD_TYPE=" .. (package:debug() and "Debug" or "Release"))
         table.insert(configs, "-DBUILD_SHARED_LIBS=" .. (package:config("shared") and "ON" or "OFF"))
 
@@ -139,7 +139,7 @@ package("libcurl")
             table.insert(configs, (version:ge("7.80") and "-DCURL_USE_SCHANNEL=ON" or "-DCMAKE_USE_SCHANNEL=ON"))
         end
         if package:is_plat("macosx", "iphoneos") then
-            table.insert(configs, (version:ge("7.65") and "-DCURL_USE_SECTRANSP=ON" or "-DCMAKE_USE_DARWINSSL=ON"))
+            table.insert(configs, '-DCURL_CA_BUNDLE=/etc/ssl/cert.pem')
         end
         if package:is_plat("windows") then
             table.insert(configs, "-DCURL_STATIC_CRT=" .. (package:runtimes():startswith("MT") and "ON" or "OFF"))
diff --git a/src/zen/authutils.cpp b/src/zen/authutils.cpp
index bc185535b..fdcb8e15d 100644
--- a/src/zen/authutils.cpp
+++ b/src/zen/authutils.cpp
@@ -147,7 +147,8 @@ AuthCommandLineOptions::ParseOptions(cxxopts::Options&			  Ops,
 									 std::string_view			  HostUrl,
 									 std::unique_ptr<AuthMgr>&	  Auth,
 									 bool						  Quiet,
-									 bool						  Hidden)
+									 bool						  Hidden,
+									 bool						  Verbose)
 {
 	auto CreateAuthMgr = [&]() {
 		ZEN_ASSERT(!SystemRootDir.empty());
@@ -182,6 +183,14 @@ AuthCommandLineOptions::ParseOptions(cxxopts::Options&			  Ops,
 			{
 				throw OptionParseException(fmt::format("'--encryption-aes-iv' ('{}') is malformed", m_EncryptionIV), Ops.help());
 			}
+			if (Verbose)
+			{
+				ExtendableStringBuilder<128> SB;
+				SB << "\n    RootDirectory: " << AuthMgrConfig.RootDirectory.string();
+				SB << "\n    EncryptionKey: " << m_EncryptionKey;
+				SB << "\n    EncryptionIV:  " << m_EncryptionIV;
+				ZEN_CONSOLE("Creating auth manager with:{}", SB.ToString());
+			}
 			Auth = AuthMgr::Create(AuthMgrConfig);
 		}
 	};
@@ -190,9 +199,18 @@ AuthCommandLineOptions::ParseOptions(cxxopts::Options&			  Ops,
 	{
 		CreateAuthMgr();
 		std::string ProviderName = m_OpenIdProviderName.empty() ? "Default" : m_OpenIdProviderName;
+		if (Verbose)
+		{
+			ExtendableStringBuilder<128> SB;
+			SB << "\n    Name:     " << ProviderName;
+			SB << "\n    Url:      " << m_OpenIdProviderUrl;
+			SB << "\n    ClientId: " << m_OpenIdClientId;
+			ZEN_CONSOLE("Adding openid auth provider:{}", SB.ToString());
+		}
 		Auth->AddOpenIdProvider({.Name = ProviderName, .Url = m_OpenIdProviderUrl, .ClientId = m_OpenIdClientId});
 		if (!m_OpenIdRefreshToken.empty())
 		{
+			ZEN_CONSOLE("Adding open id refresh token {} to provider {}", m_OpenIdRefreshToken, ProviderName);
 			Auth->AddOpenIdToken({.ProviderName = ProviderName, .RefreshToken = m_OpenIdRefreshToken});
 		}
 	}
@@ -207,6 +225,10 @@ AuthCommandLineOptions::ParseOptions(cxxopts::Options&			  Ops,
 
 	if (!m_AccessToken.empty())
 	{
+		if (Verbose)
+		{
+			ZEN_CONSOLE("Adding static auth token: {}", m_AccessToken);
+		}
 		ClientSettings.AccessTokenProvider = httpclientauth::CreateFromStaticToken(m_AccessToken);
 	}
 	else if (!m_AccessTokenPath.empty())
@@ -215,25 +237,49 @@ AuthCommandLineOptions::ParseOptions(cxxopts::Options&			  Ops,
 		std::string ResolvedAccessToken = ReadAccessTokenFromJsonFile(m_AccessTokenPath);
 		if (!ResolvedAccessToken.empty())
 		{
+			if (Verbose)
+			{
+				ZEN_CONSOLE("Adding static auth token from {}: {}", m_AccessTokenPath, ResolvedAccessToken);
+			}
 			ClientSettings.AccessTokenProvider = httpclientauth::CreateFromStaticToken(ResolvedAccessToken);
 		}
 	}
 	else if (!m_OAuthUrl.empty())
 	{
+		if (Verbose)
+		{
+			ExtendableStringBuilder<128> SB;
+			SB << "\n    Url:          " << m_OAuthUrl;
+			SB << "\n    ClientId:     " << m_OAuthClientId;
+			SB << "\n    ClientSecret: " << m_OAuthClientSecret;
+			ZEN_CONSOLE("Adding oauth provider:{}", SB.ToString());
+		}
 		ClientSettings.AccessTokenProvider = httpclientauth::CreateFromOAuthClientCredentials(
 			{.Url = m_OAuthUrl, .ClientId = m_OAuthClientId, .ClientSecret = m_OAuthClientSecret});
 	}
 	else if (!m_OpenIdProviderName.empty())
 	{
 		CreateAuthMgr();
+		if (Verbose)
+		{
+			ZEN_CONSOLE("Using openid provider: {}", m_OpenIdProviderName);
+		}
 		ClientSettings.AccessTokenProvider = httpclientauth::CreateFromOpenIdProvider(*Auth, m_OpenIdProviderName);
 	}
 	else if (std::string ResolvedAccessToken = GetEnvAccessToken(m_AccessTokenEnv); !ResolvedAccessToken.empty())
 	{
+		if (Verbose)
+		{
+			ZEN_CONSOLE("Using environment variable '{}' as access token '{}'", m_AccessTokenEnv, ResolvedAccessToken);
+		}
 		ClientSettings.AccessTokenProvider = httpclientauth::CreateFromStaticToken(ResolvedAccessToken);
 	}
 	else if (std::filesystem::path OidcTokenExePath = FindOidcTokenExePath(m_OidcTokenAuthExecutablePath); !OidcTokenExePath.empty())
 	{
+		if (Verbose)
+		{
+			ZEN_CONSOLE("Running oidctoken exe from path '{}'", m_OidcTokenAuthExecutablePath);
+		}
 		ClientSettings.AccessTokenProvider =
 			httpclientauth::CreateFromOidcTokenExecutable(OidcTokenExePath, HostUrl, Quiet, m_OidcTokenUnattended, Hidden);
 	}
@@ -241,6 +287,10 @@ AuthCommandLineOptions::ParseOptions(cxxopts::Options&			  Ops,
 	if (!ClientSettings.AccessTokenProvider)
 	{
 		CreateAuthMgr();
+		if (Verbose)
+		{
+			ZEN_CONSOLE("Using default openid provider");
+		}
 		ClientSettings.AccessTokenProvider = httpclientauth::CreateFromDefaultOpenIdProvider(*Auth);
 	}
 }
diff --git a/src/zen/authutils.h b/src/zen/authutils.h
index 8f041c8fc..2201c3f83 100644
--- a/src/zen/authutils.h
+++ b/src/zen/authutils.h
@@ -42,7 +42,8 @@ struct AuthCommandLineOptions
 					  std::string_view			   HostUrl,
 					  std::unique_ptr<AuthMgr>&	   OutAuthMgr,
 					  bool						   Quiet,
-					  bool						   Hidden);
+					  bool						   Hidden,
+					  bool						   Verbose);
 };
 
 std::string			  ReadAccessTokenFromJsonFile(const std::filesystem::path& Path);
diff --git a/src/zen/cmds/builds_cmd.cpp b/src/zen/cmds/builds_cmd.cpp
index 33a35156e..ab991fe6a 100644
--- a/src/zen/cmds/builds_cmd.cpp
+++ b/src/zen/cmds/builds_cmd.cpp
@@ -3010,10 +3010,11 @@ BuildsCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 									   m_Host.empty() ? m_OverrideHost : m_Host,
 									   Auth,
 									   IsQuiet,
-									   /*Hidden*/ false);
+									   /*Hidden*/ false,
+									   m_Verbose);
 
 			BuildStorageResolveResult ResolveRes =
-				ResolveBuildStorage(ClientSettings, m_Host, m_OverrideHost, m_ZenCacheHost, ZenCacheResolveMode::All);
+				ResolveBuildStorage(ClientSettings, m_Host, m_OverrideHost, m_ZenCacheHost, ZenCacheResolveMode::All, m_Verbose);
 			if (!ResolveRes.HostUrl.empty())
 			{
 				ClientSettings.AssumeHttp2 = ResolveRes.HostAssumeHttp2;
diff --git a/src/zen/cmds/projectstore_cmd.cpp b/src/zen/cmds/projectstore_cmd.cpp
index 6cf846606..5791e6fda 100644
--- a/src/zen/cmds/projectstore_cmd.cpp
+++ b/src/zen/cmds/projectstore_cmd.cpp
@@ -2431,10 +2431,11 @@ OplogDownloadCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** a
 							   m_OverrideHost.empty() ? m_Host : m_OverrideHost,
 							   Auth,
 							   m_Quiet,
-							   /*Hidden*/ false);
+							   /*Hidden*/ false,
+							   m_Verbose);
 
 	BuildStorageResolveResult ResolveRes =
-		ResolveBuildStorage(ClientSettings, m_Host, m_OverrideHost, m_ZenCacheHost, ZenCacheResolveMode::Discovery);
+		ResolveBuildStorage(ClientSettings, m_Host, m_OverrideHost, m_ZenCacheHost, ZenCacheResolveMode::Discovery, m_Verbose);
 
 	BuildStorageBase::Statistics StorageStats;
 
diff --git a/src/zencore/xmake.lua b/src/zencore/xmake.lua
index ef462ad03..a3fd4dacb 100644
--- a/src/zencore/xmake.lua
+++ b/src/zencore/xmake.lua
@@ -37,10 +37,8 @@ target('zencore')
     
     add_packages("json11")
 
-    if is_plat("linux") then
+    if is_plat("linux", "macosx") then
         add_packages("openssl3") -- required for crypto
-    elseif is_plat("macosx") then
-        add_packages("mbedtls") -- required for crypto
     end
     
     add_packages(
diff --git a/src/zenremotestore/builds/buildstoragecache.cpp b/src/zenremotestore/builds/buildstoragecache.cpp
index d7442d7c5..39f2b8373 100644
--- a/src/zenremotestore/builds/buildstoragecache.cpp
+++ b/src/zenremotestore/builds/buildstoragecache.cpp
@@ -411,14 +411,15 @@ CreateZenBuildStorageCache(HttpClient&					  HttpClient,
 }
 
 ZenCacheEndpointTestResult
-TestZenCacheEndpoint(std::string_view BaseUrl, const bool AssumeHttp2)
+TestZenCacheEndpoint(std::string_view BaseUrl, const bool AssumeHttp2, const bool HttpVerbose)
 {
 	HttpClientSettings	 TestClientSettings{.LogCategory	= "httpcacheclient",
 											.ConnectTimeout = std::chrono::milliseconds{1000},
 											.Timeout		= std::chrono::milliseconds{2000},
 											.AssumeHttp2	= AssumeHttp2,
 											.AllowResume	= true,
-											.RetryCount		= 0};
+											.RetryCount		= 0,
+											.Verbose		= HttpVerbose};
 	HttpClient			 TestHttpClient(BaseUrl, TestClientSettings);
 	HttpClient::Response TestResponse = TestHttpClient.Get("/status/builds");
 	if (TestResponse.IsSuccess())
diff --git a/src/zenremotestore/builds/buildstorageutil.cpp b/src/zenremotestore/builds/buildstorageutil.cpp
index 3680d1d83..3af323628 100644
--- a/src/zenremotestore/builds/buildstorageutil.cpp
+++ b/src/zenremotestore/builds/buildstorageutil.cpp
@@ -13,13 +13,31 @@
 #include <zenutil/zenserverprocess.h>
 
 namespace zen {
+namespace {
+	std::string ConnectionSettingsToString(const HttpClientSettings& ClientSettings)
+	{
+		ExtendableStringBuilder<128> SB;
+		SB << "\n    LogCategory:                 " << ClientSettings.LogCategory;
+		SB << "\n    ConnectTimeout:              " << ClientSettings.ConnectTimeout.count() << " ms";
+		SB << "\n    Timeout:                     " << ClientSettings.Timeout.count() << " ms";
+		SB << "\n    AccessTokenProvider:         " << ClientSettings.AccessTokenProvider.has_value();
+		SB << "\n    AssumeHttp2:                 " << ClientSettings.AssumeHttp2;
+		SB << "\n    AllowResume:                 " << ClientSettings.AllowResume;
+		SB << "\n    RetryCount:                  " << ClientSettings.RetryCount;
+		SB << "\n    SessionId:                   " << ClientSettings.SessionId.ToString();
+		SB << "\n    Verbose:                     " << ClientSettings.Verbose;
+		SB << "\n    MaximumInMemoryDownloadSize: " << ClientSettings.MaximumInMemoryDownloadSize;
+		return SB.ToString();
+	}
+}  // namespace
 
 BuildStorageResolveResult
 ResolveBuildStorage(const HttpClientSettings& ClientSettings,
 					std::string_view		  Host,
 					std::string_view		  OverrideHost,
 					std::string_view		  ZenCacheHost,
-					ZenCacheResolveMode		  ZenResolveMode)
+					ZenCacheResolveMode		  ZenResolveMode,
+					bool					  Verbose)
 {
 	bool AllowZenCacheDiscovery = ZenResolveMode == ZenCacheResolveMode::Discovery || ZenResolveMode == ZenCacheResolveMode::All;
 	bool AllowLocalZenCache		= ZenResolveMode == ZenCacheResolveMode::LocalHost || ZenResolveMode == ZenCacheResolveMode::All;
@@ -55,13 +73,29 @@ ResolveBuildStorage(const HttpClientSettings& ClientSettings,
 
 	if (OverrideHost.empty() || (ZenCacheHost.empty() && AllowZenCacheDiscovery))
 	{
+		if (Verbose)
+		{
+			ZEN_CONSOLE("Querying servers at '{}/api/v1/status/servers'\n  Connection settings:{}",
+						DiscoveryHost,
+						ConnectionSettingsToString(ClientSettings));
+		}
+
 		DiscoveryResponse = DiscoverJupiterEndpoints(DiscoveryHost, ClientSettings);
 	}
 
 	if (!OverrideHost.empty())
 	{
-		if (JupiterEndpointTestResult TestResult = TestJupiterEndpoint(OverrideHost, HostAssumeHttp2); TestResult.Success)
+		if (Verbose)
+		{
+			ZEN_CONSOLE("Testing server endpoint at '{}/health/live'. Assume http2: {}", OverrideHost, HostAssumeHttp2);
+		}
+		if (JupiterEndpointTestResult TestResult = TestJupiterEndpoint(OverrideHost, HostAssumeHttp2, ClientSettings.Verbose);
+			TestResult.Success)
 		{
+			if (Verbose)
+			{
+				ZEN_CONSOLE("Server endpoint at '{}/api/v1/status/servers' succeeded", OverrideHost);
+			}
 			HostUrl	 = OverrideHost;
 			HostName = GetHostNameFromUrl(OverrideHost);
 		}
@@ -81,9 +115,19 @@ ResolveBuildStorage(const HttpClientSettings& ClientSettings,
 		{
 			if (!ServerEndpoint.BaseUrl.empty())
 			{
-				if (JupiterEndpointTestResult TestResult = TestJupiterEndpoint(ServerEndpoint.BaseUrl, ServerEndpoint.AssumeHttp2);
+				if (Verbose)
+				{
+					ZEN_CONSOLE("Testing server endpoint at '{}/health/live'. Assume http2: {}",
+								ServerEndpoint.BaseUrl,
+								ServerEndpoint.AssumeHttp2);
+				}
+
+				if (JupiterEndpointTestResult TestResult =
+						TestJupiterEndpoint(ServerEndpoint.BaseUrl, ServerEndpoint.AssumeHttp2, ClientSettings.Verbose);
 					TestResult.Success)
 				{
+					ZEN_CONSOLE("Server endpoint at '{}/api/v1/status/servers' succeeded", ServerEndpoint.BaseUrl);
+
 					HostUrl			= ServerEndpoint.BaseUrl;
 					HostAssumeHttp2 = ServerEndpoint.AssumeHttp2;
 					HostName		= ServerEndpoint.Name;
@@ -110,9 +154,19 @@ ResolveBuildStorage(const HttpClientSettings& ClientSettings,
 			{
 				if (!CacheEndpoint.BaseUrl.empty())
 				{
-					if (ZenCacheEndpointTestResult TestResult = TestZenCacheEndpoint(CacheEndpoint.BaseUrl, CacheEndpoint.AssumeHttp2);
+					if (Verbose)
+					{
+						ZEN_CONSOLE("Testing cache endpoint at '{}/status/builds'. Assume http2: {}",
+									CacheEndpoint.BaseUrl,
+									CacheEndpoint.AssumeHttp2);
+					}
+
+					if (ZenCacheEndpointTestResult TestResult =
+							TestZenCacheEndpoint(CacheEndpoint.BaseUrl, CacheEndpoint.AssumeHttp2, ClientSettings.Verbose);
 						TestResult.Success)
 					{
+						ZEN_CONSOLE("Cache endpoint at '{}/status/builds' succeeded", CacheEndpoint.BaseUrl);
+
 						CacheUrl		 = CacheEndpoint.BaseUrl;
 						CacheAssumeHttp2 = CacheEndpoint.AssumeHttp2;
 						CacheName		 = CacheEndpoint.Name;
@@ -130,7 +184,9 @@ ResolveBuildStorage(const HttpClientSettings& ClientSettings,
 					if (CacheUrl.empty())
 					{
 						std::string ZenServerLocalHostUrl = fmt::format("http://127.0.0.1:{}", Entry.EffectiveListenPort.load());
-						if (ZenCacheEndpointTestResult TestResult = TestZenCacheEndpoint(ZenServerLocalHostUrl, false); TestResult.Success)
+						if (ZenCacheEndpointTestResult TestResult =
+								TestZenCacheEndpoint(ZenServerLocalHostUrl, /*AssumeHttp2*/ false, ClientSettings.Verbose);
+							TestResult.Success)
 						{
 							CacheUrl		 = ZenServerLocalHostUrl;
 							CacheAssumeHttp2 = false;
@@ -141,14 +197,22 @@ ResolveBuildStorage(const HttpClientSettings& ClientSettings,
 			}
 		}
 	}
-	else if (ZenCacheEndpointTestResult TestResult = TestZenCacheEndpoint(ZenCacheHost, false); TestResult.Success)
-	{
-		CacheUrl  = ZenCacheHost;
-		CacheName = GetHostNameFromUrl(ZenCacheHost);
-	}
 	else
 	{
-		ZEN_WARN("Unable to reach cache host {}. Reason: {}", ZenCacheHost, TestResult.FailureReason);
+		if (Verbose)
+		{
+			ZEN_CONSOLE("Testing cache endpoint at '{}/status/builds'. Assume http2: {}", ZenCacheHost, false);
+		}
+		if (ZenCacheEndpointTestResult TestResult = TestZenCacheEndpoint(ZenCacheHost, /*AssumeHttp2*/ false, ClientSettings.Verbose);
+			TestResult.Success)
+		{
+			CacheUrl  = ZenCacheHost;
+			CacheName = GetHostNameFromUrl(ZenCacheHost);
+		}
+		else
+		{
+			ZEN_WARN("Unable to reach cache host {}. Reason: {}", ZenCacheHost, TestResult.FailureReason);
+		}
 	}
 
 	return BuildStorageResolveResult{.HostUrl		  = HostUrl,
diff --git a/src/zenremotestore/include/zenremotestore/builds/buildstoragecache.h b/src/zenremotestore/include/zenremotestore/builds/buildstoragecache.h
index f1916da10..bb5b1c5f4 100644
--- a/src/zenremotestore/include/zenremotestore/builds/buildstoragecache.h
+++ b/src/zenremotestore/include/zenremotestore/builds/buildstoragecache.h
@@ -67,6 +67,6 @@ struct ZenCacheEndpointTestResult
 	std::string FailureReason;
 };
 
-ZenCacheEndpointTestResult TestZenCacheEndpoint(std::string_view BaseUrl, const bool AssumeHttp2);
+ZenCacheEndpointTestResult TestZenCacheEndpoint(std::string_view BaseUrl, const bool AssumeHttp2, const bool HttpVerbose);
 
 }  // namespace zen
diff --git a/src/zenremotestore/include/zenremotestore/builds/buildstorageutil.h b/src/zenremotestore/include/zenremotestore/builds/buildstorageutil.h
index 3816822be..7ac1f78d4 100644
--- a/src/zenremotestore/include/zenremotestore/builds/buildstorageutil.h
+++ b/src/zenremotestore/include/zenremotestore/builds/buildstorageutil.h
@@ -35,7 +35,8 @@ BuildStorageResolveResult ResolveBuildStorage(const HttpClientSettings& ClientSe
 											  std::string_view			Host,
 											  std::string_view			OverrideHost,
 											  std::string_view			ZenCacheHost,
-											  ZenCacheResolveMode		ZenResolveMode);
+											  ZenCacheResolveMode		ZenResolveMode,
+											  bool						Verbose);
 
 std::vector<ChunkBlockDescription> GetBlockDescriptions(OperationLogOutput&		Output,
 														BuildStorageBase&		Storage,
diff --git a/src/zenremotestore/include/zenremotestore/jupiter/jupiterhost.h b/src/zenremotestore/include/zenremotestore/jupiter/jupiterhost.h
index 3bbc700b8..432496bc1 100644
--- a/src/zenremotestore/include/zenremotestore/jupiter/jupiterhost.h
+++ b/src/zenremotestore/include/zenremotestore/jupiter/jupiterhost.h
@@ -30,6 +30,6 @@ struct JupiterEndpointTestResult
 	std::string FailureReason;
 };
 
-JupiterEndpointTestResult TestJupiterEndpoint(std::string_view BaseUrl, const bool AssumeHttp2);
+JupiterEndpointTestResult TestJupiterEndpoint(std::string_view BaseUrl, const bool AssumeHttp2, const bool HttpVerbose);
 
 }  // namespace zen
diff --git a/src/zenremotestore/jupiter/jupiterhost.cpp b/src/zenremotestore/jupiter/jupiterhost.cpp
index 01728f38d..6b13d69a5 100644
--- a/src/zenremotestore/jupiter/jupiterhost.cpp
+++ b/src/zenremotestore/jupiter/jupiterhost.cpp
@@ -45,14 +45,15 @@ DiscoverJupiterEndpoints(std::string_view Host, const HttpClientSettings& Client
 }
 
 JupiterEndpointTestResult
-TestJupiterEndpoint(std::string_view BaseUrl, const bool AssumeHttp2)
+TestJupiterEndpoint(std::string_view BaseUrl, const bool AssumeHttp2, const bool HttpVerbose)
 {
 	HttpClientSettings TestClientSettings{.LogCategory	  = "httpbuildsclient",
 										  .ConnectTimeout = std::chrono::milliseconds{1000},
 										  .Timeout		  = std::chrono::milliseconds{2000},
 										  .AssumeHttp2	  = AssumeHttp2,
 										  .AllowResume	  = true,
-										  .RetryCount	  = 0};
+										  .RetryCount	  = 0,
+										  .Verbose		  = HttpVerbose};
 
 	HttpClient			 TestHttpClient(BaseUrl, TestClientSettings);
 	HttpClient::Response TestResponse = TestHttpClient.Get("/health/live");
diff --git a/src/zenremotestore/projectstore/buildsremoteprojectstore.cpp b/src/zenremotestore/projectstore/buildsremoteprojectstore.cpp
index 09ffc5d71..db2192a49 100644
--- a/src/zenremotestore/projectstore/buildsremoteprojectstore.cpp
+++ b/src/zenremotestore/projectstore/buildsremoteprojectstore.cpp
@@ -665,7 +665,7 @@ CreateJupiterBuildsRemoteStore(LoggerRef					   InLog,
 										  .AllowResume		   = true,
 										  .RetryCount		   = 2};
 
-		ResolveRes = ResolveBuildStorage(ClientSettings, Host, OverrideUrl, ZenHost, ZenCacheResolveMode::Discovery);
+		ResolveRes = ResolveBuildStorage(ClientSettings, Host, OverrideUrl, ZenHost, ZenCacheResolveMode::Discovery, /*Verbose*/ false);
 	}
 
 	HttpClientSettings ClientSettings{.LogCategory		   = "httpbuildsclient",