Merge branch 'master' of https://github.com/serilog-contrib/serilog-enrichers-clientinfo

Author: mo-esmp

README.md

@@ -94,6 +94,26 @@ or
   }
 }
 ```
+#### Retrieving Correlation ID
+You can easily retrieve the correlation ID from `HttpContext` using the `GetCorrelationId()` extension method:
+
+```csharp
+public void SomeControllerAction()
+{
+    // This will return the correlation ID that was enriched by the CorrelationIdEnricher
+    var correlationId = HttpContext.GetCorrelationId();
+    
+    // You can use this for error reporting, tracing, etc.
+    if (!string.IsNullOrEmpty(correlationId))
+    {
+        // Show correlation ID to user for error reporting
+        // or use it for additional logging/tracing
+    }
+}
+```
+
+This eliminates the need for manual casting and provides a clean API for accessing correlation IDs.
+
 ### RequestHeader
 You can use multiple `WithRequestHeader` to log different request headers. `WithRequestHeader` accepts two parameters; The first parameter `headerName` is the header name to log 
 and the second parameter is `propertyName` which is the log property name.

nuget.exe

@@ -0,0 +1,6 @@
+namespace Serilog;
+
+internal static class Constants
+{
+    public const string CorrelationIdValueKey = "Serilog_CorrelationId_Value";
+}

src/Serilog.Enrichers.ClientInfo/Constants.cs

@@ -46,6 +46,14 @@ public void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory)
             value is LogEventProperty logEventProperty)
         {
             logEvent.AddPropertyIfAbsent(logEventProperty);
+
+            // Ensure the string value is also available if not already stored
+            if (!httpContext.Items.ContainsKey(Constants.CorrelationIdValueKey))
+            {
+                string correlationIdValue = ((ScalarValue)logEventProperty.Value).Value as string;
+                httpContext.Items.Add(Constants.CorrelationIdValueKey, correlationIdValue);
+            }
+
             return;
         }
 
@@ -67,5 +75,6 @@ public void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory)
         logEvent.AddOrUpdateProperty(correlationIdProperty);
 
         httpContext.Items.Add(CorrelationIdItemKey, correlationIdProperty);
+        httpContext.Items.Add(Constants.CorrelationIdValueKey, correlationId);
     }
 }

src/Serilog.Enrichers.ClientInfo/Enrichers/CorrelationIdEnricher.cs

@@ -0,0 +1,17 @@
+using Microsoft.AspNetCore.Http;
+
+namespace Serilog.Enrichers;
+
+/// <summary>
+///     Extension methods for <see cref="HttpContext" /> to access enriched values.
+/// </summary>
+public static class HttpContextExtensions
+{
+    /// <summary>
+    ///     Retrieves the correlation ID value from the current HTTP context.
+    /// </summary>
+    /// <param name="httpContext">The HTTP context.</param>
+    /// <returns>The correlation ID as a string, or null if not available.</returns>
+    public static string GetCorrelationId(this HttpContext httpContext)
+        => httpContext?.Items[Constants.CorrelationIdValueKey] as string;
+}

src/Serilog.Enrichers.ClientInfo/Extensions/HttpContextExtensions.cs

@@ -161,6 +161,147 @@ public void
         Assert.Equal(requestCorrelationId, evt.Properties[LogPropertyName].LiteralValue().ToString());
     }
 
+    [Fact]
+    public void GetCorrelationId_WhenHttpRequestContainCorrelationHeader_ShouldReturnCorrelationIdFromHttpContext()
+    {
+        // Arrange
+        string correlationId = Guid.NewGuid().ToString();
+        _contextAccessor.HttpContext!.Request!.Headers[HeaderKey] = correlationId;
+        CorrelationIdEnricher correlationIdEnricher = new(HeaderKey, false, _contextAccessor);
+
+        LogEvent evt = null;
+        Logger log = new LoggerConfiguration()
+            .Enrich.With(correlationIdEnricher)
+            .WriteTo.Sink(new DelegatingSink(e => evt = e))
+            .CreateLogger();
+
+        // Act
+        log.Information("Has a correlation id.");
+        string retrievedCorrelationId = _contextAccessor.HttpContext!.GetCorrelationId();
+
+        // Assert
+        Assert.NotNull(evt);
+        Assert.Equal(correlationId, retrievedCorrelationId);
+    }
+
+    [Fact]
+    public void
+        GetCorrelationId_WhenHttpRequestNotContainCorrelationHeaderAndAddDefaultValueIsTrue_ShouldReturnGeneratedCorrelationIdFromHttpContext()
+    {
+        // Arrange
+        CorrelationIdEnricher correlationIdEnricher = new(HeaderKey, true, _contextAccessor);
+
+        LogEvent evt = null;
+        Logger log = new LoggerConfiguration()
+            .Enrich.With(correlationIdEnricher)
+            .WriteTo.Sink(new DelegatingSink(e => evt = e))
+            .CreateLogger();
+
+        // Act
+        log.Information("Has a correlation id.");
+        string retrievedCorrelationId = _contextAccessor.HttpContext!.GetCorrelationId();
+
+        // Assert
+        Assert.NotNull(evt);
+        Assert.NotNull(retrievedCorrelationId);
+        Assert.NotEmpty(retrievedCorrelationId);
+        // Verify it's a valid GUID format
+        Assert.True(Guid.TryParse(retrievedCorrelationId, out _));
+    }
+
+    [Fact]
+    public void
+        GetCorrelationId_WhenHttpRequestNotContainCorrelationHeaderAndAddDefaultValueIsFalse_ShouldReturnNullFromHttpContext()
+    {
+        // Arrange
+        CorrelationIdEnricher correlationIdEnricher = new(HeaderKey, false, _contextAccessor);
+
+        LogEvent evt = null;
+        Logger log = new LoggerConfiguration()
+            .Enrich.With(correlationIdEnricher)
+            .WriteTo.Sink(new DelegatingSink(e => evt = e))
+            .CreateLogger();
+
+        // Act
+        log.Information("Has a correlation id.");
+        string retrievedCorrelationId = _contextAccessor.HttpContext!.GetCorrelationId();
+
+        // Assert
+        Assert.NotNull(evt);
+        Assert.Null(retrievedCorrelationId);
+    }
+
+    [Fact]
+    public void GetCorrelationId_WhenCalledMultipleTimes_ShouldReturnSameCorrelationId()
+    {
+        // Arrange
+        string correlationId = Guid.NewGuid().ToString();
+        _contextAccessor.HttpContext!.Request!.Headers[HeaderKey] = correlationId;
+        CorrelationIdEnricher correlationIdEnricher = new(HeaderKey, false, _contextAccessor);
+
+        Logger log = new LoggerConfiguration()
+            .Enrich.With(correlationIdEnricher)
+            .WriteTo.Sink(new DelegatingSink(_ => { }))
+            .CreateLogger();
+
+        // Act
+        log.Information("First log message.");
+        string firstRetrieval = _contextAccessor.HttpContext!.GetCorrelationId();
+
+        log.Information("Second log message.");
+        string secondRetrieval = _contextAccessor.HttpContext!.GetCorrelationId();
+
+        // Assert
+        Assert.Equal(correlationId, firstRetrieval);
+        Assert.Equal(correlationId, secondRetrieval);
+        Assert.Equal(firstRetrieval, secondRetrieval);
+    }
+
+    [Fact]
+    public void GetCorrelationId_WhenHttpContextIsNull_ShouldReturnNull()
+    {
+        // Arrange & Act
+        string result = HttpContextExtensions.GetCorrelationId(null);
+
+        // Assert
+        Assert.Null(result);
+    }
+
+    [Fact]
+    public void EnrichLogWithCorrelationId_BackwardCompatibility_OldRetrievalMethodShouldStillWork()
+    {
+        // Arrange
+        string correlationId = Guid.NewGuid().ToString();
+        _contextAccessor.HttpContext!.Request!.Headers[HeaderKey] = correlationId;
+        CorrelationIdEnricher correlationIdEnricher = new(HeaderKey, false, _contextAccessor);
+
+        LogEvent evt = null;
+        Logger log = new LoggerConfiguration()
+            .Enrich.With(correlationIdEnricher)
+            .WriteTo.Sink(new DelegatingSink(e => evt = e))
+            .CreateLogger();
+
+        // Act
+        log.Information("Has a correlation id.");
+
+        // Test that the old way (hacky way) still works
+        HttpContext httpContext = _contextAccessor.HttpContext!;
+        string retrievedCorrelationIdOldWay = null;
+
+        if (httpContext.Items.TryGetValue("Serilog_CorrelationId", out object correlationIdItem) &&
+            correlationIdItem is LogEventProperty { Name: "CorrelationId" } correlationIdProperty)
+            retrievedCorrelationIdOldWay = ((ScalarValue)correlationIdProperty.Value).Value as string;
+
+        // Test that the new way also works
+        string retrievedCorrelationIdNewWay = httpContext.GetCorrelationId();
+
+        // Assert
+        Assert.NotNull(evt);
+        Assert.Equal(correlationId, retrievedCorrelationIdOldWay);
+        Assert.Equal(correlationId, retrievedCorrelationIdNewWay);
+        Assert.Equal(retrievedCorrelationIdOldWay, retrievedCorrelationIdNewWay);
+    }
+
     [Fact]
     public void WithClientIp_ThenLoggerIsCalled_ShouldNotThrowException()
     {