Use ILogProvider instead of ILog in the high level APIs

odinserj · odinserj · commit 573ed26044e1 · 2025-09-07T16:00:44.000+07:00
diff --git a/src/Hangfire.Core/BackgroundJobClient.cs b/src/Hangfire.Core/BackgroundJobClient.cs
@@ -95,8 +95,8 @@ public BackgroundJobClient([NotNull] JobStorage storage, [NotNull] IJobFilterPro
         {
         }
 
-        public BackgroundJobClient([NotNull] JobStorage storage, [NotNull] IJobFilterProvider filterProvider, [NotNull] ILog logger)
-            : this(storage, new BackgroundJobFactory(filterProvider), new BackgroundJobStateChanger(filterProvider), logger)
+        public BackgroundJobClient([NotNull] JobStorage storage, [NotNull] IJobFilterProvider filterProvider, [CanBeNull] ILogProvider? logProvider)
+            : this(storage, new BackgroundJobFactory(filterProvider), new BackgroundJobStateChanger(filterProvider), logProvider)
         {
         }
 
@@ -116,7 +116,7 @@ public BackgroundJobClient(
             [NotNull] JobStorage storage,
             [NotNull] IBackgroundJobFactory factory,
             [NotNull] IBackgroundJobStateChanger stateChanger)
-            : this(storage, factory, stateChanger, LogProvider.For<BackgroundJobClient>())
+            : this(storage, factory, stateChanger, null)
         {
         }
 
@@ -125,12 +125,15 @@ public BackgroundJobClient(
             [NotNull] JobStorage storage,
             [NotNull] IBackgroundJobFactory factory,
             [NotNull] IBackgroundJobStateChanger stateChanger,
-            [NotNull] ILog logger)
+            [CanBeNull] ILogProvider? logProvider)
         {
             _storage = storage ?? throw new ArgumentNullException(nameof(storage));
             _stateChanger = stateChanger ?? throw new ArgumentNullException(nameof(stateChanger));
             _factory = factory ?? throw new ArgumentNullException(nameof(factory));
-            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+
+            logProvider ??= LogProvider.GetCurrentLogProvider();
+
+            _logger = logProvider.GetLogger(GetType().FullName!); // TODO: Obtain safe logger here
             _profiler = new SlowLogProfiler(_logger);
         }
 
diff --git a/src/Hangfire.Core/RecurringJobManager.cs b/src/Hangfire.Core/RecurringJobManager.cs
@@ -66,8 +66,8 @@ public RecurringJobManager(
             [NotNull] JobStorage storage, 
             [NotNull] IJobFilterProvider filterProvider,
             [NotNull] ITimeZoneResolver timeZoneResolver,
-            [NotNull] ILog logger)
-            : this(storage, new BackgroundJobFactory(filterProvider), timeZoneResolver, static () => DateTime.UtcNow, logger)
+            [NotNull] ILogProvider logProvider)
+            : this(storage, new BackgroundJobFactory(filterProvider), timeZoneResolver, static () => DateTime.UtcNow, logProvider)
         {
         }
 
@@ -76,7 +76,7 @@ public RecurringJobManager(
             [NotNull] IJobFilterProvider filterProvider, 
             [NotNull] ITimeZoneResolver timeZoneResolver,
             [NotNull] Func<DateTime> nowFactory)
-            : this(storage, new BackgroundJobFactory(filterProvider), timeZoneResolver, nowFactory, LogProvider.For<RecurringJobManager>())
+            : this(storage, new BackgroundJobFactory(filterProvider), timeZoneResolver, nowFactory, null)
         {
         }
 
@@ -86,7 +86,7 @@ public RecurringJobManager([NotNull] JobStorage storage, [NotNull] IBackgroundJo
         }
 
         public RecurringJobManager([NotNull] JobStorage storage, [NotNull] IBackgroundJobFactory factory, [NotNull] ITimeZoneResolver timeZoneResolver)
