Make DefaultHttpClientFactory singleton ready, by supporting named clients + Disable content buffering by default in HttpRequestTracer

Author: C0nquistadore

src/Dibix.Http.Client/Client/DefaultHttpClientFactory.cs

@@ -15,14 +15,14 @@ public BearerAuthorizationHttpMessageHandler() { }
 
         protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
         {
-            string token = await this.GetToken().ConfigureAwait(false);
+            string token = await this.GetToken(request).ConfigureAwait(false);
             if (String.IsNullOrEmpty(token))
                 throw new InvalidOperationException("Bearer token is empty");
 
             request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", token);
             return await base.SendAsync(request, cancellationToken).ConfigureAwait(false);
         }
 
-        protected virtual Task<string> GetToken() => Task.FromResult(this._token);
+        protected virtual Task<string> GetToken(HttpRequestMessage requestMessage) => Task.FromResult(this._token);
     }
 }

src/Dibix.Http.Client/Client/Handlers/BearerAuthorizationHttpMessageHandler.cs

@@ -47,9 +47,9 @@ protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage
         #endregion
 
         #region Private Methods
-        private Task TraceRequest(HttpRequestMessage request) => this._tracer.TraceRequestAsync(request);
+        private Task TraceRequest(HttpRequestMessage request) => this._tracer.TraceRequestMessageAsync(request);
 
-        private Task TraceResponse(HttpResponseMessage response) => this._tracer.TraceResponseAsync(response, this._requestDurationTracker.Elapsed);
+        private Task TraceResponse(HttpResponseMessage response) => this._tracer.TraceResponseMessageAsync(response, this._requestDurationTracker.Elapsed);
 
         private void StartTracking() => this._requestDurationTracker.Restart();
 

src/Dibix.Http.Client/Client/Handlers/TracingHttpMessageHandler.cs

@@ -0,0 +1,9 @@
+namespace Dibix.Http.Client
+{
+    public abstract class HttpClientConfiguration
+    {
+        public abstract string Name { get; }
+
+        public abstract void Configure(IHttpClientBuilder builder);
+    }
+}

src/Dibix.Http.Client/Client/HttpClientConfiguration.cs

@@ -7,7 +7,6 @@
 using System.Net.Http.Headers;
 using System.Text;
 using System.Text.RegularExpressions;
