Simplified version of a logging project that captures multiple timing properties for a log entry using a DisposableTimer.

DisposableTimer.cs

public class DisposableTimer : IDisposable
{
    readonly string _name;
    readonly IDelayedLogBuilder _logBuilder;
    readonly Stopwatch _stopwatch;
    
    internal DisposableTimer(IDelayedLogBuilder logBuilder, string name)
    {
        _name = name;
        _logBuilder = logBuilder;
        
        _stopwatch = new Stopwatch();
        _stopwatch.Start();
    }
    
    public void Dispose()
    {
        _stopwatch.Stop();
        _logBuilder.WithProperties(p => p.Add(_name, _stopwatch.Elapsed.ToString()));
    }
}

IDelayedLogger.cs

//Required to capture multiple timings for a single log entry
public interface IDelayedLogBuilder : IDisposable
{
    DisposableTimer Timer(string name);
    
    IDelayedLogBuilder WithProperties(Action<LogPropertyFactory> action);
    
    // A level needs to be set before dispose
    AsDebug();  
    AsFatal();
}

ILogBuilder.cs

public interface ILogBuilder
{
    Write(LogEntry entry);
    
    IDelayedLogBuilder Delayed();

    ILogBuilder WithProperties(Action<LogPropertyFactory> action);
    
    // Other methods
}

Program.cs

static class Program
{
    void WithoutTimings()
    {
        var builder = Log.Build("A message")
                         .WithProperties(p => p.Add("Something", 123))
                         .AsDebug(); //builds log entry and writes 
    }
    
    void WithTimings()
    {
        var builder = Log.Build("A message")
                         .WithProperties(p => p.Add("Something", 123))
                         .Delayed()
                         .AsDebug();
                         
        using (builder.Timer("Step 1"))
        {
            //...
        }
        
        using (builder.Timer("Step 2"))
        {
            //...
        }
        
         //builds log entry and writes
        builder.Dispose();
    }    
}