-            : this(storage, factory, timeZoneResolver, static () => DateTime.UtcNow, LogProvider.For<RecurringJobManager>())
+            : this(storage, factory, timeZoneResolver, static () => DateTime.UtcNow, null)
         {
         }
 
@@ -95,8 +95,8 @@ public RecurringJobManager(
             [NotNull] JobStorage storage,
             [NotNull] IBackgroundJobFactory factory,
             [NotNull] ITimeZoneResolver timeZoneResolver,
-            [NotNull] ILog logger)
-            : this(storage, factory, timeZoneResolver, static () => DateTime.UtcNow, logger)
+            [CanBeNull] ILogProvider? logProvider)
+            : this(storage, factory, timeZoneResolver, static () => DateTime.UtcNow, logProvider)
         {
         }
 
@@ -105,13 +105,16 @@ internal RecurringJobManager(
             [NotNull] IBackgroundJobFactory factory,
             [NotNull] ITimeZoneResolver timeZoneResolver,
             [NotNull] Func<DateTime> nowFactory,
-            [NotNull] ILog logger)
+            [CanBeNull] ILogProvider? logProvider)
         {
             _storage = storage ?? throw new ArgumentNullException(nameof(storage));
             _factory = factory ?? throw new ArgumentNullException(nameof(factory));
             _timeZoneResolver = timeZoneResolver ?? throw new ArgumentNullException(nameof(timeZoneResolver));
             _nowFactory = nowFactory ?? throw new ArgumentNullException(nameof(nowFactory));
-            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+
+            logProvider ??= LogProvider.GetCurrentLogProvider();
+
+            _logger = logProvider.GetLogger(GetType().FullName!); // TODO: Obtain safe logger here
             _profiler = new SlowLogProfiler(_logger);
         }
 
diff --git a/src/Hangfire.NetCore/DefaultClientManagerFactory.cs b/src/Hangfire.NetCore/DefaultClientManagerFactory.cs
@@ -33,17 +33,16 @@ public DefaultClientManagerFactory([NotNull] IServiceProvider serviceProvider)
         public IBackgroundJobClientV2 GetClientV2(JobStorage storage)
         {
             var logProvider = _serviceProvider.GetRequiredService<ILogProvider>();
-            var logger = logProvider.GetLogger(typeof(BackgroundJobClient).FullName!); // TODO: Ensure logger is wrapped
 
             if (HangfireServiceCollectionExtensions.GetInternalServices(_serviceProvider, out var factory, out var stateChanger, out _))
             {
-                return new BackgroundJobClient(storage, factory, stateChanger, logger);
+                return new BackgroundJobClient(storage, factory, stateChanger, logProvider);
             }
 
             return new BackgroundJobClient(
                 storage,
                 _serviceProvider.GetRequiredService<IJobFilterProvider>(),
-                logger);
+                logProvider);
         }
 
         public IBackgroundJobClient GetClient(JobStorage storage)
@@ -54,22 +53,21 @@ public IBackgroundJobClient GetClient(JobStorage storage)
         public IRecurringJobManagerV2 GetManagerV2(JobStorage storage)
         {
             var logProvider = _serviceProvider.GetRequiredService<ILogProvider>();
-            var logger = logProvider.GetLogger(typeof(BackgroundJobClient).FullName!); // TODO: Ensure logger is wrapped
 
             if (HangfireServiceCollectionExtensions.GetInternalServices(_serviceProvider, out var factory, out _, out _))
             {
                 return new RecurringJobManager(
                     storage,
                     factory,
                     _serviceProvider.GetRequiredService<ITimeZoneResolver>(),
-                    logger);
+                    logProvider);
             }
 
             return new RecurringJobManager(
                 storage,
                 _serviceProvider.GetRequiredService<IJobFilterProvider>(),
                 _serviceProvider.GetRequiredService<ITimeZoneResolver>(),
-                logger);
+                logProvider);
         }
 
         public IRecurringJobManager GetManager(JobStorage storage)
