Serilogs added for request audibility and exception middleware. Xmlcomments added in fetch application by id. Endpoint boom added to test exception middleware. Instance name added for in docker MySQL connection string in appsettings.production.json.

Author: HasanJaved-Developer

CentralizedLoggingApi/CentralizedLoggingApi.csproj

@@ -4,6 +4,9 @@
     <TargetFramework>net9.0</TargetFramework>
     <Nullable>enable</Nullable>
     <ImplicitUsings>enable</ImplicitUsings>
+    <GenerateDocumentationFile>True</GenerateDocumentationFile>
+	 <NoWarn>$(NoWarn);1591</NoWarn> <!-- suppress missing XML comment warnings -->
+	<DocumentationFile>$(AssemblyName).xml</DocumentationFile>
   </PropertyGroup>
 
   <ItemGroup>
@@ -18,6 +21,14 @@
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
+    <PackageReference Include="Serilog.AspNetCore" Version="9.0.0" />
+    <PackageReference Include="Serilog.Enrichers.Environment" Version="3.0.1" />
+    <PackageReference Include="Serilog.Enrichers.Process" Version="3.0.0" />
+    <PackageReference Include="Serilog.Enrichers.Thread" Version="4.0.0" />
+    <PackageReference Include="Serilog.Filters.Expressions" Version="2.1.0" />
+    <PackageReference Include="Serilog.Sinks.Console" Version="6.0.0" />
+    <PackageReference Include="Serilog.Sinks.File" Version="7.0.0" />
+    <PackageReference Include="Serilog.Sinks.MSSqlServer" Version="8.2.2" />
     <PackageReference Include="Swashbuckle.AspNetCore" Version="9.0.3" />
     <PackageReference Include="Swashbuckle.AspNetCore.SwaggerGen" Version="9.0.3" />
   </ItemGroup>

CentralizedLoggingApi/CentralizedLoggingApi.xml

@@ -9,11 +9,14 @@ namespace CentralizedLoggingApi.Controllers
     [Route("api/[controller]")]
     public class ApplicationsController : ControllerBase
     {
+        private readonly ILogger<ApplicationsController> _logger;
+        
         private readonly LoggingDbContext _context;
 
-        public ApplicationsController(LoggingDbContext context)
+        public ApplicationsController(LoggingDbContext context, ILogger<ApplicationsController> logger)
         {
             _context = context;
+            _logger = logger;
         }
 
         [HttpPost]
@@ -24,14 +27,60 @@ public async Task<IActionResult> Create([FromBody] Application app)
             return CreatedAtAction(nameof(GetById), new { id = app.Id }, app);
         }
 
+        /// <summary>
+        /// Fetches an application by its unique Id.
+        /// </summary>
+        /// <remarks>
+        /// This endpoint retrieves application details from the database.  
+        /// 
+        /// **Logging:**  
+        /// - On every call, Serilog writes an entry to the log file (e.g., `dev-app-.clef`).  
+        /// - If an error occurs (e.g., record not found or DB exception), the error is also recorded in the same log file.  
+        /// 
+        /// **Usage:**  
+        /// `GET /api/applications/{id}`  
+        /// 
+        /// Note:  
+        /// The logging setup ensures that each request is auditable and errors can be traced via structured log files.
+        /// </remarks>
+        /// <param name="id">Unique application Id.</param>
+        /// <returns>Returns the application details if found, otherwise NotFound (404).</returns>
+
         [HttpGet("{id}")]
         public async Task<IActionResult> GetById(int id)