-using System.Threading.Tasks;
 
 namespace Dibix.Http.Client
 {
@@ -40,14 +39,6 @@ public static string Format(string formattedRequestText, string formattedRespons
         #endregion
 
         #region Internal Methods
-        internal static async Task<string> Format(HttpRequestMessage requestMessage, bool maskSensitiveData)
-        {
-            string requestMessageContent = null;
-            if (requestMessage.Content != null)
-                requestMessageContent = await requestMessage.Content.ReadAsStringAsync().ConfigureAwait(false);
-
-            return Format(requestMessage, requestMessageContent, maskSensitiveData);
-        }
         internal static string Format(HttpRequestMessage requestMessage, string requestContentText, bool maskSensitiveData)
         {
             Guard.IsNotNull(requestMessage, nameof(requestMessage));
@@ -81,11 +72,6 @@ internal static string Format(HttpRequestMessage requestMessage, string requestC
             return formattedRequest;
         }
 
-        internal static async Task<string> Format(HttpResponseMessage responseMessage)
-        {
-            string responseContentText = await responseMessage.Content.ReadAsStringAsync().ConfigureAwait(false);
-            return Format(responseMessage, responseContentText);
-        }
         internal static string Format(HttpResponseMessage responseMessage, string responseContentText)
         {
             Guard.IsNotNull(responseMessage, nameof(responseMessage));

src/Dibix.Http.Client/Client/HttpMessageFormatter.cs

@@ -6,47 +6,99 @@ namespace Dibix.Http.Client
 {
     public class HttpRequestTracer
     {
-        public bool MaskSensitiveData { get; set; } = true;
+        public bool MaskSensitiveContent { get; } = true;
         public HttpRequestTrace LastRequest { get; private set; }
 
-        internal async Task TraceRequestAsync(HttpRequestMessage requestMessage)
+        public HttpRequestTracer() { }
+        public HttpRequestTracer(bool maskSensitiveContent)
         {
-            string requestContentText = await this.GetRequestContentTextAsync(requestMessage).ConfigureAwait(false);
-            string formattedRequestText = this.FormatRequest(requestMessage, requestContentText);
-            await this.TraceRequestAsync(requestMessage, formattedRequestText).ConfigureAwait(false);
+            this.MaskSensitiveContent = maskSensitiveContent;
+        }
+
+        internal async Task TraceRequestMessageAsync(HttpRequestMessage requestMessage)
+        {
+            await this.CollectLastRequest(requestMessage).ConfigureAwait(false);
+            await this.TraceRequestAsync(requestMessage).ConfigureAwait(false);
         }
 
-        internal async Task TraceResponseAsync(HttpResponseMessage responseMessage, TimeSpan duration)
+        internal async Task TraceResponseMessageAsync(HttpResponseMessage responseMessage, TimeSpan duration)
         {
-            string responseContentTest = await this.GetResponseContentTextAsync(responseMessage).ConfigureAwait(false);
-            string formattedResponseText = this.FormatResponse(responseMessage, responseContentTest);
-            await this.TraceResponseAsync(responseMessage, formattedResponseText, duration).ConfigureAwait(false);
+            await CompleteLastRequest(responseMessage, duration).ConfigureAwait(false);
+            await this.TraceResponseAsync(responseMessage, duration);
         }
 
-        protected virtual Task TraceRequestAsync(HttpRequestMessage requestMessage, string formattedRequestText)
+        protected virtual Task TraceRequestAsync(HttpRequestMessage requestMessage) => Task.CompletedTask;
+
+        protected virtual Task TraceResponseAsync(HttpResponseMessage responseMessage, TimeSpan duration) => Task.CompletedTask;
+
+        protected virtual bool ShouldBufferRequestContent(HttpRequestMessage requestMessage) => false;
+
+        protected virtual bool ShouldBufferResponseContent(HttpRequestMessage requestMessage) => false;
+
+        private async Task CollectLastRequest(HttpRequestMessage requestMessage)
         {
+            string formattedRequestText = await this.GetFormattedRequestContent(requestMessage).ConfigureAwait(false);
             this.LastRequest = new HttpRequestTrace(requestMessage, formattedRequestText);
-            return Task.CompletedTask;
         }
 
-        protected virtual Task TraceResponseAsync(HttpResponseMessage responseMessage, string formattedResponseText, TimeSpan duration)
+        private async Task CompleteLastRequest(HttpResponseMessage responseMessage, TimeSpan duration)
         {
             if (this.LastRequest == null)
                 throw new InvalidOperationException("Request not initialized");
 
+            string formattedResponseText = await this.GetFormattedResponseContent(responseMessage).ConfigureAwait(false);
             this.LastRequest.ResponseMessage = responseMessage;
             this.LastRequest.FormattedResponseText = formattedResponseText;
             this.LastRequest.Duration = duration;
-            
-            return Task.CompletedTask;
+
+            // Since non successful status code will throw an exception,
+            // it is now safe to restore the request content, that was not previously captured
+            HttpRequestMessage requestMessage = responseMessage.RequestMessage;
+            if (!this.ShouldBufferRequestContent(requestMessage) && !responseMessage.IsSuccessStatusCode)
+            {
+                string requestContentText = await GetRequestContentTextAsync(requestMessage, bufferRequestContent: true).ConfigureAwait(false);
+                this.LastRequest.FormattedRequestText = this.FormatRequest(requestMessage, requestContentText);
+            }
+        }
+
+        private async Task<string> GetFormattedRequestContent(HttpRequestMessage requestMessage)
+        {
+            bool bufferRequestContent = this.ShouldBufferRequestContent(requestMessage);
+            string requestContentText = await GetRequestContentTextAsync(requestMessage, bufferRequestContent).ConfigureAwait(false);
+            string formattedRequestText = this.FormatRequest(requestMessage, requestContentText);
+            return formattedRequestText;
+        }
+
+        private async Task<string> GetFormattedResponseContent(HttpResponseMessage responseMessage)
+        {
+            bool bufferResponseContent = this.ShouldBufferResponseContent(responseMessage.RequestMessage) || !responseMessage.IsSuccessStatusCode;
+            string responseContentTest = await GetResponseContentTextAsync(responseMessage, bufferResponseContent).ConfigureAwait(false);
+            string formattedResponseText = HttpMessageFormatter.Format(responseMessage, responseContentTest);
+            return formattedResponseText;
+        }
+
+        private string FormatRequest(HttpRequestMessage requestMessage, string requestContentText) => HttpMessageFormatter.Format(requestMessage, requestContentText, this.MaskSensitiveContent);
+
+        private static async Task<string> GetRequestContentTextAsync(HttpRequestMessage requestMessage, bool bufferRequestContent)
+        {
+            if (requestMessage.Content == null)
+                return null;
+
+            if (!bufferRequestContent)
+                return "<Request content unavailable>";
+
+            return await requestMessage.Content.ReadAsStringAsync().ConfigureAwait(false);
         }
 
-        protected virtual string FormatRequest(HttpRequestMessage requestMessage, string requestContentText) => HttpMessageFormatter.Format(requestMessage, requestContentText, this.MaskSensitiveData);
+        private static async Task<string> GetResponseContentTextAsync(HttpResponseMessage responseMessage, bool bufferResponseContent)
+        {
+            if (responseMessage.Content == null)
+                return null;
 
-        protected virtual string FormatResponse(HttpResponseMessage responseMessage, string responseContentTest) => HttpMessageFormatter.Format(responseMessage, responseContentTest);
+            if (!bufferResponseContent)
+                return "<Response content unavailable>";
 
-        protected virtual async Task<string> GetRequestContentTextAsync(HttpRequestMessage requestMessage) => requestMessage.Content != null ? await requestMessage.Content.ReadAsStringAsync().ConfigureAwait(false) : null;
-        
-        protected virtual Task<string> GetResponseContentTextAsync(HttpResponseMessage responseMessage) => responseMessage.Content.ReadAsStringAsync();
+            return await responseMessage.Content.ReadAsStringAsync().ConfigureAwait(false);
+        }
     }
 }

src/Dibix.Http.Client/Client/HttpRequestTracer.cs

@@ -5,13 +5,16 @@ namespace Dibix.Http.Client
 {
     public interface IHttpClientBuilder
     {
+        bool EnsureSuccessStatusCode { get; set; }
+        bool FollowRedirectsGetRequests { get; set; }
+        bool WrapTimeoutsInException { get; set; }
+        bool TraceProxy { get; set; }
+        HttpRequestTracer Tracer { get; set; }
+
         IHttpClientBuilder ConfigureClient(Action<HttpClient> configure);
-        IHttpClientBuilder ConfigurePrimaryHttpMessageHandler<THandler>() where THandler : HttpMessageHandler, new();
-        IHttpClientBuilder ConfigurePrimaryHttpMessageHandler<THandler>(THandler handler) where THandler : HttpMessageHandler;
         IHttpClientBuilder AddHttpMessageHandler<THandler>() where THandler : DelegatingHandler, new();
-        IHttpClientBuilder AddHttpMessageHandler(DelegatingHandler handler);
-        IHttpClientBuilder RemoveHttpMessageHandler<THandler>() where THandler : DelegatingHandler;
-        IHttpClientBuilder RemoveHttpMessageHandler(DelegatingHandler handler);
-        IHttpClientBuilder ClearHttpMessageHandlers();
+        IHttpClientBuilder AddHttpMessageHandler(Func<DelegatingHandler> handlerFactory);
+        IHttpClientBuilder ConfigurePrimaryHttpMessageHandler<THandler>() where THandler : HttpMessageHandler, new();
+        IHttpClientBuilder ConfigurePrimaryHttpMessageHandler<THandler>(Func<THandler> handlerFactory) where THandler : HttpMessageHandler;
     }
 }

src/Dibix.Http.Client/Client/IHttpClientBuilder.cs

@@ -6,6 +6,8 @@ namespace Dibix.Http.Client
     public interface IHttpClientFactory
     {
         HttpClient CreateClient();
+        HttpClient CreateClient(string name);
         HttpClient CreateClient(Uri baseAddress);
+        HttpClient CreateClient(string name, Uri baseAddress);
     }
 }

src/Dibix.Http.Client/Client/IHttpClientFactory.cs

@@ -7,6 +7,7 @@
   <ItemGroup>
     <Compile Include="..\..\shared\Guard.cs" Link="Diagnostics\Guard.cs" />
     <Compile Include="..\..\shared\KnownHeaders.cs" Link="Client\KnownHeaders.cs" />
+    <Compile Include="..\..\shared\Extensions\CollectionExtensions.cs" Link="Extensions\CollectionExtensions.cs" />
   </ItemGroup>
 
   <ItemGroup>

src/Dibix.Http.Client/Dibix.Http.Client.csproj

@@ -1,4 +1,5 @@
 <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:String x:Key="/Default/CodeInspection/CSharpLanguageProject/LanguageLevel/@EntryValue">CSharp80</s:String>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=client/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=client_005Chandlers/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=description/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>