diff --git a/tests/Hangfire.Core.Tests/BackgroundJobClientFacts.cs b/tests/Hangfire.Core.Tests/BackgroundJobClientFacts.cs
@@ -21,7 +21,7 @@ public class BackgroundJobClientFacts
         private readonly Mock<IState> _state;
         private readonly Job _job;
         private readonly Mock<IBackgroundJobStateChanger> _stateChanger;
-        private readonly Mock<ILog> _logger;
+        private readonly Mock<ILogProvider> _logProvider;
 
         public BackgroundJobClientFacts()
         {
@@ -39,7 +39,8 @@ public BackgroundJobClientFacts()
             _factory.Setup(x => x.Create(It.IsAny<CreateContext>()))
                 .Returns(new BackgroundJob("some-job", _job, DateTime.UtcNow));
 
-            _logger = new Mock<ILog>();
+            _logProvider = new Mock<ILogProvider>();
+            _logProvider.Setup(x => x.GetLogger(It.IsAny<string>())).Returns(new Mock<ILog>().Object);
         }
 
         [Fact]
@@ -70,12 +71,10 @@ public void Ctor_ThrowsAnException_WhenStateChangerIsNull()
         }
 
         [Fact]
-        public void Ctor_ThrowsAnException_WhenLoggerIsNull()
+        public void Ctor_DoesNotThrow_WhenLoggerIsNull()
         {
-            var exception = Assert.Throws<ArgumentNullException>(
-                () => new BackgroundJobClient(_storage.Object, _factory.Object, _stateChanger.Object, null));
-
-            Assert.Equal("logger", exception.ParamName);
+            var client = new BackgroundJobClient(_storage.Object, _factory.Object, _stateChanger.Object, null);
+            Assert.NotNull(client);
         }
 
         [Fact, GlobalLock(Reason = "Needs JobStorage.Current instance")]
@@ -211,7 +210,7 @@ public static void Method()
 
         private BackgroundJobClient CreateClient()
         {
-            return new BackgroundJobClient(_storage.Object, _factory.Object, _stateChanger.Object, _logger.Object);
+            return new BackgroundJobClient(_storage.Object, _factory.Object, _stateChanger.Object, _logProvider.Object);
         }
     }
 }
diff --git a/tests/Hangfire.Core.Tests/RecurringJobManagerFacts.cs b/tests/Hangfire.Core.Tests/RecurringJobManagerFacts.cs
@@ -28,7 +28,7 @@ public class RecurringJobManagerFacts
         private readonly Func<DateTime> _nowFactory;
         private readonly BackgroundJob _backgroundJob;
         private readonly Mock<ITimeZoneResolver> _timeZoneResolver;
-        private readonly Mock<ILog> _logger;
+        private readonly Mock<ILogProvider> _logProvider;
 
         public RecurringJobManagerFacts()
         {
@@ -39,7 +39,8 @@ public RecurringJobManagerFacts()
             _storage = new Mock<JobStorage>();
             _factory = new Mock<IBackgroundJobFactory>();
             _stateMachine = new Mock<IStateMachine>();
-            _logger = new Mock<ILog>();
+            _logProvider = new Mock<ILogProvider>();
+            _logProvider.Setup(x => x.GetLogger(It.IsAny<string>())).Returns(new Mock<ILog>().Object);
             _factory.SetupGet(x => x.StateMachine).Returns(_stateMachine.Object);
             _nowFactory = () => _now;
 
@@ -82,7 +83,7 @@ public void Ctor_ThrowsAnException_WhenFactoryIsNull()
         public void Ctor_ThrowsAnException_WhenTimeZoneResolverIsNull()
         {
             var exception = Assert.Throws<ArgumentNullException>(
-                () => new RecurringJobManager(_storage.Object, _factory.Object, null, _nowFactory, _logger.Object));
+                () => new RecurringJobManager(_storage.Object, _factory.Object, null, _nowFactory, _logProvider.Object));
 
             Assert.Equal("timeZoneResolver", exception.ParamName);
         }
