fix: harden event processing and edge case handling

engineering87 · engineering87 · commit 5f02c1194438 · 2026-02-28T21:44:50.000+01:00
diff --git a/src/WART-Client/WartTestClient.cs b/src/WART-Client/WartTestClient.cs
@@ -38,7 +38,7 @@ public static async Task ConnectAsync(string wartHubUrl)
                 {
                     Console.WriteLine(exception);
                     Console.WriteLine(Environment.NewLine);
-                    await Task.Delay(new Random().Next(0, 5) * 1000);
+                    await Task.Delay(Random.Shared.Next(0, 5) * 1000);
                     await hubConnection.StartAsync();
                 };
 
diff --git a/src/WART-Client/WartTestClientCookie.cs b/src/WART-Client/WartTestClientCookie.cs
@@ -28,7 +28,7 @@ public static async Task ConnectAsync(string hubUrl)
                     AllowAutoRedirect = true
                 };
 
-                using var httpClient = new HttpClient(handler);
+                using var httpClient = new HttpClient(handler, disposeHandler: false);
 
                 var loginContent = new FormUrlEncodedContent(new[]
                 {
@@ -66,7 +66,7 @@ public static async Task ConnectAsync(string hubUrl)
                 hubConnection.Closed += async (ex) =>
                 {
                     Console.WriteLine($"Connection closed: {ex?.Message}");
-                    await Task.Delay(new Random().Next(0, 5) * 1000);
+                    await Task.Delay(Random.Shared.Next(0, 5) * 1000);
                     if (hubConnection != null)
                         await hubConnection.StartAsync();
                 };
diff --git a/src/WART-Client/WartTestClientJwt.cs b/src/WART-Client/WartTestClientJwt.cs
@@ -43,7 +43,7 @@ public static async Task ConnectAsync(string wartHubUrl, string key)
                 {
                     Console.WriteLine(exception);
                     Console.WriteLine(Environment.NewLine);
-                    await Task.Delay(new Random().Next(0, 5) * 1000);
+                    await Task.Delay(Random.Shared.Next(0, 5) * 1000);
                     await hubConnection.StartAsync();
                 };
 
diff --git a/src/WART-Client/appsettings.json b/src/WART-Client/appsettings.json
@@ -1,7 +1,7 @@
 {
   "Scheme": "https",
   "Host": "localhost",
-  "Port": "54644",
+  "Port": "62198",
   "Hubname": "warthub",
   "AuthenticationType": "JWT",
   "Key": "dn3341fmcscscwe28419brhwbwgbss4t",
diff --git a/src/WART-Core/Entity/WartEventWithFilters.cs b/src/WART-Core/Entity/WartEventWithFilters.cs
@@ -1,6 +1,7 @@
 ﻿// (c) 2024 Francesco Del Re <francesco.delre.87@gmail.com>
 // This code is licensed under MIT license (see LICENSE.txt for details)
 using Microsoft.AspNetCore.Mvc.Filters;
+using System;
 using System.Collections.Generic;
 
 namespace WART_Core.Entity
@@ -20,13 +21,20 @@ public class WartEventWithFilters
         /// </summary>
         public List<IFilterMetadata> Filters { get; set; }
 
+        /// <summary>
+        /// The number of times this event has been retried.
+        /// </summary>
+        public int RetryCount { get; set; }
+
         /// <summary>
         /// Initializes a new instance of the WartEventWithFilters class.
         /// </summary>
         /// <param name="wartEvent">The WartEvent to associate with the filters.</param>
         /// <param name="filters">The list of filters applied to the event.</param>
         public WartEventWithFilters(WartEvent wartEvent, List<IFilterMetadata> filters)
         {
+            ArgumentNullException.ThrowIfNull(wartEvent);
+
             // Initialize the WartEvent and Filters properties
             WartEvent = wartEvent;
             Filters = filters;
diff --git a/src/WART-Core/Middleware/WartApplicationBuilderExtension.cs b/src/WART-Core/Middleware/WartApplicationBuilderExtension.cs
@@ -107,7 +107,7 @@ public static IApplicationBuilder UseWartMiddleware(this IApplicationBuilder app
         /// <exception cref="ArgumentException">Thrown when the hub name is null or empty.</exception>
         public static IApplicationBuilder UseWartMiddleware(this IApplicationBuilder app, string hubName)
         {
-            if (string.IsNullOrEmpty(hubName))
+            if (string.IsNullOrWhiteSpace(hubName))
                 throw new ArgumentException("Invalid hub name");
 
             app.UseForwardedHeaders();
@@ -143,7 +143,7 @@ public static IApplicationBuilder UseWartMiddleware(this IApplicationBuilder app
             var unique = hubNameList
                 .Where(s => !string.IsNullOrWhiteSpace(s))
                 .Select(NormalizeHubPath)
-                .Distinct()
+                .Distinct(StringComparer.Ordinal)
                 .ToList();
 
             app.UseEndpoints(endpoints =>
@@ -167,7 +167,7 @@ public static IApplicationBuilder UseWartMiddleware(this IApplicationBuilder app
         /// <exception cref="ArgumentException">Thrown when the hub name is null or empty.</exception>
         public static IApplicationBuilder UseWartMiddleware(this IApplicationBuilder app, string hubName, HubType hubType)
         {
-            if (string.IsNullOrEmpty(hubName))
+            if (string.IsNullOrWhiteSpace(hubName))
                 throw new ArgumentException("Invalid hub name");
 
             app.UseForwardedHeaders();
diff --git a/src/WART-Core/Serialization/JsonArrayOrObjectStringConverter.cs b/src/WART-Core/Serialization/JsonArrayOrObjectStringConverter.cs
@@ -25,7 +25,9 @@ public override string Read(ref Utf8JsonReader reader, Type typeToConvert, JsonS
                 JsonTokenType.String => reader.GetString(),
                 JsonTokenType.StartObject or JsonTokenType.StartArray => JsonDocument.ParseValue(ref reader).RootElement.GetRawText(),
                 JsonTokenType.Null => null,
-                _ => reader.GetString()
+                JsonTokenType.Number => JsonDocument.ParseValue(ref reader).RootElement.GetRawText(),
+                JsonTokenType.True or JsonTokenType.False => reader.GetBoolean().ToString(),
+                _ => throw new JsonException($"Unexpected token type: {reader.TokenType}")
             };
         }
 
diff --git a/src/WART-Core/Services/WartEventWorker.cs b/src/WART-Core/Services/WartEventWorker.cs
@@ -26,6 +26,7 @@ public class WartEventWorker<THub> : BackgroundService where THub : Hub
 
         private const int NoClientsDelayMs = 500;
         private const int IdleDelayMs = 200;
+        private const int MaxRetryCount = 5;
 
         /// <summary>
         /// Constructor that initializes the worker with the event queue, hub context, and logger.
@@ -68,14 +69,29 @@ protected override async Task ExecuteAsync(CancellationToken stoppingToken)
 
                         _logger.LogInformation("Event sent: {Event}", wartEvent);
                     }
+                    catch (OperationCanceledException) when (stoppingToken.IsCancellationRequested)
+                    {
+                        // Shutting down — re-enqueue without logging an error so
+                        // the event is not lost, then exit the loop.
+                        _eventQueue.Enqueue(wartEventWithFilters);
+                        break;
+                    }
                     catch (Exception ex)
                     {
                         // Log any errors that occur while sending the event.
                         _logger.LogError(ex, "Error while sending event.");
 
-                        // Re-enqueue the event for retry
-                        // We lost the order of the events, but we can't lose the events
-                        _eventQueue.Enqueue(wartEventWithFilters);
+                        // Re-enqueue the event for retry up to the maximum retry count.
+                        wartEventWithFilters.RetryCount++;
+                        if (wartEventWithFilters.RetryCount <= MaxRetryCount)
+                        {
+                            _eventQueue.Enqueue(wartEventWithFilters);
+                        }
+                        else
+                        {
+                            _logger.LogWarning("Event {EventId} dropped after {MaxRetries} retries.",
+                                wartEventWithFilters.WartEvent?.EventId, MaxRetryCount);
+                        }
                     }
                 }
 
diff --git a/src/WART-Tests/Entity/WartEventTests.cs b/src/WART-Tests/Entity/WartEventTests.cs
@@ -108,5 +108,75 @@ public void WartEvent_GetResponseObject_ShouldDeserializeJsonResponse()
             // Assert
             Assert.NotNull(deserializedResponse);
         }
+
+        [Fact]
+        public void WartEvent_Constructor_NullParameters_DefaultsToEmpty()
+        {
+            // Act
+            var wartEvent = new WartEvent(null!, null!, null!);
+
+            // Assert
+            Assert.Equal(string.Empty, wartEvent.HttpMethod);
+            Assert.Equal(string.Empty, wartEvent.HttpPath);
+            Assert.Equal(string.Empty, wartEvent.RemoteAddress);
+        }
+
+        [Fact]
+        public void WartEvent_FullConstructor_NullRequestResponse_DoesNotThrow()
+        {
+            // Act
+            var wartEvent = new WartEvent(null, null, "PUT", "/api/items", "10.0.0.1");
+
+            // Assert
+            Assert.NotEqual(Guid.Empty, wartEvent.EventId);
+            Assert.Equal("PUT", wartEvent.HttpMethod);
+        }
+
+        [Fact]
+        public void WartEvent_ToDictionary_ContainsAllKeys()
+        {
+            // Arrange
+            var wartEvent = new WartEvent("DELETE", "/api/items/1", "192.168.0.1")
+            {
+                ExtraInfo = "test-info"
+            };
+
+            // Act
+            var dict = wartEvent.ToDictionary();
+
+            // Assert
+            Assert.Equal(9, dict.Count);
+            Assert.Equal(wartEvent.EventId, dict["EventId"]);
+            Assert.Equal("DELETE", dict["HttpMethod"]);
+            Assert.Equal("/api/items/1", dict["HttpPath"]);
+            Assert.Equal("192.168.0.1", dict["RemoteAddress"]);
+            Assert.Equal("test-info", dict["ExtraInfo"]);
+            Assert.True(dict.ContainsKey("TimeStamp"));
+            Assert.True(dict.ContainsKey("UtcTimeStamp"));
+            Assert.True(dict.ContainsKey("JsonRequestPayload"));
+            Assert.True(dict.ContainsKey("JsonResponsePayload"));
+        }
+
+        [Fact]
+        public void WartEvent_Timestamps_AreConsistent()
+        {
+            // Arrange & Act
+            var before = DateTime.UtcNow;
+            var wartEvent = new WartEvent("GET", "/", "::1");
+            var after = DateTime.UtcNow;
+
+            // Assert
+            Assert.InRange(wartEvent.UtcTimeStamp, before, after);
+            Assert.Equal(wartEvent.UtcTimeStamp.ToLocalTime(), wartEvent.TimeStamp);
+        }
+
+        [Fact]
+        public void WartEvent_EventId_IsUnique()
+        {
+            var a = new WartEvent("GET", "/", "::1");
+            var b = new WartEvent("GET", "/", "::1");
+
+            Assert.NotEqual(a.EventId, b.EventId);
+        }
     }
 }
diff --git a/src/WART-Tests/Entity/WartEventWithFiltersTests.cs b/src/WART-Tests/Entity/WartEventWithFiltersTests.cs
@@ -0,0 +1,60 @@
+// (c) 2025 Francesco Del Re <francesco.delre.87@gmail.com>
+// This code is licensed under MIT license (see LICENSE.txt for details)
+using Microsoft.AspNetCore.Mvc.Filters;
+using WART_Core.Entity;
+using WART_Core.Filters;
+
+namespace WART_Tests.Entity
+{
+    public class WartEventWithFiltersTests
+    {
+        [Fact]
+        public void Constructor_SetsProperties()
+        {
+            var evt = new WartEvent("POST", "/api/items", "10.0.0.1");
+            var filters = new List<IFilterMetadata> { new GroupWartAttribute("g1") };
+
+            var item = new WartEventWithFilters(evt, filters);
+
+            Assert.Same(evt, item.WartEvent);
+            Assert.Same(filters, item.Filters);
+            Assert.Equal(0, item.RetryCount);
+        }
+
+        [Fact]
+        public void Constructor_NullWartEvent_ThrowsArgumentNullException()
+        {
+            Assert.Throws<ArgumentNullException>(() =>
+                new WartEventWithFilters(null!, []));
+        }
+
+        [Fact]
+        public void Constructor_NullFilters_DoesNotThrow()
+        {
+            var evt = new WartEvent("GET", "/", "::1");
+
+            var item = new WartEventWithFilters(evt, null!);
+
+            Assert.Null(item.Filters);
+        }
+
+        [Fact]
+        public void RetryCount_DefaultsToZero()
+        {
+            var item = new WartEventWithFilters(new WartEvent("GET", "/", "::1"), []);
+
+            Assert.Equal(0, item.RetryCount);
+        }
+
+        [Fact]
+        public void RetryCount_CanBeIncremented()
+        {
+            var item = new WartEventWithFilters(new WartEvent("GET", "/", "::1"), []);
+
+            item.RetryCount++;
+            item.RetryCount++;
+
+            Assert.Equal(2, item.RetryCount);
+        }
+    }
+}
diff --git a/src/WART-Tests/Serialization/JsonArrayOrObjectStringConverterTests.cs b/src/WART-Tests/Serialization/JsonArrayOrObjectStringConverterTests.cs
@@ -13,7 +13,7 @@ public class JsonArrayOrObjectStringConverterTests
             Converters = { new JsonArrayOrObjectStringConverter() }
         };
 
-        private class Wrapper { public string Payload { get; set; } }
+        private class Wrapper { public string? Payload { get; set; } }
 
         [Fact]
         public void Write_String_RemainsString()
@@ -62,5 +62,86 @@ public void WartEvent_ToString_IsValidJson()
             var json = e.ToString();
             using var _ = JsonDocument.Parse(json);
         }
+
+        [Fact]
+        public void Read_NullToken_ReturnsNull()
+        {
+            var json = "{\"Payload\": null}";
+            var wrapper = JsonSerializer.Deserialize<Wrapper>(json, _opts);
+            Assert.Null(wrapper!.Payload);
+        }
+
+        [Fact]
+        public void Read_NumberToken_ReturnsStringRepresentation()
+        {
+            var json = "{\"Payload\": 42}";
+            var wrapper = JsonSerializer.Deserialize<Wrapper>(json, _opts);
+            Assert.Equal("42", wrapper!.Payload);
+        }
+
+        [Fact]
+        public void Read_DecimalNumberToken_ReturnsStringRepresentation()
+        {
+            var json = "{\"Payload\": 3.14}";
+            var wrapper = JsonSerializer.Deserialize<Wrapper>(json, _opts);
+            Assert.Equal("3.14", wrapper!.Payload);
+        }
+
+        [Fact]
+        public void Read_BooleanTrueToken_ReturnsString()
+        {
+            var json = "{\"Payload\": true}";
+            var wrapper = JsonSerializer.Deserialize<Wrapper>(json, _opts);
+            Assert.Equal("True", wrapper!.Payload);
+        }
+
+        [Fact]
+        public void Read_BooleanFalseToken_ReturnsString()
+        {
+            var json = "{\"Payload\": false}";
+            var wrapper = JsonSerializer.Deserialize<Wrapper>(json, _opts);
+            Assert.Equal("False", wrapper!.Payload);
+        }
+
+        [Fact]
+        public void Read_ArrayToken_ReturnsRawJson()
+        {
+            var json = "{\"Payload\": [1,2,3]}";
+            var wrapper = JsonSerializer.Deserialize<Wrapper>(json, _opts);
+            Assert.Equal("[1,2,3]", wrapper!.Payload);
+        }
+
+        [Fact]
+        public void Write_NullValue_WritesNull()
+        {
+            var obj = new Wrapper { Payload = null! };
+            var json = JsonSerializer.Serialize(obj, _opts);
+            Assert.Contains("\"Payload\":null", json);
+        }
+
+        [Fact]
+        public void Write_EmptyString_WritesEmptyString()
+        {
+            var obj = new Wrapper { Payload = string.Empty };
+            var json = JsonSerializer.Serialize(obj, _opts);
+            Assert.Contains("\"Payload\":\"\"", json);
+        }
+
+        [Fact]
+        public void Read_StringToken_ReturnsString()
+        {
+            var json = "{\"Payload\": \"simple text\"}";
+            var wrapper = JsonSerializer.Deserialize<Wrapper>(json, _opts);
+            Assert.Equal("simple text", wrapper!.Payload);
+        }
+
+        [Fact]
+        public void Roundtrip_ObjectPayload_PreservesStructure()
+        {
+            var obj = new Wrapper { Payload = "{\"key\":\"value\"}" };
+            var json = JsonSerializer.Serialize(obj, _opts);
+            var deserialized = JsonSerializer.Deserialize<Wrapper>(json, _opts);
+            Assert.Equal("{\"key\":\"value\"}", deserialized!.Payload);
+        }
     }
 }
