mark handled concept

Author: Ihar Yakimush

Commmunity.AspNetCore.ExceptionHandling.Integration/Controllers/ValuesController.cs

@@ -21,6 +21,17 @@ public IEnumerable<string> Get()
         [HttpGet("{id}")]
         public string Get(int id)
         {
+
+            if (id > 25)
+            {
+                throw new DuplicateWaitObjectException();
+            }
+
+            if (id > 20)
+            {
+                throw new DuplicateNameException();
+            }
+
             if (id > 15)
             {
                 throw new InvalidConstraintException();

Commmunity.AspNetCore.ExceptionHandling.Integration/Startup.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Data;
 using System.IO;
 using System.Linq;
 using System.Text;
@@ -29,9 +30,13 @@ public void ConfigureServices(IServiceCollection services)
 
             services.AddExceptionHandlingPolicies(options =>
             {
+                options.For<DuplicateNameException>().Retry().NextChain();
+                options.For<DuplicateWaitObjectException>().Retry();
+                
                 options.For<ArgumentOutOfRangeException>().Log().Rethrow();
+                
                 options.For<InvalidCastException>()
-                    .NewResponse(e => 400)
+                    .Response(e => 400)
                     .WithHeaders((h, e) => h["X-qwe"] = e.Message)
                     .WithBody((stream, exception) =>
                     {
@@ -41,18 +46,17 @@ public void ConfigureServices(IServiceCollection services)
                         }                                                
                     })
                     .NextChain();
-                options.For<Exception>().Log(lo =>
-                {
-                    lo.Formatter = (o, e) => "qwe";
-                })
-                    .NewResponse(e => 500, RequestStartedBehaviour.Ignore).WithBody(
+                options.For<Exception>()
+                    .Log(lo => { lo.Formatter = (o, e) => "qwe"; })
+                    .Response(e => 500, RequestStartedBehaviour.SkipHandler).WithBody(
                     async (stream, exception) =>
                     {
                         using (StreamWriter sw = new StreamWriter(stream))
                         {                            
                             await sw.WriteAsync("unhandled exception");
                         }
-                    });
+                    })
+                    .Handled();
             });
 
             services.AddLogging();

Commmunity.AspNetCore.ExceptionHandling/Events.cs

@@ -8,5 +8,9 @@ public static class Events
         public static readonly EventId PolicyNotFound = new EventId(101, "PolicyForExceptionNotRegistered");
         public static readonly EventId HandlersNotFound = new EventId(102, "HandlersCollectionEmpty");
         public static readonly EventId HandlerNotCreated = new EventId(103, "HandlersCanNotBeCreated");
+        public static readonly EventId RetryForStartedResponce = new EventId(104, "RetryForStartedResponce");
+        public static readonly EventId Retry = new EventId(105, "Retry");
+        public static readonly EventId UnhandledResult = new EventId(106, "UnhandledResult");
+        public static readonly EventId RetryIterationExceedLimit = new EventId(107, "RetryIterationExceedLimit");
     }
 }

Commmunity.AspNetCore.ExceptionHandling/ExceptionHandlingPolicyMiddleware.cs

