Janus007/PlanTempusApp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Extends Seq Logger with more Exception formatting.

Browse source
This commit is contained in:
Janus C. H. Knudsen 2025-02-17 23:08:37 +01:00
parent 440087c43b
commit a139b1ad08
2 changed files with 320 additions and 242 deletions
Download patch file Download diff file Expand all files Collapse all files

355
Core/Telemetry/SeqLogger.cs
View file

@ -1,185 +1,238 @@
using Microsoft.ApplicationInsights.DataContracts; using Microsoft.ApplicationInsights.Channel;
using Microsoft.ApplicationInsights.DataContracts;
using System.Text; using System.Text;
using System.Text.Json; using System.Text.Json;
namespace Core.Telemetry namespace Core.Telemetry
{ {
public record SeqConfiguration(string IngestionEndpoint, string ApiKey, string Environment); public record SeqConfiguration(string IngestionEndpoint, string ApiKey, string Environment);
public class SeqHttpClient public class SeqHttpClient
{ {
HttpClient _httpClient; 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) Timeout = TimeSpan.FromSeconds(30)
}; };
_httpClient.DefaultRequestHeaders.Accept.Clear(); _httpClient.DefaultRequestHeaders.Accept.Clear();
_httpClient.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json")); _httpClient.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
if (seqConfiguration.ApiKey != null) if (seqConfiguration.ApiKey != null)
_httpClient.DefaultRequestHeaders.Add("X-Seq-ApiKey", seqConfiguration.ApiKey); _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) public async Task<HttpResponseMessage> SendAsync(HttpRequestMessage httpRequestMessage, CancellationToken cancellationToken)
{ {
return await _httpClient.SendAsync(httpRequestMessage, cancellationToken); return await _httpClient.SendAsync(httpRequestMessage, cancellationToken);
} }
} }
public class SeqLogger public class SeqLogger
{ {
private readonly SeqHttpClient _httpClient; private readonly SeqHttpClient _httpClient;
private readonly string _environmentName; private readonly string _environmentName;
private readonly string _machineName; private readonly string _machineName;
private readonly SeqConfiguration _configuration; private readonly SeqConfiguration _configuration;
public SeqLogger(SeqHttpClient httpClient, string environmentName, SeqConfiguration configuration) public SeqLogger(SeqHttpClient httpClient, string environmentName, SeqConfiguration configuration)
{ {
_httpClient = httpClient; _httpClient = httpClient;
_environmentName = configuration.Environment; _environmentName = configuration.Environment;
_machineName = Environment.MachineName; _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> var seqEvent = new Dictionary<string, object>
{ {
{ "@t", trace.Timestamp.UtcDateTime.ToString("o") }, { "@t", trace.Timestamp.UtcDateTime.ToString("o") },
{ "@mt", trace.Message }, { "@mt", trace.Message },
{ "@l", MapSeverityToLevel(trace.SeverityLevel) }, { "@l", MapSeverityToLevel(trace.SeverityLevel) },
{ "Environment", _environmentName }, { "Environment", _environmentName },
{ "MachineName", _machineName } { "MachineName", _machineName }
}; };
foreach (var prop in trace.Properties) foreach (var prop in trace.Properties)
{ {
seqEvent.Add(prop.Key, prop.Value); seqEvent.Add(prop.Key, prop.Value);
} }
await SendToSeqAsync(seqEvent, cancellationToken); 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> var seqEvent = new Dictionary<string, object>
{ {
{ "@t", evt.Timestamp.UtcDateTime.ToString("o") }, { "@t", evt.Timestamp.UtcDateTime.ToString("o") },
{ "@mt", evt.Name }, { "@mt", evt.Name },
{ "@l", "Information" }, { "@l", "Information" },
{ "Environment", _environmentName }, { "Environment", _environmentName },
{ "MachineName", _machineName } { "MachineName", _machineName }
}; };
foreach (var prop in evt.Properties) foreach (var prop in evt.Properties)
{ {
seqEvent.Add(prop.Key, prop.Value); seqEvent.Add(prop.Key, prop.Value);
} }
foreach (var metric in evt.Metrics) foreach (var metric in evt.Metrics)
{ {
seqEvent.Add($"metric_{metric.Key}", metric.Value); seqEvent.Add($"metric_{metric.Key}", metric.Value);
} }
await SendToSeqAsync(seqEvent, cancellationToken); 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> var seqEvent = new Dictionary<string, object>
{ {
{ "@t", ex.Timestamp.UtcDateTime.ToString("o") }, { "@t", ex.Timestamp.UtcDateTime.ToString("o") },
{ "@mt", ex.Exception.Message }, { "@mt", ex.Exception.Message },
{ "@l", "Error" }, { "@l", "Error" },
{ "Environment", _environmentName }, { "@x", FormatExceptionForSeq(ex.Exception) },
{ "MachineName", _machineName }, { "Environment", _environmentName },
{ "ExceptionType", ex.Exception.GetType().Name }, { "MachineName", _machineName },
{ "StackTrace", ex.Exception.StackTrace } { "ExceptionType", ex.Exception.GetType().Name },
}; };
foreach (var prop in ex.Properties) foreach (var prop in ex.Properties)
{ {
seqEvent.Add(prop.Key, prop.Value); seqEvent.Add(prop.Key, prop.Value);
} }
await SendToSeqAsync(seqEvent, cancellationToken); 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> var seqEvent = new Dictionary<string, object>
{ {
{ "@t", dep.Timestamp.UtcDateTime.ToString("o") }, { "@t", dep.Timestamp.UtcDateTime.ToString("o") },
{ "@mt", $"Dependency: {dep.Name}" }, { "@mt", $"Dependency: {dep.Name}" },
{ "@l", dep.Success??true ? "Information" : "Error" }, { "@l", dep.Success??true ? "Information" : "Error" },
{ "Environment", _environmentName }, { "Environment", _environmentName },
{ "MachineName", _machineName }, { "MachineName", _machineName },
{ "DependencyType", dep.Type }, { "DependencyType", dep.Type },
{ "Target", dep.Target }, { "Target", dep.Target },
{ "Duration", dep.Duration.TotalMilliseconds } { "Duration", dep.Duration.TotalMilliseconds }
}; };
foreach (var prop in dep.Properties) foreach (var prop in dep.Properties)
{ {
seqEvent.Add(prop.Key, prop.Value); seqEvent.Add(prop.Key, prop.Value);
} }
await SendToSeqAsync(seqEvent, cancellationToken); 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> var seqEvent = new Dictionary<string, object>
{ {
{ "@t", req.Timestamp.UtcDateTime.ToString("o") }, { "@t", req.Timestamp.UtcDateTime.ToString("o") },
{ "@mt", $"Request: {req.Name}" }, { "@mt", $"Request: {req.Name}" },
{ "@l", req.Success??true ? "Information" : "Error" }, { "@l", req.Success??true ? "Information" : "Error" },
{ "Environment", _environmentName }, { "Environment", _environmentName },
{ "MachineName", _machineName }, { "MachineName", _machineName },
{ "Url", req.Url }, { "Url", req.Url },
{ "ResponseCode", req.ResponseCode }, { "ResponseCode", req.ResponseCode },
{ "Duration", req.Duration.TotalMilliseconds } { "Duration", req.Duration.TotalMilliseconds }
}; };
foreach (var prop in req.Properties) foreach (var prop in req.Properties)
{ {
seqEvent.Add(prop.Key, prop.Value); seqEvent.Add(prop.Key, prop.Value);
} }
await SendToSeqAsync(seqEvent, cancellationToken); await SendToSeqAsync(seqEvent, cancellationToken);
} }
private async Task SendToSeqAsync(Dictionary<string, object> seqEvent, CancellationToken cancellationToken) private async Task SendToSeqAsync(Dictionary<string, object> seqEvent, CancellationToken cancellationToken)
{ {
var content = new StringContent( var content = new StringContent(
Newtonsoft.Json.JsonConvert.SerializeObject(seqEvent), Newtonsoft.Json.JsonConvert.SerializeObject(seqEvent),
Encoding.UTF8, Encoding.UTF8,
"application/vnd.serilog.clef"); "application/vnd.serilog.clef");
var requestMessage = new HttpRequestMessage(HttpMethod.Post, "/ingest/clef") var requestMessage = new HttpRequestMessage(HttpMethod.Post, "/ingest/clef")
{ {
Content = content Content = content
}; };
await _httpClient.SendAsync(requestMessage, cancellationToken); var result = await _httpClient.SendAsync(requestMessage, cancellationToken);
}
private string MapSeverityToLevel(SeverityLevel? severity) result.EnsureSuccessStatusCode();
{ }
return severity switch
{ private string MapSeverityToLevel(SeverityLevel? severity)
SeverityLevel.Verbose => "Verbose", {
SeverityLevel.Information => "Information", return severity switch
SeverityLevel.Warning => "Warning", {
SeverityLevel.Error => "Error", SeverityLevel.Verbose => "Verbose",
SeverityLevel.Critical => "Fatal", SeverityLevel.Information => "Information",
_ => "Information" SeverityLevel.Warning => "Warning",
}; SeverityLevel.Error => "Error",
} SeverityLevel.Critical => "Fatal",
} _ => "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();
}
}
} }