diff --git a/src/WART-Tests/Services/WartEventQueueServiceTests.cs b/src/WART-Tests/Services/WartEventQueueServiceTests.cs
diff --git a/src/WART-Tests/Services/WartEventWorkerTests.cs b/src/WART-Tests/Services/WartEventWorkerTests.cs
diff --git a/src/WART-Tests/Utilities/LogSanitizerTests.cs b/src/WART-Tests/Utilities/LogSanitizerTests.cs

Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ public static async Task ConnectAsync(string wartHubUrl)`
`38`	`38`	`{`
`39`	`39`	`Console.WriteLine(exception);`
`40`	`40`	`Console.WriteLine(Environment.NewLine);`
`41`		`- await Task.Delay(new Random().Next(0, 5) * 1000);`
	`41`	`+ await Task.Delay(Random.Shared.Next(0, 5) * 1000);`
`42`	`42`	`await hubConnection.StartAsync();`
`43`	`43`	`};`
`44`	`44`
Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ public static async Task ConnectAsync(string wartHubUrl, string key)`
`43`	`43`	`{`
`44`	`44`	`Console.WriteLine(exception);`
`45`	`45`	`Console.WriteLine(Environment.NewLine);`
`46`		`- await Task.Delay(new Random().Next(0, 5) * 1000);`
	`46`	`+ await Task.Delay(Random.Shared.Next(0, 5) * 1000);`
`47`	`47`	`await hubConnection.StartAsync();`
`48`	`48`	`};`
`49`	`49`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`{`
`2`	`2`	`"Scheme": "https",`
`3`	`3`	`"Host": "localhost",`
`4`		`- "Port": "54644",`
	`4`	`+ "Port": "62198",`
`5`	`5`	`"Hubname": "warthub",`
`6`	`6`	`"AuthenticationType": "JWT",`
`7`	`7`	`"Key": "dn3341fmcscscwe28419brhwbwgbss4t",`