-        {
+        {            
+
             var app = await _context.Applications.FindAsync(id);
-            if (app == null) return NotFound();
+            if (app == null)
+            {
+                _logger.LogWarning("Application not found. Id={Id}", id);
+                return NotFound();
+            }
+
             return Ok(app);
         }
 
+        /// <summary>
+        /// Test endpoint that always throws an <see cref="InvalidOperationException"/>.
+        /// </summary>
+        /// <remarks>
+        /// <para>
+        /// This endpoint exists only for verifying the application's global exception
+        /// handling middleware and Serilog logging.
+        /// </para>
+        /// <para>
+        /// When called, it will throw an unhandled exception. The request should be
+        /// intercepted by <c>ExceptionHandlingMiddleware</c>, which will log the error
+        /// and return a consistent JSON error response.
+        /// </para>
+        /// </remarks>
+        /// <response code="500">Always returned, because the endpoint throws an exception.</response>
+        [HttpGet("boom")]
+        public Task<IActionResult> Boom()
+        {
+            throw new InvalidOperationException("Boom!");
+        }
+
         [HttpGet]
         public async Task<IActionResult> GetAll()
         {

CentralizedLoggingApi/Controllers/ApplicationsController.cs

@@ -0,0 +1,73 @@
+using System.Net.Mime;
+
+namespace CentralizedLoggingApi.Middlewares
+{
+    public class ExceptionHandlingMiddleware
+    {
+        private readonly RequestDelegate _next;
+        private readonly ILogger<ExceptionHandlingMiddleware> _logger;
+
+        public ExceptionHandlingMiddleware(RequestDelegate next, ILogger<ExceptionHandlingMiddleware> logger)
+        {
+            _next = next;
+            _logger = logger;
+        }
+
+        public async Task Invoke(HttpContext context)
+        {
+            try
+            {
+                await _next(context); // continue pipeline
+            }
+            catch (OperationCanceledException oce) when (context.RequestAborted.IsCancellationRequested)
+            {
+                // Client aborted; don’t try to write a response body.
+                _logger.LogWarning(oce, "Request aborted by client {Path} ({TraceId})",
+                    context.Request.Path, context.TraceIdentifier);
+                // Let it bubble or just return; here we just return.
+            }
+            catch (Exception ex)
+            {
+                // Log using Serilog (through ILogger)
+                _logger.LogError(ex, "Unhandled exception occurred while processing request {Path}", context.Request.Path);
+
+                // If the server already committed headers/body, we can't change it.
+                if (context.Response.HasStarted)
+                {
+                    _logger.LogWarning("The response has already started; cannot write error body. Rethrowing.");
+                    throw; // Let server infrastructure terminate the connection appropriately.
+                }
+
+                // Clear headers/status that may have been set
+                context.Response.Clear();
+                context.Response.ContentType = "application/json";
+                context.Response.StatusCode = StatusCodes.Status500InternalServerError;
+
+                // If a previous component wrote to the (buffered) body, wipe it safely.
+                try
+                {
+                    if (context.Response.Body.CanSeek)
+                    {
+                        context.Response.Body.SetLength(0);
+                        context.Response.Body.Position = 0;
+                    }
+                }
+                catch
+                {
+                    // If the body stream isn't seekable/writable (rare with your buffer), ignore.
+                }
+                // Let the server recalc Content-Length
+                context.Response.Headers.ContentLength = null;
+    
+
+                var result = new
+                {
+                    error = "An unexpected error occurred",
+                    details = ex.Message // optional, avoid exposing internals in production
+                };
+
+                await context.Response.WriteAsJsonAsync(result);
+            }
+        }
+    }
+}

CentralizedLoggingApi/Middlewares/ExceptionHandlingMiddleware.cs

@@ -0,0 +1,52 @@
+namespace CentralizedLoggingApi.Middlewares
+{
+    public class RequestAudibilityMiddleware
+    {
+        private readonly RequestDelegate _next;
+        private readonly ILogger<RequestAudibilityMiddleware> _logger;
+
+        public RequestAudibilityMiddleware(RequestDelegate next, ILogger<RequestAudibilityMiddleware> logger)
+        {
+            _next = next;
+            _logger = logger;
+        }
+
+        public async Task InvokeAsync(HttpContext context)
+        {
+            var requestId = context.TraceIdentifier;
+
+            // Log request info
+            _logger.LogInformation("Incoming request {RequestId} {Method} {Path} from {RemoteIp}",
+                requestId,
+                context.Request.Method,
+                context.Request.Path,
+                context.Connection.RemoteIpAddress?.ToString());
+
+
+            var originalBodyStream = context.Response.Body; // Save original response stream
+
+            await using var responseBody = new MemoryStream();
+            context.Response.Body = responseBody;
+
+            try
+            {
+                await _next(context); // continue pipeline
+            }
+            finally
+            {
+                // Capture response
+                context.Response.Body.Seek(0, SeekOrigin.Begin);
+                var responseText = await new StreamReader(context.Response.Body).ReadToEndAsync();
+                context.Response.Body.Seek(0, SeekOrigin.Begin);
+
+                _logger.LogInformation("Outgoing response {RequestId} with status {StatusCode}, length {Length}",
+                    requestId,
+                    context.Response.StatusCode,
+                    responseText?.Length);
+
+                // Copy back to original response body
+                await responseBody.CopyToAsync(originalBodyStream);
+            }
+        }
+    }
+}

CentralizedLoggingApi/Middlewares/RequestAudibilityMiddleware.cs

@@ -1,19 +1,32 @@
+using CentralizedLoggingApi;
+using CentralizedLoggingApi.Data;
+using CentralizedLoggingApi.Middlewares;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.OpenApi.Models; 
-using CentralizedLoggingApi.Data;
-using CentralizedLoggingApi;
+using Serilog;
+using System.Reflection;
 
 
 
 var builder = WebApplication.CreateBuilder(args);
 
+Log.Logger = new LoggerConfiguration()
+    .ReadFrom.Configuration(builder.Configuration)
+    .Enrich.WithProperty("Application", "CentralizedLogging") // change if needed
+    .CreateLogger();
+
+builder.Host.UseSerilog();
+
 Console.WriteLine($"Environment: {builder.Environment.EnvironmentName}");
 Console.WriteLine($"Connection: {builder.Configuration.GetConnectionString("DefaultConnection")}");
 
 // DB connection string (SQL Server example)
 builder.Services.AddDbContext<LoggingDbContext>(options =>
     options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));
 
+
+builder.Services.AddHttpContextAccessor();
+
 // Add services to the container.
 
 builder.Services.AddControllers();
@@ -28,10 +41,28 @@
         Version = "v1",
         Description = "API for centralized error logging and monitoring"
     });