207
Tests/TelemetryLogging/SeqLoggerTests.cs
View file

@ -1,109 +1,134 @@
using Core.Telemetry; using Core.Telemetry;
using Microsoft.ApplicationInsights.Channel;
using Microsoft.ApplicationInsights.DataContracts; using Microsoft.ApplicationInsights.DataContracts;
namespace Tests.TelemetryLogging namespace Tests.TelemetryLogging
{ {
[TestClass] [TestClass]
public class SeqLoggerTests : TestFixture public class SeqLoggerTests : TestFixture
{ {
private SeqLogger _logger; private SeqLogger _logger;
private SeqHttpClient _httpClient; private SeqHttpClient _httpClient;
private readonly string _testId; private readonly string _testId;
public SeqLoggerTests() public SeqLoggerTests()
{ {
_testId = Guid.NewGuid().ToString(); _testId = Guid.NewGuid().ToString();
var config = new SeqConfiguration("http://localhost:5341", null, "MSTEST"); var config = new SeqConfiguration("http://localhost:5341", null, "MSTEST");
_httpClient = new SeqHttpClient(config); _httpClient = new SeqHttpClient(config);
_logger = new SeqLogger(_httpClient, Environment.MachineName, config); _logger = new SeqLogger(_httpClient, Environment.MachineName, config);
} }
[TestMethod] [TestMethod]
public async Task LogTraceTelemetry_SendsCorrectData() public async Task LogTraceTelemetry_SendsCorrectDataWithErrorLevel()
{ {
// Arrange // Arrange
var traceTelemetry = new TraceTelemetry var traceTelemetry = new TraceTelemetry
{ {
Message = "Test trace message", Message = "Test trace error message",
SeverityLevel = SeverityLevel.Error, SeverityLevel = SeverityLevel.Error,
Timestamp = DateTimeOffset.UtcNow Timestamp = DateTimeOffset.UtcNow
}; };
traceTelemetry.Properties.Add("TestId", _testId); traceTelemetry.Properties.Add("TestId", _testId);
// Act // Act
await _logger.LogTraceTelemetryAsync(traceTelemetry); await _logger.LogAsync(traceTelemetry);
// Du kan nu tjekke Seq med følgende query: // Du kan nu tjekke Seq med følgende query:
// TestId = 'guid-værdi-her' // 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);
[TestMethod] // Act
public async Task LogEventTelemetry_SendsCorrectData() await _logger.LogAsync(traceTelemetry);
{
// Arrange
var eventTelemetry = new EventTelemetry
{
Name = "Test Event",
Timestamp = DateTimeOffset.UtcNow
};
eventTelemetry.Properties.Add("TestId", _testId);
eventTelemetry.Metrics.Add("TestMetric", 42.0);
// Act }
await _logger.LogEventTelemetryAsync(eventTelemetry); [TestMethod]
} public async Task LogEventTelemetry_SendsCorrectData()
{
// Arrange
var eventTelemetry = new EventTelemetry
{
Name = "Test Event",
Timestamp = DateTimeOffset.UtcNow
};
eventTelemetry.Properties.Add("TestId", _testId);
eventTelemetry.Metrics.Add("TestMetric", 42.0);
[TestMethod] // Act
public async Task LogExceptionTelemetry_SendsCorrectData() await _logger.LogAsync(eventTelemetry);
{ }
// Arrange
var exception = new Exception("Test exception");
var exceptionTelemetry = new ExceptionTelemetry(exception)
{
Timestamp = DateTimeOffset.UtcNow
};
exceptionTelemetry.Properties.Add("TestId", _testId);
// Act [TestMethod]
await _logger.LogExceptionTelemetryAsync(exceptionTelemetry); public async Task LogExceptionTelemetry_SendsCorrectData()
} {
try
{
int t = 0;
var result = 10 / t;
[TestMethod] }
public async Task LogDependencyTelemetry_SendsCorrectData() catch (Exception e)
{ {
// Arrange
var dependencyTelemetry = new DependencyTelemetry
{
Name = "SQL Query",
Type = "SQL",
Target = "TestDB",
Success = true,
Duration = TimeSpan.FromMilliseconds(100),
Timestamp = DateTimeOffset.UtcNow
};
dependencyTelemetry.Properties.Add("TestId", _testId);
// Act // Arrange
await _logger.LogDependencyTelemetryAsync(dependencyTelemetry); var exceptionTelemetry = new ExceptionTelemetry(e)
} {
Timestamp = DateTimeOffset.UtcNow
};
exceptionTelemetry.Properties.Add("TestId", _testId);
[TestMethod] // Act
public async Task LogRequestTelemetry_SendsCorrectData() await _logger.LogAsync(exceptionTelemetry);
{ }
// Arrange }
var requestTelemetry = new RequestTelemetry
{
Name = "GET /api/test",
Success = true,
ResponseCode = "200",
Duration = TimeSpan.FromMilliseconds(50),
Url = new Uri("http://test.com/api/test"),
Timestamp = DateTimeOffset.UtcNow
};
requestTelemetry.Properties.Add("TestId", _testId);
// Act [TestMethod]
await _logger.LogRequestTelemetryAsync(requestTelemetry); public async Task LogDependencyTelemetry_SendsCorrectData()
} {
} // Arrange
var dependencyTelemetry = new DependencyTelemetry
{
Name = "SQL Query",
Type = "SQL",
Target = "TestDB",
Success = true,
Duration = TimeSpan.FromMilliseconds(100),
Timestamp = DateTimeOffset.UtcNow
};
dependencyTelemetry.Properties.Add("TestId", _testId);
// Act
await _logger.LogAsync(dependencyTelemetry);
}
[TestMethod]
public async Task LogRequestTelemetry_SendsCorrectData()
{
// Arrange
var requestTelemetry = new RequestTelemetry
{
Name = "GET /api/test",
Success = true,
ResponseCode = "200",
Duration = TimeSpan.FromMilliseconds(50),
Url = new Uri("http://test.com/api/test"),
Timestamp = DateTimeOffset.UtcNow
};
requestTelemetry.Properties.Add("TestId", _testId);
// Act
await _logger.LogAsync(requestTelemetry);
}
}
} }