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

This is near the end of this Seq Logging Implementation

Browse source
This commit is contained in:
Janus C. H. Knudsen 2025-02-22 20:14:56 +01:00
parent 78d49a9829
commit 099f6467d2
9 changed files with 212 additions and 123 deletions
Download patch file Download diff file Expand all files Collapse all files

5
Core/Logging/SeqBackgroundService.cs
View file

@ -19,6 +19,9 @@ namespace PlanTempus.Core.Logging
_telemetryClient = telemetryClient; _telemetryClient = telemetryClient;
_messageChannel = messageChannel; _messageChannel = messageChannel;
_seqLogger = seqlogger; _seqLogger = seqlogger;
_telemetryClient.TrackTrace("SeqBackgroundService started");
} }
protected override async Task ExecuteAsync(CancellationToken stoppingToken) protected override async Task ExecuteAsync(CancellationToken stoppingToken)
@ -72,12 +75,12 @@ namespace PlanTempus.Core.Logging
throw; throw;
} }
_telemetryClient.TrackTrace("Service shutdown started");
} }
} }
public override async Task StopAsync(CancellationToken cancellationToken) public override async Task StopAsync(CancellationToken cancellationToken)
{ {
_telemetryClient.TrackTrace("StopAsync called: Service shutdown started");
_messageChannel.Dispose(); _messageChannel.Dispose();
await base.StopAsync(cancellationToken); await base.StopAsync(cancellationToken);
} }

37
Core/ModuleRegistry/SeqLoggingModule.cs
View file

@ -1,32 +1,31 @@
using Autofac; using Autofac;
using PlanTempus.Core.Logging; using PlanTempus.Core.Logging;
using PlanTempus.Core.Telemetry;
namespace PlanTempus.Core.ModuleRegistry namespace PlanTempus.Core.ModuleRegistry
{ {
public class SeqLoggingModule : Module public class SeqLoggingModule : Module
{ {
public required SeqConfiguration SeqConfiguration { get; set; } public required SeqConfiguration SeqConfiguration { get; set; }
protected override void Load(ContainerBuilder builder) protected override void Load(ContainerBuilder builder)
{ {
//builder.RegisterType<MessageChannel>() //builder.RegisterType<MessageChannel>()
// .As<IMessageChannel<Microsoft.ApplicationInsights.Channel.ITelemetry>>() // .As<IMessageChannel<Microsoft.ApplicationInsights.Channel.ITelemetry>>()
// .SingleInstance(); // .SingleInstance();
builder.RegisterType<SeqBackgroundService>() builder.RegisterType<SeqBackgroundService>()
.As<Microsoft.Extensions.Hosting.IHostedService>() //.As<Microsoft.Extensions.Hosting.IHostedService>()
.SingleInstance(); .SingleInstance();
builder.RegisterGeneric(typeof(SeqLogger<>)); builder.RegisterGeneric(typeof(SeqLogger<>));
builder.RegisterInstance(SeqConfiguration); builder.RegisterInstance(SeqConfiguration);
builder.RegisterType<SeqHttpClient>() builder.RegisterType<SeqHttpClient>()
.As<SeqHttpClient>() .As<SeqHttpClient>()
.SingleInstance(); .SingleInstance();
} }
} }
} }

18
Core/ModuleRegistry/TelemetryModule.cs
View file

