DisposingLoggerScopeFactory

DisposingLoggerScopeFactory.cs

/// <summary>
/// Used to create logging scopes that will live for the lifetime of the service providers scope.
/// </summary>
public interface ILoggerScopeFactory
{
    void BeginScope<TState>(TState state);
    void BeginScope(String messageFormat, params Object[] args);
}

public class DisposingLoggerScopeFactory : ILoggerScopeFactory, IDisposable
{
    private readonly ILogger<DisposingLoggerScopeFactory> logger;
    private readonly ConcurrentStack<IDisposable> scopes = new ConcurrentStack<IDisposable>();
    
    public DisposingLoggerScopeFactory(ILogger<DisposingLoggerScopeFactory> logger) => this.logger = logger;
    
    public void BeginScope<TState>(TState state) => this.scopes.Push(this.logger.BeginScope(state));
    public void BeginScope(String messageFormat, params object[] args) => this.scopes.Push(this.logger.BeginScope(messageFormat, args));

    public void Dispose()
    {
        while (scopes.TryPop(out var scope))
        {
            scope?.Dispose();
        }
    }
}

Program.cs

void Main()
{
    var services = new ServiceCollection();
    services.AddLogging(logging =>
    {
        logging.AddConsole(x => x.IncludeScopes = true);
    });
    services.AddScoped<ILoggerScopeFactory, DisposingLoggerScopeFactory>();
    
    using var root = services.BuildServiceProvider();
    using (var scope = root.CreateScope())
    {
        var logger = scope.ServiceProvider.GetRequiredService<ILogger<Object>>();
        var scopeFactory = scope.ServiceProvider.GetRequiredService<ILoggerScopeFactory>();

        try
        {
            CreateScopeAndThrow(scopeFactory);
        }
        catch (Exception ex)
        {
            logger.LogError(ex, "Unhandled exception :(");
        }
    }
}

public void CreateScopeAndThrow(ILoggerScopeFactory scopeFactory)
{
    scopeFactory.BeginScope("Scope");
    throw new Exception("Oh no!");
}