Add TimeProvider support

src/ZeroLog.Impl.Full/Configuration/ResolvedLoggerConfiguration.cs

@@ -21,6 +21,10 @@ internal sealed class ResolvedLoggerConfiguration
     public LogLevel Level { get; }
     public LogMessagePoolExhaustionStrategy LogMessagePoolExhaustionStrategy { get; private init; } = LogMessagePoolExhaustionStrategy.Default;
 
+#if NET8_0_OR_GREATER
+    public TimeProvider TimeProvider { get; private init; } = TimeProvider.System;
+#endif
+
     private ResolvedLoggerConfiguration(IEnumerable<Appender[]> appendersByLogLevel)
     {
         _appendersByLogLevel = appendersByLogLevel.ToArray();
@@ -61,7 +65,11 @@ public static ResolvedLoggerConfiguration Resolve(string loggerName, ZeroLogConf
 
         return new ResolvedLoggerConfiguration(appendersByLogLevel.Select(i => i.ToArray()))
         {
-            LogMessagePoolExhaustionStrategy = effectiveLogMessagePoolExhaustionStrategy
+            LogMessagePoolExhaustionStrategy = effectiveLogMessagePoolExhaustionStrategy,
+#if NET8_0_OR_GREATER
+            // ReSharper disable once NullCoalescingConditionIsAlwaysNotNullAccordingToAPIContract
+            TimeProvider = configuration.TimeProvider ?? TimeProvider.System
+#endif
         };
 
         IEnumerable<ILoggerConfiguration> GetOrderedLoggerConfigurations()
@@ -96,7 +104,11 @@ void ApplyLoggerConfig(ILoggerConfiguration loggerConfig)
         }
     }
 
-    internal static ResolvedLoggerConfiguration SingleAppender(LogLevel level, Appender? appender = null)
+    internal static ResolvedLoggerConfiguration SingleAppender(LogLevel level, Appender? appender = null
+#if NET8_0_OR_GREATER
+                                                               , TimeProvider? timeProvider = null
+#endif
+    )
     {
         // For unit tests
 
@@ -105,6 +117,11 @@ internal static ResolvedLoggerConfiguration SingleAppender(LogLevel level, Appen
         var appendersByLogLevel = Enumerable.Range(0, _levelCount)
                                             .Select(i => i >= (int)level ? appenderArray : []);
 
-        return new ResolvedLoggerConfiguration(appendersByLogLevel);
+        return new ResolvedLoggerConfiguration(appendersByLogLevel)
+        {
+#if NET8_0_OR_GREATER
+            TimeProvider = timeProvider ?? TimeProvider.System
+#endif
+        };
     }
 }

src/ZeroLog.Impl.Full/Configuration/ZeroLogConfiguration.cs

@@ -121,6 +121,16 @@ public bool UseBackgroundThread
     /// </remarks>
     public ILoggerConfigurationCollection Loggers => _loggers;
 
+#if NET8_0_OR_GREATER
+    /// <summary>
+    /// The time provider to use for message timestamps.
+    /// </summary>
+    /// <remarks>
+    /// Default: <see cref="System.TimeProvider.System"/>.
+    /// </remarks>
+    public TimeProvider TimeProvider { get; init; } = TimeProvider.System;
+#endif
+
     /// <summary>
     /// Applies the changes made to this object since the call to <see cref="LogManager.Initialize"/>
     /// or the last call to <see cref="ApplyChanges"/>.

src/ZeroLog.Impl.Full/Log.Impl.cs