@ -15,6 +15,14 @@ namespace PlanTempus.Core.ModuleRegistry
configuration.ConnectionString = TelemetryConfig.ConnectionString; configuration.ConnectionString = TelemetryConfig.ConnectionString;
configuration.TelemetryChannel.DeveloperMode = true; configuration.TelemetryChannel.DeveloperMode = true;
var client = new Microsoft.ApplicationInsights.TelemetryClient(configuration);
client.Context.GlobalProperties["Application"] = GetType().Namespace.Split('.')[0];
client.Context.GlobalProperties["MachineName"] = Environment.MachineName;
client.Context.GlobalProperties["Version"] = Environment.Version.ToString();
client.Context.GlobalProperties["ProcessorCount"] = Environment.ProcessorCount.ToString();
builder.Register(c => client).InstancePerLifetimeScope();
if (TelemetryConfig.UseSeqLoggingTelemetryChannel) if (TelemetryConfig.UseSeqLoggingTelemetryChannel)
{ {
var messageChannel = new Telemetry.MessageChannel(); var messageChannel = new Telemetry.MessageChannel();
@ -23,21 +31,13 @@ namespace PlanTempus.Core.ModuleRegistry
.As<Telemetry.IMessageChannel<ITelemetry>>() .As<Telemetry.IMessageChannel<ITelemetry>>()
.SingleInstance(); .SingleInstance();
configuration.TelemetryChannel = new Telemetry.SeqLoggingTelemetryChannel(messageChannel); configuration.TelemetryChannel = new Telemetry.SeqTelemetryChannel(messageChannel, client);
} }
var telemetryProcessorChain = new Microsoft.ApplicationInsights.Extensibility.Implementation.TelemetryProcessorChainBuilder(configuration); var telemetryProcessorChain = new Microsoft.ApplicationInsights.Extensibility.Implementation.TelemetryProcessorChainBuilder(configuration);
telemetryProcessorChain.Use(next => new Telemetry.Enrichers.EnrichWithMetaTelemetry(next)); telemetryProcessorChain.Use(next => new Telemetry.Enrichers.EnrichWithMetaTelemetry(next));
telemetryProcessorChain.Build(); telemetryProcessorChain.Build();
var client = new Microsoft.ApplicationInsights.TelemetryClient(configuration);
client.Context.GlobalProperties["Application"] = GetType().Namespace.Split('.')[0];
client.Context.GlobalProperties["MachineName"] = Environment.MachineName;
client.Context.GlobalProperties["Version"] = Environment.Version.ToString();
client.Context.GlobalProperties["ProcessorCount"] = Environment.ProcessorCount.ToString();
builder.Register(c => client).InstancePerLifetimeScope();
} }
} }

27
Core/Telemetry/SeqLoggingTelemetryChannel.cs
View file

@ -1,27 +0,0 @@
using Microsoft.ApplicationInsights.Channel;
namespace PlanTempus.Core.Telemetry
{
public class SeqLoggingTelemetryChannel : InMemoryChannel, ITelemetryChannel
{
private readonly IMessageChannel<ITelemetry> _messageChannel;
public SeqLoggingTelemetryChannel(IMessageChannel<ITelemetry> messageChannel)
{
_messageChannel = messageChannel;
}
public new void Send(ITelemetry telemetry)
{
var writeTask = _messageChannel.Writer.WriteAsync(telemetry).AsTask();
writeTask.ContinueWith(t =>
{
if (t.Exception != null)
{
throw t.Exception;
}
}, TaskContinuationOptions.OnlyOnFaulted);
base.Send(telemetry);
}
}
}

37
Core/Telemetry/SeqTelemetryChannel.cs Normal file
View file

@ -0,0 +1,37 @@
using Microsoft.ApplicationInsights;
using Microsoft.ApplicationInsights.Channel;
namespace PlanTempus.Core.Telemetry
{
public class SeqTelemetryChannel : InMemoryChannel, ITelemetryChannel
{
private readonly IMessageChannel<ITelemetry> _messageChannel;
private readonly TelemetryClient _telemetryClient;
public SeqTelemetryChannel(IMessageChannel<ITelemetry> messageChannel, TelemetryClient telemetryClient)
{
_messageChannel = messageChannel;
_telemetryClient = telemetryClient;
}
public new void Send(ITelemetry telemetry)
{
if (telemetry.Context.GlobalProperties["OmitSeqTelemetryChannel"] != "true")
try
{
var writeTask = _messageChannel.Writer.WriteAsync(telemetry).AsTask();
writeTask.ContinueWith(t =>
{
if (t.Exception != null)
{
throw t.Exception;
}
}, TaskContinuationOptions.OnlyOnFaulted);
}
catch (Exception e)
{
_telemetryClient.TrackException(e, new Dictionary<string, string> { { "OmitSeqTelemetryChannel", "true" } });
}
base.Send(telemetry);
}
}
}

4
Tests/Logging/SeqBackgroundServiceTest.cs
View file