@@ -12,22 +12,22 @@ namespace Commmunity.AspNetCore.ExceptionHandling
 {
     public class ExceptionHandlingPolicyMiddleware : IMiddleware
     {
+        public const int MaxRetryIterations = 10;
+
         private readonly IOptions<ExceptionHandlingPolicyOptions> options;
 
         public ExceptionHandlingPolicyMiddleware(IOptions<ExceptionHandlingPolicyOptions> options)
         {
             this.options = options ?? throw new ArgumentNullException(nameof(options));
         }       
 
-        private static async Task<bool> EnumerateExceptionMapping(
+        private static async Task<HandlerResult> EnumerateExceptionMapping(
             HttpContext context, 
             ExceptionHandlingPolicyOptions policyOptions,
-            Exception exception)
+            Exception exception,
+            ILogger logger)
         {
-            Type exceptionType = exception.GetType();
-
-            ILogger logger = context.RequestServices.GetService<ILogger<ExceptionHandlingPolicyMiddleware>>() ??
-                             NullLoggerFactory.Instance.CreateLogger(Const.Category);
+            Type exceptionType = exception.GetType();            
 
             bool mappingExists = false;
             HandlerResult handleResult = HandlerResult.ReThrow;
@@ -38,12 +38,7 @@ private static async Task<bool> EnumerateExceptionMapping(
                 {
                     mappingExists = true;
                     handleResult = await EnumerateHandlers(context, type, exception, policyOptions, logger);
-
-                    if (handleResult == HandlerResult.ReThrow)
-                    {
-                        return true;
-                    }
-
+                                        
                     if (handleResult != HandlerResult.NextChain)
                     {
                         break;
@@ -57,10 +52,10 @@ private static async Task<bool> EnumerateExceptionMapping(
                     "Handlers mapping for exception type {exceptionType} not exists. Exception will be re-thrown. RequestId: {RequestId}",
                     exceptionType, context.TraceIdentifier);
 
-                return false;
+                return HandlerResult.ReThrow;
             }
 
-            return handleResult == HandlerResult.ReThrow;
+            return handleResult;
         }
 
         private static async Task<HandlerResult> EnumerateHandlers(
@@ -123,6 +118,14 @@ private static async Task<HandlerResult> EnumerateHandlers(
         }
 
         public async Task InvokeAsync(HttpContext context, RequestDelegate next)
+        {
+            ILogger logger = context.RequestServices.GetService<ILogger<ExceptionHandlingPolicyMiddleware>>() ??
+                             NullLoggerFactory.Instance.CreateLogger(Const.Category);
+
+            await InvokeWithRetryAsync(context, next, logger, 0);
+        }   
+        
+        private async Task InvokeWithRetryAsync(HttpContext context, RequestDelegate next, ILogger logger, int iteration)
         {
             try
             {
@@ -132,10 +135,53 @@ public async Task InvokeAsync(HttpContext context, RequestDelegate next)
             {
                 ExceptionHandlingPolicyOptions policyOptions = this.options.Value;
 
-                bool throwRequired = await EnumerateExceptionMapping(context, policyOptions, exception);
+                var result = await EnumerateExceptionMapping(context, policyOptions, exception, logger);
+
+                if (result == HandlerResult.ReThrow)
+                {
+                    throw;
+                }
+
+                if (result == HandlerResult.Retry)
+                {
+                    // We can't do anything if the response has already started, just abort.
+                    if (context.Response.HasStarted)
+                    {
+                        logger.LogWarning(Events.RetryForStartedResponce,
+                        exception,
+                            "Retry requested when responce already started. Exception will be re-thrown. RequestId: {RequestId}",
+                            context.TraceIdentifier);
+
+                        throw;
+                    }
 
-                if (throwRequired)
+                    if (iteration > MaxRetryIterations)
+                    {
+                        logger.LogCritical(Events.RetryIterationExceedLimit,
+                        exception,
+                            "Retry iterations count exceed limit of {limit}. Possible issues with retry policy configuration. Exception will be re-thrown. RequestId: {RequestId}",
+                            MaxRetryIterations,
+                            context.TraceIdentifier);
+
+                        throw;
+                    }
+
+                    logger.LogWarning(Events.Retry,
+                        exception,
+                            "Retry requested. Iteration {iteration} RequestId: {RequestId}",
+                            iteration,
+                            context.TraceIdentifier);
+
+                    await InvokeWithRetryAsync(context, next, logger, iteration + 1);
+                }
+
+                if (result != HandlerResult.Handled)
                 {
+                    logger.LogWarning(Events.UnhandledResult,
+                        exception,
+                            "After execution of all handlers exception was not marked as handled and  will be re thrown. RequestId: {RequestId}",
+                            context.TraceIdentifier);
+
                     throw;
                 }
             }

Commmunity.AspNetCore.ExceptionHandling/Handlers/HandlerOptions.cs

@@ -8,6 +8,8 @@ public enum HandlerResult
 
         NextChain = 2,
 
-        Terminate = 3
+        Retry = 3,
+
+        Handled = 4
     }
 }

Commmunity.AspNetCore.ExceptionHandling/Handlers/HandlerResult.cs

@@ -1,6 +1,6 @@
 namespace Commmunity.AspNetCore.ExceptionHandling.Handlers
 {
-    public class HandlerWithLoggerOptions : HandlerOptions
+    public class HandlerWithLoggerOptions 
     {
         private string _loggerCategory = null;
 

Commmunity.AspNetCore.ExceptionHandling/Handlers/HandlerWithLoggerOptions.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http;
+
+namespace Commmunity.AspNetCore.ExceptionHandling.Handlers
+{
+    public class MarkHandledHandler : IExceptionHandler
+    {
+        public Task<HandlerResult> Handle(HttpContext httpContext, Exception exception)
+        {
+            return Task.FromResult(HandlerResult.Handled);
+        }
+    }
+}

Commmunity.AspNetCore.ExceptionHandling/Handlers/MarkHandledHandler.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using Commmunity.AspNetCore.ExceptionHandling.Handlers;
+using Microsoft.AspNetCore.Http;
+
+namespace Commmunity.AspNetCore.ExceptionHandling.Logs
+{
+    class DisableLoggingHandler : IExceptionHandler
+    {
+        public const string DisableLoggingFlagKey = "427EDE68BE9A";
+                
+        public Task<HandlerResult> Handle(HttpContext httpContext, Exception exception)
+        {
+            exception.Data[DisableLoggingFlagKey] = string.Empty;
+            
+            return Task.FromResult(HandlerResult.NextHandler);
+        }
+    }
+}

Commmunity.AspNetCore.ExceptionHandling/Logs/DisableLoggingHandler.cs

@@ -23,6 +23,11 @@ public LogExceptionHandler(IOptions<LogHandlerOptions<TException>> settings)
         }
         public Task<HandlerResult> Handle(HttpContext httpContext, Exception exception)
         {
+            if (exception.Data.Contains(DisableLoggingHandler.DisableLoggingFlagKey))
+            {
+                return Task.FromResult(HandlerResult.NextHandler);
+            }
+
             ILoggerFactory loggerFactory =
                 httpContext.RequestServices.GetService(typeof(ILoggerFactory)) as ILoggerFactory;