diff --git a/src/Runner.Common/RunnerServer.cs b/src/Runner.Common/RunnerServer.cs
index f377622c6..4452e36b5 100644
--- a/src/Runner.Common/RunnerServer.cs
+++ b/src/Runner.Common/RunnerServer.cs
@@ -68,11 +68,23 @@ namespace GitHub.Runner.Common
 
         public async Task ConnectAsync(Uri serverUrl, VssCredentials credentials)
         {
-            var createGenericConnection = EstablishVssConnection(serverUrl, credentials, TimeSpan.FromSeconds(100));
+            System.Console.WriteLine("RunnerServer.ConnectAsync: Create message connection");
             var createMessageConnection = EstablishVssConnection(serverUrl, credentials, TimeSpan.FromSeconds(60));
-            var createRequestConnection = EstablishVssConnection(serverUrl, credentials, TimeSpan.FromSeconds(60));
+            await Task.WhenAll(createMessageConnection);
 
-            await Task.WhenAll(createGenericConnection, createMessageConnection, createRequestConnection);
+            System.Console.WriteLine("RunnerServer.ConnectAsync: Create generic connection");
+            var createGenericConnection = EstablishVssConnection(serverUrl, credentials, TimeSpan.FromSeconds(100));
+            await Task.WhenAll(createGenericConnection);
+
+            System.Console.WriteLine("RunnerServer.ConnectAsync: Create request connection");
+            var createRequestConnection = EstablishVssConnection(serverUrl, credentials, TimeSpan.FromSeconds(60));
+            await Task.WhenAll(createRequestConnection);
+
+            // var createGenericConnection = EstablishVssConnection(serverUrl, credentials, TimeSpan.FromSeconds(100));
+            // var createMessageConnection = EstablishVssConnection(serverUrl, credentials, TimeSpan.FromSeconds(60));
+            // var createRequestConnection = EstablishVssConnection(serverUrl, credentials, TimeSpan.FromSeconds(60));
+
+            // await Task.WhenAll(createGenericConnection, createMessageConnection, createRequestConnection);
 
             _genericConnection = await createGenericConnection;
             _messageConnection = await createMessageConnection;
@@ -182,6 +194,8 @@ namespace GitHub.Runner.Common
 
         private async Task<VssConnection> EstablishVssConnection(Uri serverUrl, VssCredentials credentials, TimeSpan timeout)
         {
+            System.Console.WriteLine("EstablishVssConnection");
+            Trace.Info($"EstablishVssConnection");
             Trace.Info($"Establish connection with {timeout.TotalSeconds} seconds timeout.");
             int attemptCount = 5;
             while (attemptCount-- > 0)
@@ -238,41 +252,48 @@ namespace GitHub.Runner.Common
 
         public Task<List<TaskAgentPool>> GetAgentPoolsAsync(string agentPoolName = null, TaskAgentPoolType poolType = TaskAgentPoolType.Automation)
         {
+            System.Console.WriteLine("RunnerServer.qqq");
             CheckConnection(RunnerConnectionType.Generic);
             return _genericTaskAgentClient.GetAgentPoolsAsync(agentPoolName, poolType: poolType);
         }
 
         public Task<TaskAgent> AddAgentAsync(Int32 agentPoolId, TaskAgent agent)
         {
+            System.Console.WriteLine("RunnerServer.qqq");
             CheckConnection(RunnerConnectionType.Generic);
             return _genericTaskAgentClient.AddAgentAsync(agentPoolId, agent);
         }
 
         public Task<List<TaskAgent>> GetAgentsAsync(int agentPoolId, string agentName = null)
         {
+            System.Console.WriteLine("RunnerServer.qqq");
             CheckConnection(RunnerConnectionType.Generic);
             return _genericTaskAgentClient.GetAgentsAsync(agentPoolId, agentName, false);
         }
 
         public Task<List<TaskAgent>> GetAgentsAsync(string agentName)
         {
+            System.Console.WriteLine("RunnerServer.qqq");
             return GetAgentsAsync(0, agentName); // search in all all agentPools
         }
 
         public Task<TaskAgent> ReplaceAgentAsync(int agentPoolId, TaskAgent agent)
         {
+            System.Console.WriteLine("RunnerServer.qqq");
             CheckConnection(RunnerConnectionType.Generic);
             return _genericTaskAgentClient.ReplaceAgentAsync(agentPoolId, agent);
         }
 
         public Task DeleteAgentAsync(int agentPoolId, int agentId)
         {
+            System.Console.WriteLine("RunnerServer.qqq");
             CheckConnection(RunnerConnectionType.Generic);
             return _genericTaskAgentClient.DeleteAgentAsync(agentPoolId, agentId);
         }
 
         public Task DeleteAgentAsync(int agentId)
         {
+            System.Console.WriteLine("RunnerServer.qqq");
             return DeleteAgentAsync(0, agentId); // agentPool is ignored server side
         }
 
@@ -282,24 +303,28 @@ namespace GitHub.Runner.Common
 
         public Task<TaskAgentSession> CreateAgentSessionAsync(Int32 poolId, TaskAgentSession session, CancellationToken cancellationToken)
         {
+            System.Console.WriteLine("RunnerServer.CreateAgentSessionAsync");
             CheckConnection(RunnerConnectionType.MessageQueue);
             return _messageTaskAgentClient.CreateAgentSessionAsync(poolId, session, cancellationToken: cancellationToken);
         }
 
         public Task DeleteAgentMessageAsync(Int32 poolId, Int64 messageId, Guid sessionId, CancellationToken cancellationToken)
         {
+            System.Console.WriteLine("RunnerServer.qqq");
             CheckConnection(RunnerConnectionType.MessageQueue);
             return _messageTaskAgentClient.DeleteMessageAsync(poolId, messageId, sessionId, cancellationToken: cancellationToken);
         }
 
         public Task DeleteAgentSessionAsync(Int32 poolId, Guid sessionId, CancellationToken cancellationToken)
         {
+            System.Console.WriteLine("RunnerServer.qqq");
             CheckConnection(RunnerConnectionType.MessageQueue);
             return _messageTaskAgentClient.DeleteAgentSessionAsync(poolId, sessionId, cancellationToken: cancellationToken);
         }
 
         public Task<TaskAgentMessage> GetAgentMessageAsync(Int32 poolId, Guid sessionId, Int64? lastMessageId, CancellationToken cancellationToken)
         {
+            System.Console.WriteLine("RunnerServer.qqq");
             CheckConnection(RunnerConnectionType.MessageQueue);
             return _messageTaskAgentClient.GetMessageAsync(poolId, sessionId, lastMessageId, cancellationToken: cancellationToken);
         }
@@ -310,18 +335,21 @@ namespace GitHub.Runner.Common
 
         public Task<TaskAgentJobRequest> RenewAgentRequestAsync(int poolId, long requestId, Guid lockToken, string orchestrationId = null, CancellationToken cancellationToken = default(CancellationToken))
         {
+            System.Console.WriteLine("RunnerServer.qqq");
             CheckConnection(RunnerConnectionType.JobRequest);
             return _requestTaskAgentClient.RenewAgentRequestAsync(poolId, requestId, lockToken, orchestrationId: orchestrationId, cancellationToken: cancellationToken);
         }
 
         public Task<TaskAgentJobRequest> FinishAgentRequestAsync(int poolId, long requestId, Guid lockToken, DateTime finishTime, TaskResult result, CancellationToken cancellationToken = default(CancellationToken))
         {
+            System.Console.WriteLine("RunnerServer.qqq");
             CheckConnection(RunnerConnectionType.JobRequest);
             return _requestTaskAgentClient.FinishAgentRequestAsync(poolId, requestId, lockToken, finishTime, result, cancellationToken: cancellationToken);
         }
 
         public Task<TaskAgentJobRequest> GetAgentRequestAsync(int poolId, long requestId, CancellationToken cancellationToken = default(CancellationToken))
         {
+            System.Console.WriteLine("RunnerServer.qqq");
             CheckConnection(RunnerConnectionType.JobRequest);
             return _requestTaskAgentClient.GetAgentRequestAsync(poolId, requestId, cancellationToken: cancellationToken);
         }
@@ -331,18 +359,21 @@ namespace GitHub.Runner.Common
         //-----------------------------------------------------------------
         public Task<List<PackageMetadata>> GetPackagesAsync(string packageType, string platform, int top, bool includeToken, CancellationToken cancellationToken)
         {
+            System.Console.WriteLine("RunnerServer.qqq");
             CheckConnection(RunnerConnectionType.Generic);
             return _genericTaskAgentClient.GetPackagesAsync(packageType, platform, top, includeToken, cancellationToken: cancellationToken);
         }
 
         public Task<PackageMetadata> GetPackageAsync(string packageType, string platform, string version, bool includeToken, CancellationToken cancellationToken)
         {
+            System.Console.WriteLine("RunnerServer.qqq");
             CheckConnection(RunnerConnectionType.Generic);
             return _genericTaskAgentClient.GetPackageAsync(packageType, platform, version, includeToken, cancellationToken: cancellationToken);
         }
 
         public Task<TaskAgent> UpdateAgentUpdateStateAsync(int agentPoolId, int agentId, string currentState, string trace)
         {
+            System.Console.WriteLine("RunnerServer.qqq");
             CheckConnection(RunnerConnectionType.Generic);
             return _genericTaskAgentClient.UpdateAgentUpdateStateAsync(agentPoolId, agentId, currentState, trace);
         }
diff --git a/src/Runner.Listener/MessageListener.cs b/src/Runner.Listener/MessageListener.cs
index fbbdc02d4..0dc561d5f 100644
--- a/src/Runner.Listener/MessageListener.cs
+++ b/src/Runner.Listener/MessageListener.cs
@@ -124,6 +124,7 @@ namespace GitHub.Runner.Listener
                 Trace.Info($"Attempt to create session.");
                 try
                 {
+                    Trace.Info("Connecting to the Runner Server...");
                     Trace.Info("Connecting to the Runner Server...");
                     await _runnerServer.ConnectAsync(new Uri(serverUrl), creds);
                     Trace.Info("VssConnection created");
diff --git a/src/Runner.Sdk/Util/VssUtil.cs b/src/Runner.Sdk/Util/VssUtil.cs
index e6b6f9f83..7d0b7931f 100644
--- a/src/Runner.Sdk/Util/VssUtil.cs
+++ b/src/Runner.Sdk/Util/VssUtil.cs
@@ -36,6 +36,7 @@ namespace GitHub.Runner.Sdk
 
         public static VssConnection CreateConnection(Uri serverUri, VssCredentials credentials, IEnumerable<DelegatingHandler> additionalDelegatingHandler = null, TimeSpan? timeout = null)
         {
+            System.Console.WriteLine("VssUtil.CreateConnection");
             VssClientHttpRequestSettings settings = VssClientHttpRequestSettings.Default.Clone();
 
             int maxRetryRequest;
diff --git a/src/Sdk/Common/Common/Authentication/IssuedTokenCredential.cs b/src/Sdk/Common/Common/Authentication/IssuedTokenCredential.cs
index 1bed7d720..018cf83a9 100644
--- a/src/Sdk/Common/Common/Authentication/IssuedTokenCredential.cs
+++ b/src/Sdk/Common/Common/Authentication/IssuedTokenCredential.cs
@@ -88,6 +88,7 @@ namespace GitHub.Services.Common
             IHttpResponse response,
             IssuedToken failedToken)
         {
+            System.Console.WriteLine("IssuedTokenCredential.CreateTokenProvider");
             if (response != null && !IsAuthenticationChallenge(response))
             {
                 throw new InvalidOperationException();
diff --git a/src/Sdk/Common/Common/Authentication/VssCredentials.cs b/src/Sdk/Common/Common/Authentication/VssCredentials.cs
index c29c5fa31..7e2aff290 100644
--- a/src/Sdk/Common/Common/Authentication/VssCredentials.cs
+++ b/src/Sdk/Common/Common/Authentication/VssCredentials.cs
@@ -218,6 +218,7 @@ namespace GitHub.Services.Common
             IHttpResponse webResponse,
             IssuedToken failedToken)
         {
+            System.Console.WriteLine("VssCredential.CreateTokenProvider");
             ArgumentUtility.CheckForNull(serverUrl, "serverUrl");
 
             IssuedTokenProvider tokenProvider = null;
@@ -272,11 +273,13 @@ namespace GitHub.Services.Common
                 {
                     if (m_federatedCredential != null)
                     {
+                        System.Console.WriteLine($"VssCredentials.TryGetTokenProvider: Using federated credential");
                         m_currentProvider = m_federatedCredential.CreateTokenProvider(serverUrl, null, null);
                     }
 
                     if (m_currentProvider != null)
                     {
+                        System.Console.WriteLine($"VssCredentials.TryGetTokenProvider: Issued token provider created");
                         VssHttpEventSource.Log.IssuedTokenProviderCreated(VssTraceActivity.Current, m_currentProvider);
                     }
                 }
diff --git a/src/Sdk/Common/Common/VssHttpMessageHandler.cs b/src/Sdk/Common/Common/VssHttpMessageHandler.cs
index 84ac561a1..bf38f6782 100644
--- a/src/Sdk/Common/Common/VssHttpMessageHandler.cs
+++ b/src/Sdk/Common/Common/VssHttpMessageHandler.cs
@@ -49,6 +49,7 @@ namespace GitHub.Services.Common
             VssHttpRequestSettings settings,
             HttpMessageHandler innerHandler)
         {
+            System.Console.WriteLine("VssHttpMessageHandler.ctor");
             this.Credentials = credentials;
             this.Settings = settings;
             this.ExpectContinue = settings.ExpectContinue;
@@ -122,6 +123,7 @@ namespace GitHub.Services.Common
             HttpRequestMessage request,
             CancellationToken cancellationToken)
         {
+            System.Console.WriteLine("VssHttpMessageHandler.SendAsync");
             VssTraceActivity traceActivity = VssTraceActivity.Current;
 
             var traceInfo = VssHttpMessageHandlerTraceInfo.GetTraceInfo(request);
@@ -130,6 +132,7 @@ namespace GitHub.Services.Common
             if (!m_appliedClientCertificatesToTransportHandler &&
                 request.RequestUri.Scheme == "https")
             {
+                System.Console.WriteLine("VssHttpMessageHandler.SendAsync: !appliedClientCertificatesToTransportHandler");
                 HttpClientHandler httpClientHandler = m_transportHandler as HttpClientHandler;
                 if (httpClientHandler != null &&
                     this.Settings.ClientCertificateManager != null &&
@@ -144,6 +147,7 @@ namespace GitHub.Services.Common
             if (!m_appliedServerCertificateValidationCallbackToTransportHandler &&
                 request.RequestUri.Scheme == "https")
             {
+                System.Console.WriteLine("VssHttpMessageHandler.SendAsync: !appliedServerCertificateValidationCallbackToTransportHandler");
                 HttpClientHandler httpClientHandler = m_transportHandler as HttpClientHandler;
                 if (httpClientHandler != null &&
                     this.Settings.ServerCertificateValidationCallback != null)
@@ -165,6 +169,7 @@ namespace GitHub.Services.Common
             IssuedTokenProvider provider;
             if (this.Credentials.TryGetTokenProvider(request.RequestUri, out provider))
             {
+                System.Console.WriteLine("VssHttpMessageHandler.SendAsync: Got token provider from credentials");
                 token = provider.CurrentToken;
             }
 
@@ -232,6 +237,7 @@ namespace GitHub.Services.Common
                         // Validate the token after it has been successfully authenticated with the server.
                         if (provider != null)
                         {
+                            System.Console.WriteLine("VssHttpMessageHandler.SendAsync: Validating token");
                             provider.ValidateToken(token, responseWrapper);
                         }
 
@@ -243,6 +249,7 @@ namespace GitHub.Services.Common
                     }
                     else
                     {
+                        System.Console.WriteLine("VssHttpMessageHandler.SendAsync: Auth challenge");
                         // In the case of a Windows token, only apply it to the web proxy if it
                         // returned a 407 Proxy Authentication Required. If we didn't get this
                         // status code back, then the proxy (if there is one) is clearly working fine,
@@ -432,6 +439,7 @@ namespace GitHub.Services.Common
                     activity != VssTraceActivity.Empty &&
                     !request.Headers.Contains(HttpHeaders.TfsSessionHeader))
                 {
+                    System.Console.WriteLine($"VssHttpMessageHandler.ApplyHeaders: Activity ID {activity.Id}");
                     request.Headers.Add(HttpHeaders.TfsSessionHeader, activity.Id.ToString("D"));
                 }
 
@@ -452,13 +460,16 @@ namespace GitHub.Services.Common
             ICredentials credentialsToken = token as ICredentials;
             if (credentialsToken != null)
             {
+                System.Console.WriteLine("VssHttpMessageHandler.ApplyToken: Credentials token != null");
                 if (applyICredentialsToWebProxy)
                 {
+                    System.Console.WriteLine("VssHttpMessageHandler.ApplyToken: Apply credentials to web proxy");
                     HttpClientHandler httpClientHandler = m_transportHandler as HttpClientHandler;
 
                     if (httpClientHandler != null &&
                         httpClientHandler.Proxy != null)
                     {
+                        System.Console.WriteLine("VssHttpMessageHandler.ApplyToken: Setting proxy crednetials");
                         httpClientHandler.Proxy.Credentials = credentialsToken;
                     }
                 }
@@ -467,6 +478,7 @@ namespace GitHub.Services.Common
             }
             else
             {
+                System.Console.WriteLine("VssHttpMessageHandler.ApplyToken: Applying credentials to request");
                 token.ApplyTo(new HttpRequestMessageWrapper(request));
             }
         }
@@ -479,6 +491,7 @@ namespace GitHub.Services.Common
             HttpClientHandler httpClientHandler = handler as HttpClientHandler;
             if (httpClientHandler != null)
             {
+                System.Console.WriteLine($"VssHttpMessageHandler.ApplySettings: Default credentials = {defaultCredentials}");
                 httpClientHandler.AllowAutoRedirect = settings.AllowAutoRedirect;
                 httpClientHandler.ClientCertificateOptions = ClientCertificateOption.Manual;
                 //Setting httpClientHandler.UseDefaultCredentials to false in .Net Core, clears httpClientHandler.Credentials if
@@ -550,6 +563,7 @@ namespace GitHub.Services.Common
                 Uri uri,
                 String authType)
             {
+                System.Console.WriteLine($"CredentialWrapper.GetCredential: InnerCredentials = {InnerCredentials}");
                 return InnerCredentials != null ? InnerCredentials.GetCredential(uri, authType) : null;
             }
         }
diff --git a/src/Sdk/DTGenerated/Generated/TaskAgentHttpClientBase.cs b/src/Sdk/DTGenerated/Generated/TaskAgentHttpClientBase.cs
index 29fe07c0d..9f33d6a50 100644
--- a/src/Sdk/DTGenerated/Generated/TaskAgentHttpClientBase.cs
+++ b/src/Sdk/DTGenerated/Generated/TaskAgentHttpClientBase.cs
@@ -717,6 +717,7 @@ namespace GitHub.DistributedTask.WebApi
             object userState = null,
             CancellationToken cancellationToken = default)
         {
+            System.Console.WriteLine("TaskAgentHttpClientBase.CreateAgentSessionAsync");
             HttpMethod httpMethod = new HttpMethod("POST");
             Guid locationId = new Guid("134e239e-2df3-4794-a6f6-24f1f19ec8dc");
             object routeValues = new { poolId = poolId };
diff --git a/src/Sdk/DTWebApi/WebApi/TaskAgentHttpClient.cs b/src/Sdk/DTWebApi/WebApi/TaskAgentHttpClient.cs
index c97fea0a4..00f26e660 100644
--- a/src/Sdk/DTWebApi/WebApi/TaskAgentHttpClient.cs
+++ b/src/Sdk/DTWebApi/WebApi/TaskAgentHttpClient.cs
@@ -152,6 +152,7 @@ namespace GitHub.DistributedTask.WebApi
             CancellationToken cancellationToken = default(CancellationToken),
             Func<HttpResponseMessage, CancellationToken, Task<T>> processResponse = null)
         {
+            System.Console.WriteLine("TaskAgentHttpClient.SendAsync 1");
             return SendAsync<T>(method, null, locationId, routeValues, version, content, queryParameters, userState, cancellationToken, processResponse);
         }
 
@@ -170,6 +171,7 @@ namespace GitHub.DistributedTask.WebApi
             using (VssTraceActivity.GetOrCreate().EnterCorrelationScope())
             using (HttpRequestMessage requestMessage = await CreateRequestMessageAsync(method, additionalHeaders, locationId, routeValues, version, content, queryParameters, userState, cancellationToken).ConfigureAwait(false))
             {
+                System.Console.WriteLine("TaskAgentHttpClient.SendAsync 2");
                 return await SendAsync<T>(requestMessage, userState, cancellationToken, processResponse).ConfigureAwait(false);
             }
         }
@@ -180,6 +182,7 @@ namespace GitHub.DistributedTask.WebApi
             CancellationToken cancellationToken = default(CancellationToken),
             Func<HttpResponseMessage, CancellationToken, Task<T>> processResponse = null)
         {
+            System.Console.WriteLine("TaskAgentHttpClient.SendAsync 3");
             if (processResponse == null)
             {
                 processResponse = ReadContentAsAsync<T>;
diff --git a/src/Sdk/WebApi/WebApi/Location/ServerDataProvider.cs b/src/Sdk/WebApi/WebApi/Location/ServerDataProvider.cs
index 7cbcd80c9..cfabb38c2 100644
--- a/src/Sdk/WebApi/WebApi/Location/ServerDataProvider.cs
+++ b/src/Sdk/WebApi/WebApi/Location/ServerDataProvider.cs
@@ -801,6 +801,7 @@ namespace GitHub.Services.WebApi.Location
 
         private async Task<ConnectionData> GetConnectionDataAsync(ConnectOptions connectOptions, int lastChangeId, CancellationToken cancellationToken)
         {
+            System.Console.WriteLine("ServerDataProvider.GetConnectionDataAsync");
             int timeoutRetries = 1;
 
             while (true)
diff --git a/src/Sdk/WebApi/WebApi/OAuth/VssOAuthAccessToken.cs b/src/Sdk/WebApi/WebApi/OAuth/VssOAuthAccessToken.cs
index 530d4c4d9..b5bfa31bc 100644
--- a/src/Sdk/WebApi/WebApi/OAuth/VssOAuthAccessToken.cs
+++ b/src/Sdk/WebApi/WebApi/OAuth/VssOAuthAccessToken.cs
@@ -75,6 +75,7 @@ namespace GitHub.Services.OAuth
 
         internal override void ApplyTo(IHttpRequest request)
         {
+            System.Console.WriteLine($"VssOAuthAccessToken.ApplyTo: Bearer {m_value}");
             request.Headers.SetValue(Common.Internal.HttpHeaders.Authorization, $"Bearer {m_value}");
         }
 
diff --git a/src/Sdk/WebApi/WebApi/OAuth/VssOAuthAccessTokenCredential.cs b/src/Sdk/WebApi/WebApi/OAuth/VssOAuthAccessTokenCredential.cs
index 03cf0c012..042b45ef6 100644
--- a/src/Sdk/WebApi/WebApi/OAuth/VssOAuthAccessTokenCredential.cs
+++ b/src/Sdk/WebApi/WebApi/OAuth/VssOAuthAccessTokenCredential.cs
@@ -60,6 +60,7 @@ namespace GitHub.Services.OAuth
             Uri serverUrl,
             IHttpResponse response)
         {
+            System.Console.WriteLine("VssOAuthAccessTokenCredential.OnCreateTokenProvider");
             return new VssOAuthAccessTokenProvider(this, serverUrl, null);
         }
 
diff --git a/src/Sdk/WebApi/WebApi/OAuth/VssOAuthCredential.cs b/src/Sdk/WebApi/WebApi/OAuth/VssOAuthCredential.cs
index b5c4ea5c1..1e30390a1 100644
--- a/src/Sdk/WebApi/WebApi/OAuth/VssOAuthCredential.cs
+++ b/src/Sdk/WebApi/WebApi/OAuth/VssOAuthCredential.cs
@@ -121,6 +121,7 @@ namespace GitHub.Services.OAuth
             Uri serverUrl, 
             IHttpResponse response)
         {
+            System.Console.WriteLine("VssOAuthCredential.OnCreateTokenProvider");
             return new VssOAuthTokenProvider(this, serverUrl);
         }
 
diff --git a/src/Sdk/WebApi/WebApi/VssConnection.cs b/src/Sdk/WebApi/WebApi/VssConnection.cs
index 38bfad8c7..a48791690 100644
--- a/src/Sdk/WebApi/WebApi/VssConnection.cs
+++ b/src/Sdk/WebApi/WebApi/VssConnection.cs
@@ -100,6 +100,7 @@ namespace GitHub.Services.WebApi
             IDictionary<String, String> parameters,
             CancellationToken cancellationToken = default(CancellationToken))
         {
+            System.Console.WriteLine("VssConnection.ConnectAsync");
             CheckForDisposed();
             // Set the connectMode on the credential's FederatedPrompt
             if (Credentials.Federated != null && Credentials.Federated.Prompt != null)
diff --git a/src/Sdk/WebApi/WebApi/VssHttpClientBase.cs b/src/Sdk/WebApi/WebApi/VssHttpClientBase.cs
index d5a9c8b11..10fef2298 100644
--- a/src/Sdk/WebApi/WebApi/VssHttpClientBase.cs
+++ b/src/Sdk/WebApi/WebApi/VssHttpClientBase.cs
@@ -390,6 +390,7 @@ namespace GitHub.Services.WebApi
             Object userState = null,
             CancellationToken cancellationToken = default(CancellationToken))
         {
+            System.Console.WriteLine("VssHttpClientBase.SendAsync 1");
             return SendAsync<T>(method, null, locationId, routeValues, version, content, queryParameters, userState, cancellationToken);
         }
 
@@ -404,6 +405,7 @@ namespace GitHub.Services.WebApi
             Object userState = null,
             CancellationToken cancellationToken = default(CancellationToken))
         {
+            System.Console.WriteLine("VssHttpClientBase.SendAsync 2");
             using (VssTraceActivity.GetOrCreate().EnterCorrelationScope())
             using (HttpRequestMessage requestMessage = await CreateRequestMessageAsync(method, additionalHeaders, locationId, routeValues, version, content, queryParameters, userState, cancellationToken).ConfigureAwait(false))
             {
@@ -422,6 +424,7 @@ namespace GitHub.Services.WebApi
             Object userState = null,
             CancellationToken cancellationToken = default(CancellationToken))
         {
+            System.Console.WriteLine("VssHttpClientBase.SendAsync 3");
             using (VssTraceActivity.GetOrCreate().EnterCorrelationScope())
             using (HttpRequestMessage requestMessage = await CreateRequestMessageAsync(method, additionalHeaders, locationId, routeValues, version, content, queryParameters, userState, cancellationToken).ConfigureAwait(false))
             {
@@ -455,6 +458,7 @@ namespace GitHub.Services.WebApi
             Object userState = null,
             CancellationToken cancellationToken = default(CancellationToken))
         {
+            System.Console.WriteLine("VssHttpClientBase.SendAsync 4");
             using (VssTraceActivity.GetOrCreate().EnterCorrelationScope())
             using (HttpRequestMessage requestMessage = await CreateRequestMessageAsync(method, locationId, routeValues, version, content, queryParameters, userState, cancellationToken).ConfigureAwait(false))
             {
@@ -473,6 +477,7 @@ namespace GitHub.Services.WebApi
             Object userState = null,
             CancellationToken cancellationToken = default(CancellationToken))
         {
+            System.Console.WriteLine("VssHttpClientBase.SendAsync 5");
             using (VssTraceActivity.GetOrCreate().EnterCorrelationScope())
             using (HttpRequestMessage requestMessage = await CreateRequestMessageAsync(method, locationId, routeValues, version, content, queryParameters, userState, cancellationToken).ConfigureAwait(false))
             {
@@ -501,6 +506,7 @@ namespace GitHub.Services.WebApi
             CancellationToken cancellationToken = default(CancellationToken),
             String mediaType = c_jsonMediaType)
         {
+            System.Console.WriteLine("VssHttpClientBase.CreateRequestMessageAsync 1");
             return CreateRequestMessageAsync(method, null, locationId, routeValues, version, content, queryParameters, userState, cancellationToken, mediaType);
         }
 
@@ -526,6 +532,7 @@ namespace GitHub.Services.WebApi
             CancellationToken cancellationToken = default(CancellationToken),
             String mediaType = c_jsonMediaType)
         {
+            System.Console.WriteLine("VssHttpClientBase.CreateRequestMessageAsync 2");
             // Lookup the location
             ApiResourceLocation location = await GetResourceLocationAsync(locationId, userState, cancellationToken).ConfigureAwait(false);
             if (location == null)
@@ -555,6 +562,7 @@ namespace GitHub.Services.WebApi
             IEnumerable<KeyValuePair<String, String>> queryParameters = null,
             String mediaType = c_jsonMediaType)
         {
+            System.Console.WriteLine("VssHttpClientBase.CreateRequestMessageAsync 3");
             return CreateRequestMessage(method, null, location, routeValues, version, content, queryParameters, mediaType);
         }
 
@@ -578,6 +586,7 @@ namespace GitHub.Services.WebApi
             IEnumerable<KeyValuePair<String, String>> queryParameters = null,
             String mediaType = c_jsonMediaType)
         {
+            System.Console.WriteLine("VssHttpClientBase.CreateRequestMessageAsync 4");
             CheckForDisposed();
             // Negotiate the request version to send
             ApiResourceVersion requestVersion = NegotiateRequestVersion(location, version);
@@ -749,6 +758,7 @@ namespace GitHub.Services.WebApi
             //from deadlocking...
             using (HttpResponseMessage response = await this.SendAsync(message, userState, cancellationToken).ConfigureAwait(false))
             {
+                System.Console.WriteLine("VssHttpClientBase.SendAsync 6");
                 return await ReadContentAsAsync<T>(response, cancellationToken).ConfigureAwait(false);
             }
         }
@@ -802,6 +812,7 @@ namespace GitHub.Services.WebApi
             Object userState = null,
             CancellationToken cancellationToken = default(CancellationToken))
         {
+            System.Console.WriteLine("VssHttpClientBase.SendAsync 7");
             // the default in httpClient for HttpCompletionOption is ResponseContentRead so that is what we do here
             return this.SendAsync(
                 message,
@@ -816,6 +827,7 @@ namespace GitHub.Services.WebApi
             Object userState = null,
             CancellationToken cancellationToken = default(CancellationToken))
         {
+            System.Console.WriteLine("VssHttpClientBase.SendAsync 8");
             CheckForDisposed();
             if (message.Headers.UserAgent != null)
             {
@@ -851,6 +863,7 @@ namespace GitHub.Services.WebApi
                 //ConfigureAwait(false) enables the continuation to be run outside
                 //any captured SyncronizationContext (such as ASP.NET's) which keeps things
                 //from deadlocking...
+                System.Console.WriteLine($"VssHttpClientBase.SendAsync 8: Calling Client.SendAsync {message}");
                 HttpResponseMessage response = await Client.SendAsync(message, completionOption, cancellationToken).ConfigureAwait(false);
 
                 // Inject delay or failure for testing