Extends Seq Logger with more Exception formatting.

Core/Telemetry/SeqLogger.cs

@@ -1,4 +1,5 @@
-using Microsoft.ApplicationInsights.DataContracts;
+using Microsoft.ApplicationInsights.Channel;
+using Microsoft.ApplicationInsights.DataContracts;
 using System.Text;
 using System.Text.Json;
 
@@ -11,11 +12,11 @@ namespace Core.Telemetry
     {
         HttpClient _httpClient;
 
-		public SeqHttpClient(SeqConfiguration seqConfiguration)
+        public SeqHttpClient(SeqConfiguration seqConfiguration, HttpMessageHandler httpMessageHandler)
         {
-			_httpClient = new HttpClient()
+            _httpClient = new HttpClient(httpMessageHandler)
             {
-				BaseAddress = new Uri("http://localhost:5341"),
+                BaseAddress = new Uri(seqConfiguration.IngestionEndpoint),
                 Timeout = TimeSpan.FromSeconds(30)
             };
 
@@ -24,6 +25,7 @@ namespace Core.Telemetry
             if (seqConfiguration.ApiKey != null)
                 _httpClient.DefaultRequestHeaders.Add("X-Seq-ApiKey", seqConfiguration.ApiKey);
         }
+        public SeqHttpClient(SeqConfiguration seqConfiguration) : this(seqConfiguration, new HttpClientHandler()) { }
 
         public async Task<HttpResponseMessage> SendAsync(HttpRequestMessage httpRequestMessage, CancellationToken cancellationToken)
         {
@@ -46,7 +48,7 @@ namespace Core.Telemetry
             _machineName = Environment.MachineName;
         }
 
-		public async Task LogTraceTelemetryAsync(TraceTelemetry trace, CancellationToken cancellationToken = default)
+        public async Task LogAsync(TraceTelemetry trace, CancellationToken cancellationToken = default)
         {
             var seqEvent = new Dictionary<string, object>
         {
@@ -65,7 +67,7 @@ namespace Core.Telemetry
             await SendToSeqAsync(seqEvent, cancellationToken);
         }
 
-		public async Task LogEventTelemetryAsync(EventTelemetry evt, CancellationToken cancellationToken = default)
+        public async Task LogAsync(EventTelemetry evt, CancellationToken cancellationToken = default)
         {
             var seqEvent = new Dictionary<string, object>
         {
@@ -89,17 +91,17 @@ namespace Core.Telemetry
             await SendToSeqAsync(seqEvent, cancellationToken);
         }
 
-		public async Task LogExceptionTelemetryAsync(ExceptionTelemetry ex, CancellationToken cancellationToken = default)
+        public async Task LogAsync(ExceptionTelemetry ex, CancellationToken cancellationToken = default)
         {
             var seqEvent = new Dictionary<string, object>
         {
             { "@t", ex.Timestamp.UtcDateTime.ToString("o") },
             { "@mt", ex.Exception.Message },
             { "@l", "Error" },
+            { "@x", FormatExceptionForSeq(ex.Exception) },
             { "Environment", _environmentName },
             { "MachineName", _machineName },
             { "ExceptionType", ex.Exception.GetType().Name },
-			{ "StackTrace", ex.Exception.StackTrace }
         };
 
             foreach (var prop in ex.Properties)
@@ -110,7 +112,7 @@ namespace Core.Telemetry
             await SendToSeqAsync(seqEvent, cancellationToken);
         }
 
-		public async Task LogDependencyTelemetryAsync(DependencyTelemetry dep, CancellationToken cancellationToken = default)
+        public async Task LogAsync(DependencyTelemetry dep, CancellationToken cancellationToken = default)
         {
             var seqEvent = new Dictionary<string, object>
         {
@@ -132,7 +134,7 @@ namespace Core.Telemetry
             await SendToSeqAsync(seqEvent, cancellationToken);
         }
 
-		public async Task LogRequestTelemetryAsync(RequestTelemetry req, CancellationToken cancellationToken = default)
+        public async Task LogAsync(RequestTelemetry req, CancellationToken cancellationToken = default)
         {
             var seqEvent = new Dictionary<string, object>
         {
@@ -166,7 +168,9 @@ namespace Core.Telemetry
                 Content = content
             };
 
-			await _httpClient.SendAsync(requestMessage, cancellationToken);
+            var result = await _httpClient.SendAsync(requestMessage, cancellationToken);
+
+            result.EnsureSuccessStatusCode();
         }
 
         private string MapSeverityToLevel(SeverityLevel? severity)
@@ -181,5 +185,54 @@ namespace Core.Telemetry
                 _ => "Information"
             };
         }
+        private string FormatExceptionForSeq(Exception ex)
+        {
+            var sb = new StringBuilder();
+            var exceptionCount = 0;
+
+            void FormatSingleException(Exception currentEx, int depth)
+            {
+                if (depth > 0) sb.AppendLine("\n--- Inner Exception ---");
+
+                sb.AppendLine($"Exception Type: {currentEx.GetType().FullName}");
+                sb.AppendLine($"Message: {currentEx.Message}");
+                sb.AppendLine($"Source: {currentEx.Source}");
+                sb.AppendLine($"HResult: 0x{currentEx.HResult:X8}");
+                sb.AppendLine("Stack Trace:");
+                sb.AppendLine(currentEx.StackTrace?.Trim());
+
+                if (currentEx.Data.Count > 0)
+                {
+                    sb.AppendLine("Additional Data:");
+                    foreach (var key in currentEx.Data.Keys)
+                    {
+                        sb.AppendLine($"  {key}: {currentEx.Data[key]}");
+                    }
+                }
+            }
+
+            void RecurseExceptions(Exception currentEx, int depth = 0)
+            {
+                if (currentEx is AggregateException aggEx)
+                {
+                    foreach (var inner in aggEx.InnerExceptions)
+                    {
+                        RecurseExceptions(inner, depth);
+                        depth++;
+                    }
+                }
+                else if (currentEx.InnerException != null)
+                {
+                    RecurseExceptions(currentEx.InnerException, depth + 1);
+                }
+
+                FormatSingleException(currentEx, depth);
+                exceptionCount++;
+            }
+
+            RecurseExceptions(ex);
+            sb.Insert(0, $"EXCEPTION CHAIN ({exceptionCount} exceptions):\n");
+            return sb.ToString();
+        }
     }
 }

