Merge pull request #46 from serilog/dev

nblumhardt · web-flow · commit 856f8fff69e5 · 2019-06-10T07:46:23.000+10:00
1.4.0 Release
diff --git a/appveyor.yml b/appveyor.yml
@@ -1,7 +1,6 @@
 version: '{build}'
 skip_tags: true
-image: Visual Studio 2017
-configuration: Release
+image: Visual Studio 2019
 build_script:
 - ps: ./Build.ps1
 test: off
@@ -10,7 +9,7 @@ artifacts:
 deploy:
 - provider: NuGet
   api_key:
-    secure: bd9z4P73oltOXudAjPehwp9iDKsPtC+HbgshOrSgoyQKr5xVK+bxJQngrDJkHdY8
+    secure: mnSqLheecloK/7XS+OjiDMlttTzhMTRyT2e9AUnS7aHR5AimjOD9vQtfodwagacH
   skip_symbols: true
   on:
     branch: /^(master|dev)$/
diff --git a/serilog-sinks-async.sln.DotSettings b/serilog-sinks-async.sln.DotSettings
@@ -0,0 +1,2 @@
+﻿<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Serilog/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>
diff --git a/src/Serilog.Sinks.Async/Serilog.Sinks.Async.csproj b/src/Serilog.Sinks.Async/Serilog.Sinks.Async.csproj
@@ -2,10 +2,10 @@
 
   <PropertyGroup>
     <Description>Asynchronous sink wrapper for Serilog.</Description>
-    <AssemblyVersion>1.0.0</AssemblyVersion>
-    <VersionPrefix>1.3.0</VersionPrefix>
+    <AssemblyVersion>1.4.0.0</AssemblyVersion>
+    <VersionPrefix>1.4.0</VersionPrefix>
     <Authors>Jezz Santos;Serilog Contributors</Authors>
-    <TargetFrameworks>net45;netstandard1.1</TargetFrameworks>
+    <TargetFrameworks>net45;netstandard1.1;net461;netstandard2.0</TargetFrameworks>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <AssemblyName>Serilog.Sinks.Async</AssemblyName>
@@ -15,22 +15,24 @@
     <PublicSign Condition=" '$(OS)' != 'Windows_NT' ">true</PublicSign>
     <PackageId>Serilog.Sinks.Async</PackageId>
     <PackageTags>serilog;async</PackageTags>
-    <PackageIconUrl>http://serilog.net/images/serilog-sink-nuget.png</PackageIconUrl>
+    <PackageIconUrl>https://serilog.net/images/serilog-sink-nuget.png</PackageIconUrl>
     <PackageProjectUrl>https://serilog.net</PackageProjectUrl>
-    <PackageLicenseUrl>http://www.apache.org/licenses/LICENSE-2.0</PackageLicenseUrl>
+    <PackageLicense>Apache-2.0</PackageLicense>
+    <RepositoryUrl>https://github.com/serilog/serilog-sinks-async</RepositoryUrl>
+    <RepositoryType>git</RepositoryType>
     <TreatWarningsAsErrors>True</TreatWarningsAsErrors>
   </PropertyGroup>
 
-  <PropertyGroup Condition=" '$(TargetFramework)' == 'net45' ">
+  <PropertyGroup Condition=" '$(TargetFramework)' == 'net45' Or '$(TargetFramework)' == 'net461' ">
     <!-- Don't reference the full NETStandard.Library -->
     <DisableImplicitFrameworkReferences>true</DisableImplicitFrameworkReferences>
   </PropertyGroup>
   
   <ItemGroup>
-    <PackageReference Include="Serilog" Version="2.7.1" />
+    <PackageReference Include="Serilog" Version="2.8.0" />
   </ItemGroup>
 
-  <ItemGroup Condition=" '$(TargetFramework)' == 'net45' ">
+  <ItemGroup Condition=" '$(TargetFramework)' == 'net45' Or '$(TargetFramework)' == 'net461' ">
     <Reference Include="System" />
     <Reference Include="Microsoft.CSharp" />
   </ItemGroup>
