Merge pull request #15 from managedcode/filters

Add exception and model validation filters for improved error handling

Author: VladKovtun99

Directory.Build.props

@@ -24,8 +24,8 @@
         <RepositoryUrl>https://github.com/managedcode/Communication</RepositoryUrl>
         <PackageProjectUrl>https://github.com/managedcode/Communication</PackageProjectUrl>
         <Product>Managed Code - Communication</Product>
-        <Version>9.0.0</Version>
-        <PackageVersion>9.0.0</PackageVersion>
+        <Version>9.0.1</Version>
+        <PackageVersion>9.0.1</PackageVersion>
 
     </PropertyGroup>
     <PropertyGroup Condition="'$(GITHUB_ACTIONS)' == 'true'">

ManagedCode.Communication.Extensions/CommunicationHubFilter.cs

@@ -0,0 +1,59 @@
+namespace ManagedCode.Communication.Extensions.Constants;
+
+/// <summary>
+/// Constants for Problem details to avoid string literals throughout the codebase.
+/// </summary>
+public static class ProblemConstants
+{
+    /// <summary>
+    /// Problem titles
+    /// </summary>
+    public static class Titles
+    {
+        /// <summary>
+        /// Title for validation failure problems
+        /// </summary>
+        public const string ValidationFailed = "Validation failed";
+        
+        /// <summary>
+        /// Title for unexpected error problems
+        /// </summary>
+        public const string UnexpectedError = "An unexpected error occurred";
+    }
+    
+    /// <summary>
+    /// Problem extension keys
+    /// </summary>
+    public static class ExtensionKeys
+    {
+        /// <summary>
+        /// Key for validation errors in problem extensions
+        /// </summary>
+        public const string ValidationErrors = "validationErrors";
+        
+        /// <summary>
+        /// Key for trace ID in problem extensions
+        /// </summary>
+        public const string TraceId = "traceId";
+        
+        /// <summary>
+        /// Key for hub method name in problem extensions
+        /// </summary>
+        public const string HubMethod = "hubMethod";
+        
+        /// <summary>
+        /// Key for hub type name in problem extensions
+        /// </summary>
+        public const string HubType = "hubType";
+        
+        /// <summary>
+        /// Key for inner exception in problem extensions
+        /// </summary>
+        public const string InnerException = "innerException";
+        
+        /// <summary>
+        /// Key for stack trace in problem extensions
+        /// </summary>
+        public const string StackTrace = "stackTrace";
+    }
+} 

ManagedCode.Communication.Extensions/CommunicationMiddleware.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Net;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Filters;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
+using static ManagedCode.Communication.Extensions.Helpers.HttpStatusCodeHelper;
+using static ManagedCode.Communication.Extensions.Constants.ProblemConstants;
+
+namespace ManagedCode.Communication.Extensions;
+
+public abstract class ExceptionFilterBase : IExceptionFilter
+{
+    protected readonly ILogger Logger = NullLogger<ExceptionFilterBase>.Instance;
+    
+    public virtual void OnException(ExceptionContext context)
+    {
+        try
+        {
+            var exception = context.Exception;
+            var actionName = context.ActionDescriptor.DisplayName;
+            var controllerName = context.ActionDescriptor.RouteValues["controller"] ?? "Unknown";
+
+            Logger.LogError(exception, "Unhandled exception in {ControllerName}.{ActionName}", 
+                controllerName, actionName);
+
+            var statusCode = GetStatusCodeForException(exception);
+            
+            var problem = new Problem()
+            {
+                Title = exception.GetType().Name,
+                Detail = exception.Message,
+                Status = statusCode,
+                Instance = context.HttpContext.Request.Path,
+                Extensions =
+                {
+                    [ExtensionKeys.TraceId] = context.HttpContext.TraceIdentifier
+                }
+            };
+
+            var result = Result<Problem>.Fail(exception.Message, problem);
+
+            context.Result = new ObjectResult(result)
+            {
+                StatusCode = (int)statusCode
+            };
+
+            context.ExceptionHandled = true;
+
+            Logger.LogInformation("Exception handled by {FilterType} for {ControllerName}.{ActionName}", 
+                GetType().Name, controllerName, actionName);
+        }
+        catch (Exception ex)
+        {
+            Logger.LogError(ex, "Error occurred while handling exception in {FilterType}", GetType().Name);
+            
+            var fallbackProblem = new Problem
+            {
+                Title = Titles.UnexpectedError,
+                Status = HttpStatusCode.InternalServerError,
+                Instance = context.HttpContext.Request.Path
+            };
+            
+            context.Result = new ObjectResult(Result<Problem>.Fail(Titles.UnexpectedError, fallbackProblem))
+            {
+                StatusCode = (int)HttpStatusCode.InternalServerError
+            };
+            context.ExceptionHandled = true;
+        }
+    }
+} 