@@ -91,18 +92,16 @@ public void Ctor_ThrowsAnException_WhenTimeZoneResolverIsNull()
         public void Ctor_ThrowsAnException_WhenNowFactoryIsNull()
         {
             var exception = Assert.Throws<ArgumentNullException>(
-                () => new RecurringJobManager(_storage.Object, _factory.Object, _timeZoneResolver.Object, null, _logger.Object));
+                () => new RecurringJobManager(_storage.Object, _factory.Object, _timeZoneResolver.Object, null, _logProvider.Object));
 
             Assert.Equal("nowFactory", exception.ParamName);
         }
 
         [Fact]
-        public void Ctor_ThrowsAnException_WhenLoggerIsNull()
+        public void Ctor_DoesNotThrow_WhenLoggerIsNull()
         {
-            var exception = Assert.Throws<ArgumentNullException>(
-                () => new RecurringJobManager(_storage.Object, _factory.Object, _timeZoneResolver.Object, _nowFactory, null));
-
-            Assert.Equal("logger", exception.ParamName);
+            var manager = new RecurringJobManager(_storage.Object, _factory.Object, _timeZoneResolver.Object, _nowFactory, null);
+            Assert.NotNull(manager);
         }
 
         [Fact]
@@ -1034,7 +1033,7 @@ public void HandlesChangingProcessOfInvocationDataSerialization()
 
         private RecurringJobManager CreateManager()
         {
-            return new RecurringJobManager(_storage.Object, _factory.Object, _timeZoneResolver.Object, _nowFactory, _logger.Object);
+            return new RecurringJobManager(_storage.Object, _factory.Object, _timeZoneResolver.Object, _nowFactory, _logProvider.Object);
         }
 
         [SuppressMessage("Usage", "xUnit1013:Public method should be marked as test")]

Original file line number	Diff line number	Diff line change
`@@ -95,8 +95,8 @@ public BackgroundJobClient([NotNull] JobStorage storage, [NotNull] IJobFilterPro`
`95`	`95`	`{`
`96`	`96`	`}`
`97`	`97`
`98`		`- public BackgroundJobClient([NotNull] JobStorage storage, [NotNull] IJobFilterProvider filterProvider, [NotNull] ILog logger)`
`99`		`- : this(storage, new BackgroundJobFactory(filterProvider), new BackgroundJobStateChanger(filterProvider), logger)`
	`98`	`+ public BackgroundJobClient([NotNull] JobStorage storage, [NotNull] IJobFilterProvider filterProvider, [CanBeNull] ILogProvider? logProvider)`
	`99`	`+ : this(storage, new BackgroundJobFactory(filterProvider), new BackgroundJobStateChanger(filterProvider), logProvider)`
`100`	`100`	`{`
`101`	`101`	`}`
`102`	`102`
`@@ -116,7 +116,7 @@ public BackgroundJobClient(`
`116`	`116`	`[NotNull] JobStorage storage,`
`117`	`117`	`[NotNull] IBackgroundJobFactory factory,`
`118`	`118`	`[NotNull] IBackgroundJobStateChanger stateChanger)`
`119`		`- : this(storage, factory, stateChanger, LogProvider.For<BackgroundJobClient>())`
	`119`	`+ : this(storage, factory, stateChanger, null)`
`120`	`120`	`{`
`121`	`121`	`}`
`122`	`122`
`@@ -125,12 +125,15 @@ public BackgroundJobClient(`
`125`	`125`	`[NotNull] JobStorage storage,`
`126`	`126`	`[NotNull] IBackgroundJobFactory factory,`
`127`	`127`	`[NotNull] IBackgroundJobStateChanger stateChanger,`
`128`		`- [NotNull] ILog logger)`
	`128`	`+ [CanBeNull] ILogProvider? logProvider)`