diff --git a/src/Serilog.Sinks.Async/Sinks/Async/BackgroundWorkerSink.cs b/src/Serilog.Sinks.Async/Sinks/Async/BackgroundWorkerSink.cs
@@ -10,18 +10,18 @@ namespace Serilog.Sinks.Async
 {
     sealed class BackgroundWorkerSink : ILogEventSink, IAsyncLogEventSinkInspector, IDisposable
     {
-        readonly ILogEventSink _pipeline;
+        readonly ILogEventSink _wrappedSink;
         readonly bool _blockWhenFull;
         readonly BlockingCollection<LogEvent> _queue;
         readonly Task _worker;
         readonly IAsyncLogEventSinkMonitor _monitor;
 
         long _droppedMessages;
 
-        public BackgroundWorkerSink(ILogEventSink pipeline, int bufferCapacity, bool blockWhenFull, IAsyncLogEventSinkMonitor monitor = null)
+        public BackgroundWorkerSink(ILogEventSink wrappedSink, int bufferCapacity, bool blockWhenFull, IAsyncLogEventSinkMonitor monitor = null)
         {
             if (bufferCapacity <= 0) throw new ArgumentOutOfRangeException(nameof(bufferCapacity));
-            _pipeline = pipeline ?? throw new ArgumentNullException(nameof(pipeline));
+            _wrappedSink = wrappedSink ?? throw new ArgumentNullException(nameof(wrappedSink));
             _blockWhenFull = blockWhenFull;
             _queue = new BlockingCollection<LogEvent>(bufferCapacity);
             _worker = Task.Factory.StartNew(Pump, CancellationToken.None, TaskCreationOptions.LongRunning | TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
@@ -64,7 +64,7 @@ public void Dispose()
             // Allow queued events to be flushed
             _worker.Wait();
 
-            (_pipeline as IDisposable)?.Dispose();
+            (_wrappedSink as IDisposable)?.Dispose();
 
             _monitor?.StopMonitoring(this);
         }
@@ -75,12 +75,19 @@ void Pump()
             {
                 foreach (var next in _queue.GetConsumingEnumerable())
                 {
-                    _pipeline.Emit(next);
+                    try
+                    {
+                        _wrappedSink.Emit(next);
+                    }
+                    catch (Exception ex)
+                    {
+                        SelfLog.WriteLine("{0} failed to emit event to wrapped sink: {1}", typeof(BackgroundWorkerSink), ex);
+                    }
                 }
             }
-            catch (Exception ex)
+            catch (Exception fatal)
             {
-                SelfLog.WriteLine("{0} fatal error in worker thread: {1}", typeof(BackgroundWorkerSink), ex);
+                SelfLog.WriteLine("{0} fatal error in worker thread: {1}", typeof(BackgroundWorkerSink), fatal);
             }
         }
 
diff --git a/test/Serilog.Sinks.Async.PerformanceTests/LatencyBenchmark.cs b/test/Serilog.Sinks.Async.PerformanceTests/LatencyBenchmark.cs
@@ -11,17 +11,17 @@ namespace Serilog.Sinks.Async.PerformanceTests
 {
     public class LatencyBenchmark
     {
-        private readonly LogEvent _evt = new LogEvent(DateTimeOffset.Now, LogEventLevel.Information, null,
+        readonly LogEvent _evt = new LogEvent(DateTimeOffset.Now, LogEventLevel.Information, null,
             new MessageTemplate(new[] {new TextToken("Hello")}), new LogEventProperty[0]);
 
-        private Logger _syncLogger, _asyncLogger, _fileLogger, _asyncFileLogger;
+        Logger _syncLogger, _asyncLogger, _fileLogger, _asyncFileLogger;
 
         static LatencyBenchmark()
         {
             SelfLog.Enable(new TerminatingTextWriter());
         }
 
-        [Setup]
+        [GlobalSetup]
         public void Reset()
         {
             foreach (var logger in new[] { _syncLogger, _asyncLogger, _fileLogger, _asyncFileLogger})
diff --git a/test/Serilog.Sinks.Async.PerformanceTests/Serilog.Sinks.Async.PerformanceTests.csproj b/test/Serilog.Sinks.Async.PerformanceTests/Serilog.Sinks.Async.PerformanceTests.csproj
@@ -1,7 +1,7 @@
 ﻿<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net46;netcoreapp1.1</TargetFrameworks>
+    <TargetFrameworks>net461;netcoreapp2.0</TargetFrameworks>
     <AssemblyName>Serilog.Sinks.Async.PerformanceTests</AssemblyName>
     <AssemblyOriginatorKeyFile>../../assets/Serilog.snk</AssemblyOriginatorKeyFile>
     <SignAssembly>true</SignAssembly>
@@ -17,10 +17,13 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.0.0" />
-    <PackageReference Include="xunit" Version="2.3.1" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.1" />
-    <PackageReference Include="BenchmarkDotNet" Version="0.10.6" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.1.1" />
+    <PackageReference Include="xunit" Version="2.4.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="BenchmarkDotNet" Version="0.11.5" />
     <PackageReference Include="Serilog.Sinks.File" Version="3.1.0" />
   </ItemGroup>
 
diff --git a/test/Serilog.Sinks.Async.PerformanceTests/SignallingSink.cs b/test/Serilog.Sinks.Async.PerformanceTests/SignallingSink.cs
@@ -5,11 +5,11 @@
 
 namespace Serilog.Sinks.Async.PerformanceTests
 {
-    internal class SignallingSink : ILogEventSink
+    class SignallingSink : ILogEventSink
     {
-        private readonly int _expectedCount;
-        private readonly ManualResetEvent _wh;
-        private int _current;
+        readonly int _expectedCount;
+        readonly ManualResetEvent _wh;
+        int _current;
 
         public SignallingSink(int expectedCount)
         {
diff --git a/test/Serilog.Sinks.Async.PerformanceTests/ThroughputBenchmark.cs b/test/Serilog.Sinks.Async.PerformanceTests/ThroughputBenchmark.cs
@@ -8,20 +8,20 @@ namespace Serilog.Sinks.Async.PerformanceTests
 {
     public class ThroughputBenchmark
     {
-        private const int Count = 10000;
+        const int Count = 10000;
 
-        private readonly LogEvent _evt = new LogEvent(DateTimeOffset.Now, LogEventLevel.Information, null,
+        readonly LogEvent _evt = new LogEvent(DateTimeOffset.Now, LogEventLevel.Information, null,
             new MessageTemplate(new[] {new TextToken("Hello")}), new LogEventProperty[0]);
 
-        private readonly SignallingSink _signal;
-        private Logger _syncLogger, _asyncLogger;
+        readonly SignallingSink _signal;
+        Logger _syncLogger, _asyncLogger;
 
         public ThroughputBenchmark()
         {
             _signal = new SignallingSink(Count);
         }
 
-        [Setup]
+        [GlobalSetup]
         public void Reset()
         {
             _syncLogger?.Dispose();
diff --git a/test/Serilog.Sinks.Async.Tests/BackgroundWorkerSinkIntegrationSpec.cs b/test/Serilog.Sinks.Async.Tests/BackgroundWorkerSinkIntegrationSpec.cs
@@ -15,7 +15,7 @@ public class BackgroundWorkerSinkIntegrationSpec
         /// <summary>
         ///     If <see cref="withDelay" />, then adds a 1sec delay before every fifth element created
         /// </summary>
-        private static void CreateAudits(ILogger logger, int count, bool withDelay)
+        static void CreateAudits(ILogger logger, int count, bool withDelay)
         {
             var delay = TimeSpan.FromMilliseconds(1000);
             var sw = new Stopwatch();
@@ -47,7 +47,7 @@ private static void CreateAudits(ILogger logger, int count, bool withDelay)
             }
         }
 
-        private static List<LogEvent> RetrieveEvents(MemorySink sink, int count)
+        static List<LogEvent> RetrieveEvents(MemorySink sink, int count)
         {
             Debug.WriteLine("{0:h:mm:ss tt} Retrieving {1} events", DateTime.Now, count);
 
@@ -91,9 +91,9 @@ public GivenBufferQueueAndDelays()
 
         public abstract class SinkSpecBase : IDisposable
         {
-            private bool _delayCreation;
-            private Logger _logger;
-            private MemorySink _memorySink;
+            bool _delayCreation;
+            Logger _logger;
+            MemorySink _memorySink;
 
             protected SinkSpecBase(bool useBufferedQueue, bool delayCreation)
             {
diff --git a/test/Serilog.Sinks.Async.Tests/BackgroundWorkerSinkSpec.cs b/test/Serilog.Sinks.Async.Tests/BackgroundWorkerSinkSpec.cs
@@ -230,12 +230,12 @@ public void MonitorParameterAffordsSinkInspectorSuitableForHealthChecking()
             Assert.Null(monitor.Inspector);
         }
 
-        private BackgroundWorkerSink CreateSinkWithDefaultOptions()
+        BackgroundWorkerSink CreateSinkWithDefaultOptions()
         {
             return new BackgroundWorkerSink(_logger, 10000, false);
         }
 
-        private static LogEvent CreateEvent()
+        static LogEvent CreateEvent()
         {
             return new LogEvent(DateTimeOffset.MaxValue, LogEventLevel.Error, null,
                 new MessageTemplate("amessage", Enumerable.Empty<MessageTemplateToken>()),
diff --git a/test/Serilog.Sinks.Async.Tests/Serilog.Sinks.Async.Tests.csproj b/test/Serilog.Sinks.Async.Tests/Serilog.Sinks.Async.Tests.csproj
@@ -1,7 +1,7 @@
 ﻿<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net452;netcoreapp1.0</TargetFrameworks>
+    <TargetFrameworks>net461;netcoreapp2.0</TargetFrameworks>
     <AssemblyName>Serilog.Sinks.Async.Tests</AssemblyName>
     <AssemblyOriginatorKeyFile>../../assets/Serilog.snk</AssemblyOriginatorKeyFile>
     <SignAssembly>true</SignAssembly>
@@ -14,9 +14,12 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.0.0" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.1" />
-    <PackageReference Include="xunit" Version="2.3.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.1.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="xunit" Version="2.4.1" />
   </ItemGroup>
 
   <ItemGroup>

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">`
	`2`	`+ <s:Boolean x:Key="/Default/UserDictionary/Words/=Serilog/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>`
Original file line number	Diff line number	Diff line change
`@@ -10,18 +10,18 @@ namespace Serilog.Sinks.Async`
`10`	`10`	`{`
`11`	`11`	`sealed class BackgroundWorkerSink : ILogEventSink, IAsyncLogEventSinkInspector, IDisposable`
`12`	`12`	`{`
`13`		`- readonly ILogEventSink _pipeline;`
	`13`	`+ readonly ILogEventSink _wrappedSink;`
`14`	`14`	`readonly bool _blockWhenFull;`
`15`	`15`	`readonly BlockingCollection<LogEvent> _queue;`
`16`	`16`	`readonly Task _worker;`
`17`	`17`	`readonly IAsyncLogEventSinkMonitor _monitor;`
`18`	`18`
`19`	`19`	`long _droppedMessages;`
`20`	`20`
`21`		`- public BackgroundWorkerSink(ILogEventSink pipeline, int bufferCapacity, bool blockWhenFull, IAsyncLogEventSinkMonitor monitor = null)`
	`21`	`+ public BackgroundWorkerSink(ILogEventSink wrappedSink, int bufferCapacity, bool blockWhenFull, IAsyncLogEventSinkMonitor monitor = null)`
`22`	`22`	`{`
`23`	`23`	`if (bufferCapacity <= 0) throw new ArgumentOutOfRangeException(nameof(bufferCapacity));`
`24`		`- _pipeline = pipeline ?? throw new ArgumentNullException(nameof(pipeline));`
	`24`	`+ _wrappedSink = wrappedSink ?? throw new ArgumentNullException(nameof(wrappedSink));`
`25`	`25`	`_blockWhenFull = blockWhenFull;`
`26`	`26`	`_queue = new BlockingCollection<LogEvent>(bufferCapacity);`
`27`	`27`	`_worker = Task.Factory.StartNew(Pump, CancellationToken.None, TaskCreationOptions.LongRunning \| TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);`
`@@ -64,7 +64,7 @@ public void Dispose()`
`64`	`64`	`// Allow queued events to be flushed`
`65`	`65`	`_worker.Wait();`
`66`	`66`
`67`		`- (_pipeline as IDisposable)?.Dispose();`
	`67`	`+ (_wrappedSink as IDisposable)?.Dispose();`
`68`	`68`
`69`	`69`	`_monitor?.StopMonitoring(this);`
`70`	`70`	`}`
`@@ -75,12 +75,19 @@ void Pump()`
`75`	`75`	`{`
`76`	`76`	`foreach (var next in _queue.GetConsumingEnumerable())`
`77`	`77`	`{`
`78`		`- _pipeline.Emit(next);`
	`78`	`+ try`
	`79`	`+ {`
	`80`	`+ _wrappedSink.Emit(next);`
	`81`	`+ }`
	`82`	`+ catch (Exception ex)`
	`83`	`+ {`
	`84`	`+ SelfLog.WriteLine("{0} failed to emit event to wrapped sink: {1}", typeof(BackgroundWorkerSink), ex);`
	`85`	`+ }`
`79`	`86`	`}`
`80`	`87`	`}`
`81`		`- catch (Exception ex)`
	`88`	`+ catch (Exception fatal)`
`82`	`89`	`{`
`83`		`- SelfLog.WriteLine("{0} fatal error in worker thread: {1}", typeof(BackgroundWorkerSink), ex);`
	`90`	`+ SelfLog.WriteLine("{0} fatal error in worker thread: {1}", typeof(BackgroundWorkerSink), fatal);`
`84`	`91`	`}`
`85`	`92`	`}`
`86`	`93`
Original file line number	Diff line number	Diff line change
`@@ -11,17 +11,17 @@ namespace Serilog.Sinks.Async.PerformanceTests`
`11`	`11`	`{`
`12`	`12`	`public class LatencyBenchmark`
`13`	`13`	`{`
`14`		`- private readonly LogEvent _evt = new LogEvent(DateTimeOffset.Now, LogEventLevel.Information, null,`
	`14`	`+ readonly LogEvent _evt = new LogEvent(DateTimeOffset.Now, LogEventLevel.Information, null,`
`15`	`15`	`new MessageTemplate(new[] {new TextToken("Hello")}), new LogEventProperty[0]);`
`16`	`16`
`17`		`- private Logger _syncLogger, _asyncLogger, _fileLogger, _asyncFileLogger;`
	`17`	`+ Logger _syncLogger, _asyncLogger, _fileLogger, _asyncFileLogger;`
`18`	`18`
`19`	`19`	`static LatencyBenchmark()`
`20`	`20`	`{`
`21`	`21`	`SelfLog.Enable(new TerminatingTextWriter());`
`22`	`22`	`}`
`23`	`23`
`24`		`- [Setup]`
	`24`	`+ [GlobalSetup]`
`25`	`25`	`public void Reset()`
`26`	`26`	`{`
`27`	`27`	`foreach (var logger in new[] { _syncLogger, _asyncLogger, _fileLogger, _asyncFileLogger})`
Original file line number	Diff line number	Diff line change
`@@ -5,11 +5,11 @@`
`5`	`5`
`6`	`6`	`namespace Serilog.Sinks.Async.PerformanceTests`
`7`	`7`	`{`
`8`		`- internal class SignallingSink : ILogEventSink`
	`8`	`+ class SignallingSink : ILogEventSink`
`9`	`9`	`{`
`10`		`- private readonly int _expectedCount;`
`11`		`- private readonly ManualResetEvent _wh;`
`12`		`- private int _current;`
	`10`	`+ readonly int _expectedCount;`
	`11`	`+ readonly ManualResetEvent _wh;`
	`12`	`+ int _current;`
`13`	`13`
`14`	`14`	`public SignallingSink(int expectedCount)`
`15`	`15`	`{`
Original file line number	Diff line number	Diff line change
`@@ -8,20 +8,20 @@ namespace Serilog.Sinks.Async.PerformanceTests`
`8`	`8`	`{`
`9`	`9`	`public class ThroughputBenchmark`
`10`	`10`	`{`
`11`		`- private const int Count = 10000;`
	`11`	`+ const int Count = 10000;`
`12`	`12`
`13`		`- private readonly LogEvent _evt = new LogEvent(DateTimeOffset.Now, LogEventLevel.Information, null,`
	`13`	`+ readonly LogEvent _evt = new LogEvent(DateTimeOffset.Now, LogEventLevel.Information, null,`
`14`	`14`	`new MessageTemplate(new[] {new TextToken("Hello")}), new LogEventProperty[0]);`
`15`	`15`
`16`		`- private readonly SignallingSink _signal;`
`17`		`- private Logger _syncLogger, _asyncLogger;`
	`16`	`+ readonly SignallingSink _signal;`
	`17`	`+ Logger _syncLogger, _asyncLogger;`
`18`	`18`
`19`	`19`	`public ThroughputBenchmark()`
`20`	`20`	`{`
`21`	`21`	`_signal = new SignallingSink(Count);`
`22`	`22`	`}`
`23`	`23`
`24`		`- [Setup]`
	`24`	`+ [GlobalSetup]`
`25`	`25`	`public void Reset()`
`26`	`26`	`{`
`27`	`27`	`_syncLogger?.Dispose();`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ public class BackgroundWorkerSinkIntegrationSpec`
`15`	`15`	`/// <summary>`
`16`	`16`	`/// If <see cref="withDelay" />, then adds a 1sec delay before every fifth element created`
`17`	`17`	`/// </summary>`
`18`		`- private static void CreateAudits(ILogger logger, int count, bool withDelay)`
	`18`	`+ static void CreateAudits(ILogger logger, int count, bool withDelay)`
`19`	`19`	`{`
`20`	`20`	`var delay = TimeSpan.FromMilliseconds(1000);`
`21`	`21`	`var sw = new Stopwatch();`
`@@ -47,7 +47,7 @@ private static void CreateAudits(ILogger logger, int count, bool withDelay)`
`47`	`47`	`}`
`48`	`48`	`}`
`49`	`49`
`50`		`- private static List<LogEvent> RetrieveEvents(MemorySink sink, int count)`
	`50`	`+ static List<LogEvent> RetrieveEvents(MemorySink sink, int count)`
`51`	`51`	`{`
`52`	`52`	`Debug.WriteLine("{0:h:mm:ss tt} Retrieving {1} events", DateTime.Now, count);`
`53`	`53`
`@@ -91,9 +91,9 @@ public GivenBufferQueueAndDelays()`
`91`	`91`
`92`	`92`	`public abstract class SinkSpecBase : IDisposable`
`93`	`93`	`{`
`94`		`- private bool _delayCreation;`
`95`		`- private Logger _logger;`
`96`		`- private MemorySink _memorySink;`
	`94`	`+ bool _delayCreation;`
	`95`	`+ Logger _logger;`
	`96`	`+ MemorySink _memorySink;`
`97`	`97`
`98`	`98`	`protected SinkSpecBase(bool useBufferedQueue, bool delayCreation)`
`99`	`99`	`{`
Original file line number	Diff line number	Diff line change
`@@ -230,12 +230,12 @@ public void MonitorParameterAffordsSinkInspectorSuitableForHealthChecking()`
`230`	`230`	`Assert.Null(monitor.Inspector);`
`231`	`231`	`}`
`232`	`232`
`233`		`- private BackgroundWorkerSink CreateSinkWithDefaultOptions()`
	`233`	`+ BackgroundWorkerSink CreateSinkWithDefaultOptions()`
`234`	`234`	`{`
`235`	`235`	`return new BackgroundWorkerSink(_logger, 10000, false);`
`236`	`236`	`}`
`237`	`237`
`238`		`- private static LogEvent CreateEvent()`
	`238`	`+ static LogEvent CreateEvent()`
`239`	`239`	`{`
`240`	`240`	`return new LogEvent(DateTimeOffset.MaxValue, LogEventLevel.Error, null,`
`241`	`241`	`new MessageTemplate("amessage", Enumerable.Empty<MessageTemplateToken>()),`