ManagedCode.Communication.Extensions/Constants/ProblemConstants.cs

@@ -1,5 +1,9 @@
 using System;
 using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+using ManagedCode.Communication.Extensions;
 
 namespace ManagedCode.Communication.Extensions.Extensions;
 
@@ -10,6 +14,6 @@ public static IApplicationBuilder UseCommunication(this IApplicationBuilder app)
         if (app == null)
             throw new ArgumentNullException(nameof(app));
 
-        return app.UseMiddleware<CommunicationMiddleware>();
+        return app;
     }
 }

ManagedCode.Communication.Extensions/ExceptionFilterBase.cs

@@ -1,11 +1,15 @@
+using System;
 using Microsoft.AspNetCore.SignalR;
+using Microsoft.Extensions.DependencyInjection;
+using ManagedCode.Communication.Extensions;
 
 namespace ManagedCode.Communication.Extensions.Extensions;
 
 public static class HubOptionsExtensions
 {
-    public static void AddCommunicationHubFilter(this HubOptions result)
+    public static void AddCommunicationHubFilter(this HubOptions result, IServiceProvider serviceProvider)
     {
-        result.AddFilter<CommunicationHubFilter>();
+        var hubFilter = serviceProvider.GetRequiredService<HubExceptionFilterBase>();
+        result.AddFilter(hubFilter);
     }
 }

ManagedCode.Communication.Extensions/Extensions/CommunicationAppBuilderExtensions.cs

@@ -1,14 +1,83 @@
 using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.SignalR;
+using Microsoft.AspNetCore.WebUtilities;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using static ManagedCode.Communication.Extensions.Constants.ProblemConstants;
 
 namespace ManagedCode.Communication.Extensions.Extensions;
 
+
+public static class HostApplicationBuilderExtensions
+{
+    public static IHostApplicationBuilder AddCommunication(this IHostApplicationBuilder builder)
+    {
+        builder.Services.AddCommunication(options => options.ShowErrorDetails = builder.Environment.IsDevelopment());
+        return builder;
+    }
+    
+    public static IHostApplicationBuilder AddCommunication(this IHostApplicationBuilder builder, Action<CommunicationOptions> config)
+    {
+        builder.Services.AddCommunication(config);
+        return builder;
+    }
+}
+
 public static class ServiceCollectionExtensions
 {
-    public static IServiceCollection AddCommunication(this IServiceCollection services,
-        Action<CommunicationOptions> options)
+    
+    public static IServiceCollection AddCommunication(this IServiceCollection services, Action<CommunicationOptions>? configure = null)
     {
-        services.AddOptions<CommunicationOptions>().Configure(options);
+        if (configure != null)
+            services.Configure(configure);
+
+        return services;
+    }
+    
+   
+
+    public static IServiceCollection AddDefaultProblemDetails(this IServiceCollection services)
+    {
+        services.AddProblemDetails(options =>
+        {
+            options.CustomizeProblemDetails = context =>
+            {
+                var statusCode = context.ProblemDetails.Status.GetValueOrDefault(StatusCodes.Status500InternalServerError);
+
+                context.ProblemDetails.Type ??= $"https://httpstatuses.io/{statusCode}";
+                context.ProblemDetails.Title ??= ReasonPhrases.GetReasonPhrase(statusCode);
+                context.ProblemDetails.Instance ??= context.HttpContext.Request.Path;
+                context.ProblemDetails.Extensions.TryAdd(ExtensionKeys.TraceId, Activity.Current?.Id ?? context.HttpContext.TraceIdentifier);
+            };
+        });
+
+        return services;
+    }
+
+    public static IServiceCollection AddCommunicationFilters<TExceptionFilter, TModelValidationFilter, THubExceptionFilter>(
+        this IServiceCollection services)
+        where TExceptionFilter : ExceptionFilterBase
+        where TModelValidationFilter : ModelValidationFilterBase
+        where THubExceptionFilter : HubExceptionFilterBase
+    {
+        services.AddScoped<TExceptionFilter>();
+        services.AddScoped<TModelValidationFilter>();
+        services.AddScoped<THubExceptionFilter>();
+
+        services.AddControllers(options => 
+        { 
+            options.Filters.Add<TExceptionFilter>();
+            options.Filters.Add<TModelValidationFilter>();
+        });
+
+        services.Configure<HubOptions>(options =>
+        {
+            options.AddFilter<THubExceptionFilter>();
+        });
+
         return services;
     }
 }