@@ -6,16 +6,17 @@ namespace ZeroLog;
 partial class Log
 {
     private ILogMessageProvider? _logMessageProvider;
-    private ResolvedLoggerConfiguration _config = ResolvedLoggerConfiguration.Empty;
+
+    internal ResolvedLoggerConfiguration Config { get; private set; } = ResolvedLoggerConfiguration.Empty;
 
     internal void UpdateConfiguration(ILogMessageProvider? provider, ZeroLogConfiguration? config)
         => UpdateConfiguration(provider, config?.ResolveLoggerConfiguration(Name));
 
     internal void UpdateConfiguration(ILogMessageProvider? provider, ResolvedLoggerConfiguration? config)
     {
         _logMessageProvider = provider;
-        _config = config ?? ResolvedLoggerConfiguration.Empty;
-        _logLevel = _config.Level;
+        Config = config ?? ResolvedLoggerConfiguration.Empty;
+        _logLevel = Config.Level;
     }
 
     internal void DisableLogging()
@@ -28,14 +29,14 @@ public partial bool IsEnabled(LogLevel level)
         => level >= _logLevel;
 
     internal Appender[] GetAppenders(LogLevel level)
-        => _config.GetAppenders(level);
+        => Config.GetAppenders(level);
 
     private partial LogMessage InternalAcquireLogMessage(LogLevel level)
     {
         var provider = _logMessageProvider;
 
         var logMessage = provider is not null
-            ? provider.AcquireLogMessage(_config.LogMessagePoolExhaustionStrategy)
+            ? provider.AcquireLogMessage(Config.LogMessagePoolExhaustionStrategy)
             : LogMessage.Empty;
 
         logMessage.Initialize(this, level);

src/ZeroLog.Impl.Full/LogMessage.Impl.cs

@@ -48,7 +48,12 @@ internal void Initialize(Log? log, LogLevel level)
         if (ReferenceEquals(this, Empty)) // Avoid overhead for ignored messages
             return;
 
-        Timestamp = DateTime.UtcNow; // TODO clock in Log
+#if NET8_0_OR_GREATER
+        Timestamp = log?.Config.TimeProvider.GetUtcNow().DateTime ?? DateTime.UtcNow;
+#else
+        Timestamp = DateTime.UtcNow;
+#endif
+
         Level = level;
         Thread = Thread.CurrentThread;
         Exception = null;

src/ZeroLog.Impl.Full/ZeroLog.Impl.Full.csproj

@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>net7.0;net6.0</TargetFrameworks>
+    <TargetFrameworks>net8.0;net7.0;net6.0</TargetFrameworks>
     <RootNamespace>ZeroLog</RootNamespace>
     <Nullable>enable</Nullable>
     <DisableFody>true</DisableFody>

src/ZeroLog.Tests/Configuration/ResolvedLoggerConfigurationTests.cs

@@ -1,3 +1,4 @@
+using System;
 using NUnit.Framework;
 using ZeroLog.Appenders;
 using ZeroLog.Configuration;
@@ -20,6 +21,10 @@ public void should_have_empty_config()
         emptyConfig.GetAppenders(LogLevel.Warn).ShouldBeEmpty();
         emptyConfig.GetAppenders(LogLevel.Error).ShouldBeEmpty();
         emptyConfig.GetAppenders(LogLevel.Fatal).ShouldBeEmpty();
+
+#if NET8_0_OR_GREATER
+        emptyConfig.TimeProvider.ShouldBeTheSameAs(TimeProvider.System);
+#endif
     }
 
     [Test]
@@ -244,4 +249,20 @@ public void should_use_parent_appenders_when_lowering_log_level()
         fooBarConfig.GetAppenders(LogLevel.Error).ShouldBeEquivalentTo([appenderA, appenderB]);
         fooBarConfig.GetAppenders(LogLevel.Fatal).ShouldBeEquivalentTo([appenderA, appenderB]);
     }
+
+#if NET8_0_OR_GREATER
+    [Test]
+    public void should_forward_time_provider()
+    {
+        var timeProvider = new TestTimeProvider();
+
+        var config = new ZeroLogConfiguration
+        {
+            TimeProvider = timeProvider
+        };
+
+        var logConfig = config.ResolveLoggerConfiguration("Foo");
+        logConfig.TimeProvider.ShouldBeTheSameAs(timeProvider);
+    }
+#endif
 }

src/ZeroLog.Tests/LogTests.cs

@@ -89,6 +89,18 @@ public void should_tell_if_log_level_is_enabled(LogLevel logLevel, bool isTrace,
     public string should_compact_name(string value)
         => Log.GetCompactName(value);
 
+#if NET8_0_OR_GREATER
+    [Test]
+    public void should_use_custom_time_provider()
+    {
+        var timeProvider = new TestTimeProvider { Timestamp = TestTimeProvider.ExampleTimestamp };
+        _log.UpdateConfiguration(_provider, ResolvedLoggerConfiguration.SingleAppender(LogLevel.Trace, timeProvider: timeProvider));
+
+        _log.Config.TimeProvider.ShouldBeTheSameAs(timeProvider);
+        _log.Info().Timestamp.ShouldEqual(TestTimeProvider.ExampleTimestamp);
+    }
+#endif
+
     private static string NoInline(string value)
         => value;
 

src/ZeroLog.Tests/SanityChecks.should_have_expected_public_api.DotNet8_0.verified.txt

@@ -111,6 +111,7 @@ namespace ZeroLog.Configuration
         public int LogMessageBufferSize { get; init; }
         public int LogMessagePoolSize { get; init; }
         public int LogMessageStringCapacity { get; init; }
+        public System.TimeProvider TimeProvider { get; init; }
         public bool UseBackgroundThread { get; init; }
         public void ApplyChanges() { }
         public void SetLogLevel(string? loggerName, ZeroLog.LogLevel? logLevel) { }

src/ZeroLog.Tests/Support/TestTimeProvider.cs

@@ -0,0 +1,17 @@
+#if NET8_0_OR_GREATER
+
+using System;
+
+namespace ZeroLog.Tests.Support;
+
+internal class TestTimeProvider : TimeProvider
+{
+    public static DateTime ExampleTimestamp { get; } = new(2020, 1, 2, 3, 4, 5, 6, 7);
+
+    public DateTime Timestamp { get; set; } = DateTime.UtcNow;
+
+    public override DateTimeOffset GetUtcNow()
+        => Timestamp;
+}
+
+#endif

src/ZeroLog/ZeroLog.csproj

@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>net7.0;net6.0;netstandard2.0</TargetFrameworks>
+    <TargetFrameworks>net8.0;net7.0;net6.0;netstandard2.0</TargetFrameworks>
     <Nullable>enable</Nullable>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
   </PropertyGroup>