Tests/TelemetryLogging/SeqLoggerTests.cs

@@ -1,4 +1,5 @@
 using Core.Telemetry;
+using Microsoft.ApplicationInsights.Channel;
 using Microsoft.ApplicationInsights.DataContracts;
 
 namespace Tests.TelemetryLogging
@@ -19,24 +20,39 @@ namespace Tests.TelemetryLogging
         }
 
         [TestMethod]
-		public async Task LogTraceTelemetry_SendsCorrectData()
+        public async Task LogTraceTelemetry_SendsCorrectDataWithErrorLevel()
         {
             // Arrange
             var traceTelemetry = new TraceTelemetry
             {
-				Message = "Test trace message",
+                Message = "Test trace error message",
                 SeverityLevel = SeverityLevel.Error,
                 Timestamp = DateTimeOffset.UtcNow
             };
             traceTelemetry.Properties.Add("TestId", _testId);
 
             // Act
-			await _logger.LogTraceTelemetryAsync(traceTelemetry);
+            await _logger.LogAsync(traceTelemetry);
 
             // Du kan nu tjekke Seq med følgende query:
             // TestId = 'guid-værdi-her'
         }
+        [TestMethod]
+        public async Task LogTraceTelemetry_SendsCorrectDataWithWarningLevel()
+        {
+            // Arrange
+            var traceTelemetry = new TraceTelemetry
+            {
+                Message = "Test trace warning message",
+                SeverityLevel = SeverityLevel.Warning,
+                Timestamp = DateTimeOffset.UtcNow
+            };
+            traceTelemetry.Properties.Add("TestId", _testId);
 
+            // Act
+            await _logger.LogAsync(traceTelemetry);
+
+        }
         [TestMethod]
         public async Task LogEventTelemetry_SendsCorrectData()
         {
@@ -50,22 +66,31 @@ namespace Tests.TelemetryLogging
             eventTelemetry.Metrics.Add("TestMetric", 42.0);
 
             // Act
-			await _logger.LogEventTelemetryAsync(eventTelemetry);
+            await _logger.LogAsync(eventTelemetry);
         }
 
         [TestMethod]
         public async Task LogExceptionTelemetry_SendsCorrectData()
         {
+            try
+            {
+                int t = 0;
+                var result = 10 / t;
+
+            }
+            catch (Exception e)
+            {
+
                 // Arrange
-			var exception = new Exception("Test exception");
+                var exceptionTelemetry = new ExceptionTelemetry(e)
-			var exceptionTelemetry = new ExceptionTelemetry(exception)
                 {
                     Timestamp = DateTimeOffset.UtcNow
                 };
                 exceptionTelemetry.Properties.Add("TestId", _testId);
 
                 // Act
-			await _logger.LogExceptionTelemetryAsync(exceptionTelemetry);
+                await _logger.LogAsync(exceptionTelemetry);
+            }
         }
 
         [TestMethod]
@@ -84,7 +109,7 @@ namespace Tests.TelemetryLogging
             dependencyTelemetry.Properties.Add("TestId", _testId);
 
             // Act
-			await _logger.LogDependencyTelemetryAsync(dependencyTelemetry);
+            await _logger.LogAsync(dependencyTelemetry);
         }
 
         [TestMethod]
@@ -103,7 +128,7 @@ namespace Tests.TelemetryLogging
             requestTelemetry.Properties.Add("TestId", _testId);
 
             // Act
-			await _logger.LogRequestTelemetryAsync(requestTelemetry);
+            await _logger.LogAsync(requestTelemetry);
         }
     }
 }