Initial commits

examples/Cli/Logging/Infrastructure/LogInterceptor.cs

@@ -0,0 +1,19 @@
+using Logging.Commands;
+using Serilog.Core;
+using Spectre.Console.Cli;
+
+namespace Logging.Infrastructure;
+
+public class LogInterceptor : ICommandInterceptor
+{
+    public static readonly LoggingLevelSwitch LogLevel = new();
+
+    public void Intercept(CommandContext context, CommandSettings settings)
+    {
+        if (settings is LogCommandSettings logSettings)
+        {
+            LoggingEnricher.Path = logSettings.LogFile ?? "application.log";
+            LogLevel.MinimumLevel = logSettings.LogLevel;
+        }
+    }
+}

examples/Cli/Logging/Infrastructure/LoggingEnricher.cs

@@ -0,0 +1,37 @@
+using Serilog.Core;
+using Serilog.Events;
+
+namespace Logging.Infrastructure;
+
+internal class LoggingEnricher : ILogEventEnricher
+{
+    private string _cachedLogFilePath;
+    private LogEventProperty _cachedLogFilePathProperty;
+
+    // this path and level will be set by the LogInterceptor.cs after parsing the settings
+    public static string Path = string.Empty;
+
+    public const string LogFilePathPropertyName = "LogFilePath";
+
+    public void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory)
+    {
+        // the settings might not have a path or we might not be within a command in which case
+        // we won't have the setting so a default value for the log file will be required
+        LogEventProperty logFilePathProperty;
+
+        if (_cachedLogFilePathProperty != null && Path.Equals(_cachedLogFilePath))
+        {
+            // Path hasn't changed, so let's use the cached property
+            logFilePathProperty = _cachedLogFilePathProperty;
+        }
+        else
+        {
+            // We've got a new path for the log. Let's create a new property
+            // and cache it for future log events to use
+            _cachedLogFilePath = Path;
+            _cachedLogFilePathProperty = logFilePathProperty = propertyFactory.CreateProperty(LogFilePathPropertyName, Path);
+        }
+
+        logEvent.AddPropertyIfAbsent(logFilePathProperty);
+    }
+}

examples/Cli/Logging/Infrastructure/TypeRegistrar.cs

@@ -0,0 +1,40 @@
+using System;
+using Microsoft.Extensions.DependencyInjection;
+using Spectre.Console.Cli;
+
+namespace Logging.Infrastructure;
+
+public sealed class TypeRegistrar : ITypeRegistrar
+{
+    private readonly IServiceCollection _builder;
+
+    public TypeRegistrar(IServiceCollection builder)
+    {
+        _builder = builder;
+    }
+
+    public ITypeResolver Build()
+    {
+        return new TypeResolver(_builder.BuildServiceProvider());
+    }
+
+    public void Register(Type service, Type implementation)
+    {
+        _builder.AddSingleton(service, implementation);
+    }
+
+    public void RegisterInstance(Type service, object implementation)
+    {
+        _builder.AddSingleton(service, implementation);
+    }
+
+    public void RegisterLazy(Type service, Func<object> func)
+    {
+        if (func is null)
+        {
+            throw new ArgumentNullException(nameof(func));
+        }
+
+        _builder.AddSingleton(service, _ => func());
+    }
+}

examples/Cli/Logging/Infrastructure/TypeResolver.cs

@@ -0,0 +1,24 @@
+using System;
+using Spectre.Console.Cli;
+
+namespace Logging.Infrastructure;
+
+public sealed class TypeResolver : ITypeResolver
+{
+    private readonly IServiceProvider _provider;
+
+    public TypeResolver(IServiceProvider provider)
+    {
+        _provider = provider ?? throw new ArgumentNullException(nameof(provider));
+    }
+
+    public object Resolve(Type type)
+    {
+        if (type == null)
+        {
+            return null;
+        }
+
+        return _provider.GetService(type);
+    }
+}