`129`	`129`	`{`
`130`	`130`	`_storage = storage ?? throw new ArgumentNullException(nameof(storage));`
`131`	`131`	`_stateChanger = stateChanger ?? throw new ArgumentNullException(nameof(stateChanger));`
`132`	`132`	`_factory = factory ?? throw new ArgumentNullException(nameof(factory));`
`133`		`- _logger = logger ?? throw new ArgumentNullException(nameof(logger));`
	`133`	`+`
	`134`	`+ logProvider ??= LogProvider.GetCurrentLogProvider();`
	`135`	`+`
	`136`	`+ _logger = logProvider.GetLogger(GetType().FullName!); // TODO: Obtain safe logger here`
`134`	`137`	`_profiler = new SlowLogProfiler(_logger);`
`135`	`138`	`}`
`136`	`139`
Original file line number	Diff line number	Diff line change
`@@ -66,8 +66,8 @@ public RecurringJobManager(`
`66`	`66`	`[NotNull] JobStorage storage,`
`67`	`67`	`[NotNull] IJobFilterProvider filterProvider,`
`68`	`68`	`[NotNull] ITimeZoneResolver timeZoneResolver,`
`69`		`- [NotNull] ILog logger)`
`70`		`- : this(storage, new BackgroundJobFactory(filterProvider), timeZoneResolver, static () => DateTime.UtcNow, logger)`
	`69`	`+ [NotNull] ILogProvider logProvider)`
	`70`	`+ : this(storage, new BackgroundJobFactory(filterProvider), timeZoneResolver, static () => DateTime.UtcNow, logProvider)`
`71`	`71`	`{`
`72`	`72`	`}`
`73`	`73`
`@@ -76,7 +76,7 @@ public RecurringJobManager(`
`76`	`76`	`[NotNull] IJobFilterProvider filterProvider,`
`77`	`77`	`[NotNull] ITimeZoneResolver timeZoneResolver,`
`78`	`78`	`[NotNull] Func<DateTime> nowFactory)`
`79`		`- : this(storage, new BackgroundJobFactory(filterProvider), timeZoneResolver, nowFactory, LogProvider.For<RecurringJobManager>())`
	`79`	`+ : this(storage, new BackgroundJobFactory(filterProvider), timeZoneResolver, nowFactory, null)`
`80`	`80`	`{`
`81`	`81`	`}`
`82`	`82`
`@@ -86,7 +86,7 @@ public RecurringJobManager([NotNull] JobStorage storage, [NotNull] IBackgroundJo`
`86`	`86`	`}`
`87`	`87`
`88`	`88`	`public RecurringJobManager([NotNull] JobStorage storage, [NotNull] IBackgroundJobFactory factory, [NotNull] ITimeZoneResolver timeZoneResolver)`
`89`		`- : this(storage, factory, timeZoneResolver, static () => DateTime.UtcNow, LogProvider.For<RecurringJobManager>())`
	`89`	`+ : this(storage, factory, timeZoneResolver, static () => DateTime.UtcNow, null)`
`90`	`90`	`{`
`91`	`91`	`}`
`92`	`92`
`@@ -95,8 +95,8 @@ public RecurringJobManager(`
`95`	`95`	`[NotNull] JobStorage storage,`
`96`	`96`	`[NotNull] IBackgroundJobFactory factory,`
`97`	`97`	`[NotNull] ITimeZoneResolver timeZoneResolver,`
`98`		`- [NotNull] ILog logger)`
`99`		`- : this(storage, factory, timeZoneResolver, static () => DateTime.UtcNow, logger)`
	`98`	`+ [CanBeNull] ILogProvider? logProvider)`
	`99`	`+ : this(storage, factory, timeZoneResolver, static () => DateTime.UtcNow, logProvider)`