@ -32,9 +32,7 @@ namespace PlanTempus.Tests.Logging
[TestMethod] [TestMethod]
public async Task Messages_ShouldBeProcessedFromQueue() public async Task Messages_ShouldBeProcessedFromQueue()
{ {
var processedMessages = new List<HttpRequestMessage>(); await _service.StartAsync(_cts.Token);
var serviceTask = _service.StartAsync(_cts.Token);
for (int i = 0; i < 5; i++) for (int i = 0; i < 5; i++)
{ {

4
Tests/Logging/SeqLoggerTests.cs
View file

@ -112,6 +112,10 @@ namespace PlanTempus.Tests.Logging
await _logger.LogAsync(dependencyTelemetry); await _logger.LogAsync(dependencyTelemetry);
} }
/// <summary>
/// This is for scope test in SeqLogger. It is not testing anything related to the TelemetryChannel which logs to Seq.
/// </summary>
/// <returns></returns>
[TestMethod] [TestMethod]
public async Task LogRequestTelemetryInOperationHolderWithParentChild_SendsCorrectData() public async Task LogRequestTelemetryInOperationHolderWithParentChild_SendsCorrectData()
{ {

70
Tests/Logging/SeqTelemetryChannelTest.cs Normal file
View file

@ -0,0 +1,70 @@
using Autofac;
using Microsoft.ApplicationInsights;
using Microsoft.ApplicationInsights.Channel;
using Microsoft.ApplicationInsights.DataContracts;
using PlanTempus.Core.Logging;
using PlanTempus.Core.Telemetry;
namespace PlanTempus.Tests.Logging
{
[TestClass]
public class SeqTelemetryChannelTest : TestFixture
{
private IMessageChannel<ITelemetry> _messageChannel;
TelemetryClient _telemetryClient;
private SeqBackgroundService _service;
private CancellationTokenSource _cts;
[TestInitialize]
public void SetupThis()
{
//it is important to use the same MessageChannel as the BackgroundService uses
//we know that IMessageChannel<ITelemetry> _messageChannel; is registered via Autofac and manually injected into SeqBackgroundService
//so we can get it by calling the Autofac Container in this test.
_messageChannel = Container.Resolve<IMessageChannel<ITelemetry>>();
_service = Container.Resolve<SeqBackgroundService>();
_telemetryClient = Container.Resolve<TelemetryClient>();
_cts = new CancellationTokenSource();
}
[TestMethod]
public async Task Messages_ShouldBeProcessedFromQueue()
{
await _service.StartAsync(_cts.Token);
for (int i = 0; i < 5; i++)
{
var eventTelemetry = new EventTelemetry
{
Name = "Test Event 3",
Timestamp = DateTimeOffset.UtcNow
};
eventTelemetry.Properties.Add("TestId", Guid.NewGuid().ToString());
eventTelemetry.Metrics.Add("TestMetric", 42.0);
//we don't write to the _messageChannel.Writer.WriteAsync(eventTelemetry);, but the TelemetryClient which is configured to use SeqTelemetryChannel
_telemetryClient.TrackEvent(eventTelemetry);
}
// wait for processing
await Task.Delay(5000);
//_cts.Cancel();
await _service.StopAsync(CancellationToken.None);
bool hasMoreMessages = await _messageChannel.Reader.WaitToReadAsync();
Assert.IsFalse(hasMoreMessages, "Queue should be empty after 5 seconds");
}
[TestCleanup]
public void Cleanup()
{
_cts?.Dispose();
}
}
}

133
Tests/TestFixture.cs
View file

@ -8,84 +8,89 @@ using PlanTempus.Core.Configurations.JsonConfigProvider;
using PlanTempus.Core.ModuleRegistry; using PlanTempus.Core.ModuleRegistry;
namespace PlanTempus.Tests namespace PlanTempus.Tests
{ {
/// <summary> /// <summary>
/// Act as base class for tests. Avoids duplication of test setup code /// Act as base class for tests. Avoids duplication of test setup code
/// </summary> /// </summary>
[TestClass] [TestClass]
public abstract partial class TestFixture public abstract partial class TestFixture
{ {
private readonly string _configurationFilePath; private readonly string _configurationFilePath;
protected IContainer Container { get; private set; } protected IContainer Container { get; private set; }
protected ContainerBuilder ContainerBuilder { get; private set; } protected ContainerBuilder ContainerBuilder { get; private set; }
public virtual IConfigurationRoot Configuration() public virtual IConfigurationRoot Configuration()
{ {
var configuration = new ConfigurationBuilder() var configuration = new ConfigurationBuilder()
.AddJsonFile($"{_configurationFilePath}appconfiguration.dev.json") .AddJsonFile($"{_configurationFilePath}appconfiguration.dev.json")
.Build(); .Build();
return configuration; return configuration;
} }
protected TestFixture() : this(null) { } protected TestFixture() : this(null) { }
public TestFixture(string configurationFilePath) public TestFixture(string configurationFilePath)
{ {
if (configurationFilePath is not null) if (configurationFilePath is not null)
_configurationFilePath = configurationFilePath?.TrimEnd('/') + "/"; _configurationFilePath = configurationFilePath?.TrimEnd('/') + "/";
CreateContainerBuilder(); CreateContainerBuilder();
Container = ContainerBuilder.Build(); Container = ContainerBuilder.Build();
} }
protected virtual void CreateContainerBuilder() protected virtual void CreateContainerBuilder()
{ {
IConfigurationRoot configuration = Configuration(); IConfigurationRoot configuration = Configuration();
//var logger = new LoggerConfiguration() //var logger = new LoggerConfiguration()
// .MinimumLevel.Verbose() // .MinimumLevel.Verbose()
// .MinimumLevel.Override("Microsoft", Serilog.Events.LogEventLevel.Warning) // .MinimumLevel.Override("Microsoft", Serilog.Events.LogEventLevel.Warning)
// .MinimumLevel.Override("System", Serilog.Events.LogEventLevel.Error) // .MinimumLevel.Override("System", Serilog.Events.LogEventLevel.Error)
// .WriteTo.Seq("http://localhost:5341", apiKey: "Gt8hS9ClGNfOCAdswDlW") // .WriteTo.Seq("http://localhost:5341", apiKey: "Gt8hS9ClGNfOCAdswDlW")
// .WriteTo.ApplicationInsights(configuration.Get<string>("ApplicationInsights:ConnectionString"), // .WriteTo.ApplicationInsights(configuration.Get<string>("ApplicationInsights:ConnectionString"),
// TelemetryConverter.Traces) // TelemetryConverter.Traces)
// .Enrich.FromLogContext() // .Enrich.FromLogContext()
// .Enrich.WithMachineName() // .Enrich.WithMachineName()
// .CreateLogger(); // .CreateLogger();
var builder = new ContainerBuilder(); var builder = new ContainerBuilder();
builder.RegisterGeneric(typeof(Logger<>)) builder.RegisterGeneric(typeof(Logger<>))
.As(typeof(ILogger<>)) .As(typeof(ILogger<>))
.SingleInstance(); .SingleInstance();
builder.RegisterModule(new Database.ModuleRegistry.DbPostgreSqlModule builder.RegisterModule(new Database.ModuleRegistry.DbPostgreSqlModule
{ {
ConnectionString = configuration.GetConnectionString("DefaultConnection") ConnectionString = configuration.GetConnectionString("DefaultConnection")
}); });
builder.RegisterModule(new TelemetryModule builder.RegisterModule(new TelemetryModule
{ {
TelemetryConfig = configuration.GetSection("ApplicationInsights").ToObject<TelemetryConfig>() TelemetryConfig = configuration.GetSection("ApplicationInsights").ToObject<TelemetryConfig>()
}); });
builder.RegisterModule(new SeqLoggingModule
{
SeqConfiguration = configuration.GetSection("SeqConfiguration").ToObject<Core.Logging.SeqConfiguration>()
});
ContainerBuilder = builder; ContainerBuilder = builder;
} }
[TestCleanup] [TestCleanup]
public void CleanUp() public void CleanUp()
{ {
Trace.Flush(); Trace.Flush();
var telemetryClient = Container.Resolve<TelemetryClient>(); var telemetryClient = Container.Resolve<TelemetryClient>();
telemetryClient.Flush(); telemetryClient.Flush();
if (Container != null) if (Container != null)
{ {
Container.Dispose(); Container.Dispose();
Container = null; Container = null;
} }
} }
} }
} }