+    var xmlFile = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
+    var xmlPath = Path.Combine(AppContext.BaseDirectory, xmlFile);
+    c.IncludeXmlComments(xmlPath, includeControllerXmlComments: true); // ok if your Swashbuckle version supports the bool
+
 });
 
 var app = builder.Build();
 
+app.Use(async (ctx, next) =>
+{
+    using (Serilog.Context.LogContext.PushProperty("Environment", app.Environment.EnvironmentName))
+    using (Serilog.Context.LogContext.PushProperty("Service", "CoreAPI"))
+    using (Serilog.Context.LogContext.PushProperty("CorrelationId", ctx.TraceIdentifier))
+    {
+        await next();
+    }
+});
+
+// Middleware should be early in the pipeline
+app.UseMiddleware<RequestAudibilityMiddleware>();
+app.UseMiddleware<ExceptionHandlingMiddleware>();
+
 // Configure the HTTP request pipeline.
 if (app.Environment.IsDevelopment())
 {
@@ -48,6 +79,9 @@
 
 app.UseAuthorization();
 
+
+
+
 app.MapControllers();
 
 // Seed sample data

CentralizedLoggingApi/Program.cs

@@ -1,11 +1,5 @@
 {
-  "Logging": {
-    "LogLevel": {
-      "Default": "Information",
-      "Microsoft.AspNetCore": "Warning"
-    }
-  },
   "ConnectionStrings": {
-    "DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=CentralizedLoggingDB;Trusted_Connection=True;MultipleActiveResultSets=true" 
+    "DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=CentralizedLoggingDB;Trusted_Connection=True;MultipleActiveResultSets=true"
   }
 }

CentralizedLoggingApi/appsettings.Development.json

@@ -1,12 +1,5 @@
 {
-  "Logging": {
-    "LogLevel": {
-      "Default": "Information",
-      "Microsoft.AspNetCore": "Warning"
-    }
-  },
-  "ConnectionStrings": {    
-    "DefaultConnection": "Server=localhost,1433;Database=CentralizedLoggingDB;User=sa;Password=Bisp@123;MultipleActiveResultSets=true;TrustServerCertificate=True;Encrypt=False;"
-  },
-  "AllowedHosts": "*"
+  "ConnectionStrings": {
+    "DefaultConnection": "Server=db,1433;Database=CentralizedLoggingDB;User=sa;Password=Bisp@123;MultipleActiveResultSets=true;TrustServerCertificate=True;Encrypt=False;"
+  }
 }