`100`	`100`	`{`
`101`	`101`	`}`
`102`	`102`
`@@ -105,13 +105,16 @@ internal RecurringJobManager(`
`105`	`105`	`[NotNull] IBackgroundJobFactory factory,`
`106`	`106`	`[NotNull] ITimeZoneResolver timeZoneResolver,`
`107`	`107`	`[NotNull] Func<DateTime> nowFactory,`
`108`		`- [NotNull] ILog logger)`
	`108`	`+ [CanBeNull] ILogProvider? logProvider)`
`109`	`109`	`{`
`110`	`110`	`_storage = storage ?? throw new ArgumentNullException(nameof(storage));`
`111`	`111`	`_factory = factory ?? throw new ArgumentNullException(nameof(factory));`
`112`	`112`	`_timeZoneResolver = timeZoneResolver ?? throw new ArgumentNullException(nameof(timeZoneResolver));`
`113`	`113`	`_nowFactory = nowFactory ?? throw new ArgumentNullException(nameof(nowFactory));`
`114`		`- _logger = logger ?? throw new ArgumentNullException(nameof(logger));`
	`114`	`+`
	`115`	`+ logProvider ??= LogProvider.GetCurrentLogProvider();`
	`116`	`+`
	`117`	`+ _logger = logProvider.GetLogger(GetType().FullName!); // TODO: Obtain safe logger here`
`115`	`118`	`_profiler = new SlowLogProfiler(_logger);`
`116`	`119`	`}`
`117`	`120`
Original file line number	Diff line number	Diff line change
`@@ -33,17 +33,16 @@ public DefaultClientManagerFactory([NotNull] IServiceProvider serviceProvider)`
`33`	`33`	`public IBackgroundJobClientV2 GetClientV2(JobStorage storage)`
`34`	`34`	`{`
`35`	`35`	`var logProvider = _serviceProvider.GetRequiredService<ILogProvider>();`
`36`		`- var logger = logProvider.GetLogger(typeof(BackgroundJobClient).FullName!); // TODO: Ensure logger is wrapped`
`37`	`36`
`38`	`37`	`if (HangfireServiceCollectionExtensions.GetInternalServices(_serviceProvider, out var factory, out var stateChanger, out _))`
`39`	`38`	`{`
`40`		`- return new BackgroundJobClient(storage, factory, stateChanger, logger);`
	`39`	`+ return new BackgroundJobClient(storage, factory, stateChanger, logProvider);`
`41`	`40`	`}`
`42`	`41`
`43`	`42`	`return new BackgroundJobClient(`
`44`	`43`	`storage,`
`45`	`44`	`_serviceProvider.GetRequiredService<IJobFilterProvider>(),`
`46`		`- logger);`
	`45`	`+ logProvider);`
`47`	`46`	`}`
`48`	`47`
`49`	`48`	`public IBackgroundJobClient GetClient(JobStorage storage)`
`@@ -54,22 +53,21 @@ public IBackgroundJobClient GetClient(JobStorage storage)`
`54`	`53`	`public IRecurringJobManagerV2 GetManagerV2(JobStorage storage)`
`55`	`54`	`{`
`56`	`55`	`var logProvider = _serviceProvider.GetRequiredService<ILogProvider>();`
`57`		`- var logger = logProvider.GetLogger(typeof(BackgroundJobClient).FullName!); // TODO: Ensure logger is wrapped`
`58`	`56`
`59`	`57`	`if (HangfireServiceCollectionExtensions.GetInternalServices(_serviceProvider, out var factory, out _, out _))`
`60`	`58`	`{`
`61`	`59`	`return new RecurringJobManager(`
`62`	`60`	`storage,`
`63`	`61`	`factory,`
`64`	`62`	`_serviceProvider.GetRequiredService<ITimeZoneResolver>(),`
`65`		`- logger);`
	`63`	`+ logProvider);`
