Changed log messages to be a bit more descriptive

src/Ocelot/Errors/Middleware/ExceptionHandlerMiddleware.cs

@@ -6,6 +6,9 @@ using Ocelot.Logging;
 
 namespace Ocelot.Errors.Middleware
 {
+    /// <summary>
+    /// Catches all unhandled exceptions thrown by middleware, logs and returns a 500
+    /// </summary>
     public class ExceptionHandlerMiddleware 
     {
         private readonly RequestDelegate _next;

src/Ocelot/Responder/Middleware/ResponderMiddleware.cs

@@ -1,73 +1,73 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
-using System.Threading.Tasks;
+using System.Threading.Tasks;
-using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Http;
-using Microsoft.Extensions.Logging;
+using Ocelot.Errors;
-using Ocelot.Errors;
+using Ocelot.Infrastructure.RequestData;
-using Ocelot.Infrastructure.RequestData;
+using Ocelot.Logging;
-using Ocelot.Logging;
+using Ocelot.Middleware;
-using Ocelot.Middleware;
+
-
+namespace Ocelot.Responder.Middleware
-namespace Ocelot.Responder.Middleware
+{
-{
+    /// <summary>
-    public class ResponderMiddleware : OcelotMiddleware
+    /// Completes and returns the request and request body, if any pipeline errors occured then sets the appropriate HTTP status code instead.
-    {
+    /// </summary>
-        private readonly RequestDelegate _next;
+    public class ResponderMiddleware : OcelotMiddleware
-        private readonly IHttpResponder _responder;
+    {
-        private readonly IErrorsToHttpStatusCodeMapper _codeMapper;
+        private readonly RequestDelegate _next;
-        private readonly IOcelotLogger _logger;
+        private readonly IHttpResponder _responder;
-
+        private readonly IErrorsToHttpStatusCodeMapper _codeMapper;
-        public ResponderMiddleware(RequestDelegate next, 
+        private readonly IOcelotLogger _logger;
-            IHttpResponder responder,
+
-            IOcelotLoggerFactory loggerFactory,
+        public ResponderMiddleware(RequestDelegate next, 
-            IRequestScopedDataRepository requestScopedDataRepository, 
+            IHttpResponder responder,
-            IErrorsToHttpStatusCodeMapper codeMapper)
+            IOcelotLoggerFactory loggerFactory,
-            :base(requestScopedDataRepository)
+            IRequestScopedDataRepository requestScopedDataRepository, 
-        {
+            IErrorsToHttpStatusCodeMapper codeMapper)
-            _next = next;
+            :base(requestScopedDataRepository)
-            _responder = responder;
+        {
-            _codeMapper = codeMapper;
+            _next = next;
-            _logger = loggerFactory.CreateLogger<ResponderMiddleware>();
+            _responder = responder;
-
+            _codeMapper = codeMapper;
-        }
+            _logger = loggerFactory.CreateLogger<ResponderMiddleware>();
-
+
-        public async Task Invoke(HttpContext context)
+        }
-        {
+
-            _logger.LogDebug("started error responder middleware");
+        public async Task Invoke(HttpContext context)
-
+        {
-            await _next.Invoke(context);
+            _logger.LogDebug($"entered {this.GetType().Name}");
-
+            _logger.LogDebug($"invoking next middleware from {this.GetType().Name}");
-            _logger.LogDebug("calling next middleware");
+
-
+            await _next.Invoke(context);
-            if (PipelineError)
+            
-            {
+            _logger.LogDebug($"returned to {this.GetType().Name} after next middleware completed");
-                _logger.LogDebug("there is a pipeline error, getting errors");
+
-
+            if (PipelineError)
-                var errors = PipelineErrors;
+            {
-
+                var errors = PipelineErrors;
-                _logger.LogDebug("received errors setting error response");
+                _logger.LogDebug($"{errors.Count} pipeline errors found in {this.GetType().Name}. Setting error response status code");
-
+
-                SetErrorResponse(context, errors);
+                SetErrorResponse(context, errors);
-            }
+            }
-            else
+            else
-            {
+            {
-                _logger.LogDebug("no pipeline error, setting response");
+                _logger.LogDebug("no pipeline errors, setting and returning completed response");
-
+                await _responder.SetResponseOnHttpContext(context, HttpResponseMessage);
-                await _responder.SetResponseOnHttpContext(context, HttpResponseMessage);
+            }
-            }
+            _logger.LogDebug($"completed {this.GetType().Name}");
-        }
+        }
-
+
-        private void SetErrorResponse(HttpContext context, List<Error> errors)
+        private void SetErrorResponse(HttpContext context, List<Error> errors)
-        {
+        {
-            var statusCode = _codeMapper.Map(errors);
+            var statusCode = _codeMapper.Map(errors);
-
+
-            if (!statusCode.IsError)
+            if (!statusCode.IsError)
-            {
+            {
-                _responder.SetErrorResponseOnContext(context, statusCode.Data);
+                _responder.SetErrorResponseOnContext(context, statusCode.Data);
-            }
+            }
-            else
+            else
-            {
+            {
-                _responder.SetErrorResponseOnContext(context, 500);
+                _responder.SetErrorResponseOnContext(context, 500);
-            }
+            }
-        }
+        }
-    }
+    }
 }