Merge branch 'phase-2-logging' of https://github.com/HasanJaved-Developer/CentralizedLoggingMonitoring into phase-2-logging

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

@@ -13,6 +13,7 @@ namespace CentralizedLoggingApi.Migrations
     [DbContext(typeof(LoggingDbContext))]
     partial class LoggingDbContextModelSnapshot : ModelSnapshot
     {
+
         protected override void BuildModel(ModelBuilder modelBuilder)
         {
 #pragma warning disable 612, 618

CentralizedLoggingApi/Migrations/LoggingDbContextModelSnapshot.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"
   }
 }