`66`	`64`	`}`
`67`	`65`
`68`	`66`	`return new RecurringJobManager(`
`69`	`67`	`storage,`
`70`	`68`	`_serviceProvider.GetRequiredService<IJobFilterProvider>(),`
`71`	`69`	`_serviceProvider.GetRequiredService<ITimeZoneResolver>(),`
`72`		`- logger);`
	`70`	`+ logProvider);`
`73`	`71`	`}`
`74`	`72`
`75`	`73`	`public IRecurringJobManager GetManager(JobStorage storage)`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ public class BackgroundJobClientFacts`
`21`	`21`	`private readonly Mock<IState> _state;`
`22`	`22`	`private readonly Job _job;`
`23`	`23`	`private readonly Mock<IBackgroundJobStateChanger> _stateChanger;`
`24`		`- private readonly Mock<ILog> _logger;`
	`24`	`+ private readonly Mock<ILogProvider> _logProvider;`
`25`	`25`
`26`	`26`	`public BackgroundJobClientFacts()`
`27`	`27`	`{`
`@@ -39,7 +39,8 @@ public BackgroundJobClientFacts()`
`39`	`39`	`_factory.Setup(x => x.Create(It.IsAny<CreateContext>()))`
`40`	`40`	`.Returns(new BackgroundJob("some-job", _job, DateTime.UtcNow));`
`41`	`41`
`42`		`- _logger = new Mock<ILog>();`
	`42`	`+ _logProvider = new Mock<ILogProvider>();`
	`43`	`+ _logProvider.Setup(x => x.GetLogger(It.IsAny<string>())).Returns(new Mock<ILog>().Object);`
`43`	`44`	`}`
`44`	`45`
`45`	`46`	`[Fact]`
`@@ -70,12 +71,10 @@ public void Ctor_ThrowsAnException_WhenStateChangerIsNull()`
`70`	`71`	`}`
`71`	`72`
`72`	`73`	`[Fact]`
`73`		`- public void Ctor_ThrowsAnException_WhenLoggerIsNull()`
	`74`	`+ public void Ctor_DoesNotThrow_WhenLoggerIsNull()`
`74`	`75`	`{`
`75`		`- var exception = Assert.Throws<ArgumentNullException>(`
`76`		`- () => new BackgroundJobClient(_storage.Object, _factory.Object, _stateChanger.Object, null));`
`77`		`-`
`78`		`- Assert.Equal("logger", exception.ParamName);`
	`76`	`+ var client = new BackgroundJobClient(_storage.Object, _factory.Object, _stateChanger.Object, null);`
	`77`	`+ Assert.NotNull(client);`
`79`	`78`	`}`
`80`	`79`
`81`	`80`	`[Fact, GlobalLock(Reason = "Needs JobStorage.Current instance")]`
`@@ -211,7 +210,7 @@ public static void Method()`
`211`	`210`
`212`	`211`	`private BackgroundJobClient CreateClient()`
`213`	`212`	`{`
`214`		`- return new BackgroundJobClient(_storage.Object, _factory.Object, _stateChanger.Object, _logger.Object);`
	`213`	`+ return new BackgroundJobClient(_storage.Object, _factory.Object, _stateChanger.Object, _logProvider.Object);`
`215`	`214`	`}`
`216`	`215`	`}`
`217`	`216`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ public class RecurringJobManagerFacts`
`28`	`28`	`private readonly Func<DateTime> _nowFactory;`
`29`	`29`	`private readonly BackgroundJob _backgroundJob;`
`30`	`30`	`private readonly Mock<ITimeZoneResolver> _timeZoneResolver;`
`31`		`- private readonly Mock<ILog> _logger;`
	`31`	`+ private readonly Mock<ILogProvider> _logProvider;`
`32`	`32`
`33`	`33`	`public RecurringJobManagerFacts()`
`34`	`34`	`{`
`@@ -39,7 +39,8 @@ public RecurringJobManagerFacts()`
`39`	`39`	`_storage = new Mock<JobStorage>();`
`40`	`40`	`_factory = new Mock<IBackgroundJobFactory>();`
`41`	`41`	`_stateMachine = new Mock<IStateMachine>();`
`42`		`- _logger = new Mock<ILog>();`
	`42`	`+ _logProvider = new Mock<ILogProvider>();`
	`43`	`+ _logProvider.Setup(x => x.GetLogger(It.IsAny<string>())).Returns(new Mock<ILog>().Object);`
`43`	`44`	`_factory.SetupGet(x => x.StateMachine).Returns(_stateMachine.Object);`
`44`	`45`	`_nowFactory = () => _now;`
`45`	`46`
`@@ -82,7 +83,7 @@ public void Ctor_ThrowsAnException_WhenFactoryIsNull()`
`82`	`83`	`public void Ctor_ThrowsAnException_WhenTimeZoneResolverIsNull()`
`83`	`84`	`{`
`84`	`85`	`var exception = Assert.Throws<ArgumentNullException>(`
`85`		`- () => new RecurringJobManager(_storage.Object, _factory.Object, null, _nowFactory, _logger.Object));`
	`86`	`+ () => new RecurringJobManager(_storage.Object, _factory.Object, null, _nowFactory, _logProvider.Object));`
`86`	`87`
`87`	`88`	`Assert.Equal("timeZoneResolver", exception.ParamName);`
`88`	`89`	`}`
`@@ -91,18 +92,16 @@ public void Ctor_ThrowsAnException_WhenTimeZoneResolverIsNull()`
`91`	`92`	`public void Ctor_ThrowsAnException_WhenNowFactoryIsNull()`
`92`	`93`	`{`
`93`	`94`	`var exception = Assert.Throws<ArgumentNullException>(`
`94`		`- () => new RecurringJobManager(_storage.Object, _factory.Object, _timeZoneResolver.Object, null, _logger.Object));`
	`95`	`+ () => new RecurringJobManager(_storage.Object, _factory.Object, _timeZoneResolver.Object, null, _logProvider.Object));`
`95`	`96`
`96`	`97`	`Assert.Equal("nowFactory", exception.ParamName);`
`97`	`98`	`}`
`98`	`99`
`99`	`100`	`[Fact]`
`100`		`- public void Ctor_ThrowsAnException_WhenLoggerIsNull()`
	`101`	`+ public void Ctor_DoesNotThrow_WhenLoggerIsNull()`
`101`	`102`	`{`
`102`		`- var exception = Assert.Throws<ArgumentNullException>(`
`103`		`- () => new RecurringJobManager(_storage.Object, _factory.Object, _timeZoneResolver.Object, _nowFactory, null));`
`104`		`-`
`105`		`- Assert.Equal("logger", exception.ParamName);`
	`103`	`+ var manager = new RecurringJobManager(_storage.Object, _factory.Object, _timeZoneResolver.Object, _nowFactory, null);`
	`104`	`+ Assert.NotNull(manager);`
`106`	`105`	`}`
`107`	`106`
`108`	`107`	`[Fact]`
`@@ -1034,7 +1033,7 @@ public void HandlesChangingProcessOfInvocationDataSerialization()`
`1034`	`1033`
`1035`	`1034`	`private RecurringJobManager CreateManager()`
`1036`	`1035`	`{`
`1037`		`- return new RecurringJobManager(_storage.Object, _factory.Object, _timeZoneResolver.Object, _nowFactory, _logger.Object);`
	`1036`	`+ return new RecurringJobManager(_storage.Object, _factory.Object, _timeZoneResolver.Object, _nowFactory, _logProvider.Object);`
`1038`	`1037`	`}`
`1039`	`1038`
`1040`	`1039`	`[SuppressMessage("Usage", "xUnit1013:Public method should be marked as test")]`