Update to serilog periodic batching 4.x

.dockerignore

@@ -1,2 +1,2 @@
-bin\
-obj\
+bin/
+obj/

Dockerfile

@@ -1,10 +1,10 @@
-FROM microsoft/dotnet:2.1-sdk AS build
-ADD . / 
+FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
+COPY . / 
 WORKDIR /sample/Sample
 RUN dotnet restore
-RUN dotnet publish -c Release -o out -f netcoreapp2.0
+RUN dotnet publish -c Release -o out -f net6.0
 
-FROM microsoft/dotnet:2.1-runtime AS runtime
+FROM mcr.microsoft.com/dotnet/runtime:6.0 AS runtime
 WORKDIR /sample/Sample
 COPY --from=build /sample/Sample/out ./
 ENTRYPOINT ["dotnet", "Sample.dll"]

build.sh

@@ -7,10 +7,11 @@ dotnet restore
 for path in src/**/Serilog.Sinks.Splunk.csproj; do
     dotnet build -f netstandard2.0 -c Release ${path}
     dotnet build -f netstandard2.1 -c Release ${path}
+    dotnet build -f net6.0 -c Release ${path}
 done
 
 for path in test/*.Tests/*.csproj; do
-    dotnet test -f net5.0  -c Release ${path}
+    dotnet test -f net6.0  -c Release ${path}
 done
 
-dotnet build -f net5.0 -c Release sample/Sample/Sample.csproj
+dotnet build -f net6.0 -c Release sample/Sample/Sample.csproj

sample/Sample/Sample.csproj

@@ -1,17 +1,15 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>net6.0</TargetFramework>
-    <UserSecretsId>7e06bf41-4a1d-4a41-bcf3-cacd41388d5f</UserSecretsId>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="7.0.0" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.UserSecrets" Version="6.0.1" />
-    <PackageReference Include="Serilog" Version="3.0.1" />
-    <PackageReference Include="Serilog.Sinks.Console" Version="4.1.0" />
-    <PackageReference Include="Serilog.Settings.Configuration" Version="7.0.0" />
+    <PackageReference Include="Serilog" Version="3.1.1" />
+    <PackageReference Include="Serilog.Sinks.Console" Version="5.0.1" />
+    <PackageReference Include="Serilog.Settings.Configuration" Version="3.3.0" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="6.0.0" />
   </ItemGroup>
 
   <ItemGroup>

sample/splunk/Dockerfile

@@ -1,2 +1,2 @@
-FROM splunk/splunk:9.1
+FROM splunk/splunk:latest
 ADD etc ${SPLUNK_HOME}/etc

src/Serilog.Sinks.Splunk/Serilog.Sinks.Splunk.csproj

@@ -1,10 +1,10 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <Description>The Splunk Sink for Serilog</Description>
-    <VersionPrefix>3.7.0</VersionPrefix>
+    <VersionPrefix>4.0.0</VersionPrefix>
     <Authors>Matthew Erbs, Serilog Contributors</Authors>
-    <TargetFrameworks>netstandard2.1;netstandard2.0</TargetFrameworks>
+    <TargetFrameworks>netstandard2.1;netstandard2.0;net6.0</TargetFrameworks>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <AssemblyName>Serilog.Sinks.Splunk</AssemblyName>
     <PackageId>Serilog.Sinks.Splunk</PackageId>
@@ -18,12 +18,13 @@
     <PublicSign Condition=" '$(OS)' != 'Windows_NT' ">true</PublicSign>
     <SignAssembly>true</SignAssembly>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-	<LangVersion>latest</LangVersion>
+    <RootNamespace>Serilog</RootNamespace>
+	  <LangVersion>latest</LangVersion>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Serilog" Version="2.10.0" />
-    <PackageReference Include="Serilog.Sinks.PeriodicBatching" Version="2.3.0" />
+    <PackageReference Include="Serilog" Version="3.1.1" />
+    <PackageReference Include="Serilog.Sinks.PeriodicBatching" Version="4.0.0" />
   </ItemGroup>
 
 </Project>

src/Serilog.Sinks.Splunk/Sinks/Splunk/EventCollectorSink.cs

@@ -29,9 +29,9 @@ namespace Serilog.Sinks.Splunk
     /// <summary>
     /// A sink to log to the Event Collector available in Splunk 6.3
     /// </summary>
-    public class EventCollectorSink : PeriodicBatchingSink
+    public class EventCollectorSink : IBatchedLogEventSink
     {
-        private const int DefaultQueueLimit = 100000;
+        internal const int DefaultQueueLimit = 100000;
 
         private readonly string _splunkHost;
         private readonly string _uriPath;
@@ -54,26 +54,17 @@ public class EventCollectorSink : PeriodicBatchingSink
         /// </summary>
         /// <param name="splunkHost">The host of the Splunk instance with the Event collector configured</param>
         /// <param name="eventCollectorToken">The token to use when authenticating with the event collector</param>
-        /// <param name="batchSizeLimit">The size of the batch when sending to the event collector</param>
         /// <param name="formatProvider">The format provider used when rendering the message</param>
         /// <param name="renderTemplate">Whether to render the message template</param>
-        /// <param name="batchIntervalInSeconds">The interval in seconds that batching should occur</param>
-        /// <param name="queueLimit">Maximum number of events in the queue</param>
         public EventCollectorSink(
             string splunkHost,
             string eventCollectorToken,
-            int batchIntervalInSeconds = 5,
-            int batchSizeLimit = 100,
-            int? queueLimit = null,
             IFormatProvider formatProvider = null,
             bool renderTemplate = true)
             : this(
                 splunkHost,
                 eventCollectorToken,
                 null, null, null, null, null,
-                batchIntervalInSeconds,
-                batchSizeLimit,
-                queueLimit,
                 formatProvider,
                 renderTemplate)
         {
@@ -85,11 +76,8 @@ public EventCollectorSink(
         /// <param name="splunkHost">The host of the Splunk instance with the Event collector configured</param>
         /// <param name="eventCollectorToken">The token to use when authenticating with the event collector</param>
         /// <param name="uriPath">Change the default endpoint of the Event Collector e.g. services/collector/event</param>
-        /// <param name="batchSizeLimit">The size of the batch when sending to the event collector</param>
         /// <param name="formatProvider">The format provider used when rendering the message</param>
         /// <param name="renderTemplate">Whether to render the message template</param>
-        /// <param name="batchIntervalInSeconds">The interval in seconds that batching should occur</param>
-        /// <param name="queueLimit">Maximum number of events in the queue</param>
         /// <param name="index">The Splunk index to log to</param>
         /// <param name="source">The source of the event</param>
         /// <param name="sourceType">The source type of the event</param>
@@ -103,19 +91,14 @@ public EventCollectorSink(
             string sourceType,
             string host,
             string index,
-            int batchIntervalInSeconds,
-            int batchSizeLimit,
-            int? queueLimit,
             IFormatProvider formatProvider = null,
             bool renderTemplate = true,
             HttpMessageHandler messageHandler = null)
             : this(
                 splunkHost,
                 eventCollectorToken,
                 uriPath,
-                batchIntervalInSeconds,
-                batchSizeLimit,
-                queueLimit,
+
                 new SplunkJsonFormatter(renderTemplate, formatProvider, source, sourceType, host, index),
                 messageHandler)
         {
@@ -127,11 +110,8 @@ public EventCollectorSink(
         /// <param name="splunkHost">The host of the Splunk instance with the Event collector configured</param>
         /// <param name="eventCollectorToken">The token to use when authenticating with the event collector</param>
         /// <param name="uriPath">Change the default endpoint of the Event Collector e.g. services/collector/event</param>
-        /// <param name="batchSizeLimit">The size of the batch when sending to the event collector</param>
-        /// <param name="queueLimit">Maximum number of events in the queue</param>
         /// <param name="formatProvider">The format provider used when rendering the message</param>
         /// <param name="renderTemplate">Whether to render the message template</param>
-        /// <param name="batchIntervalInSeconds">The interval in seconds that batching should occur</param>
         /// <param name="index">The Splunk index to log to</param>
         /// <param name="fields">Add extra CustomExtraFields for Splunk to index</param>
         /// <param name="source">The source of the event</param>
@@ -147,9 +127,6 @@ public EventCollectorSink(
             string host,
             string index,
             CustomFields fields,
-            int batchIntervalInSeconds,
-            int batchSizeLimit,
-            int? queueLimit,
             IFormatProvider formatProvider = null,
             bool renderTemplate = true,
             HttpMessageHandler messageHandler = null)
@@ -158,9 +135,6 @@ public EventCollectorSink(
                 splunkHost,
                 eventCollectorToken,
                 uriPath,
-                batchIntervalInSeconds,
-                batchSizeLimit,
-                queueLimit,
                 new SplunkJsonFormatter(renderTemplate, formatProvider, source, sourceType, host, index, fields),
                 messageHandler)
         {
@@ -172,21 +146,14 @@ public EventCollectorSink(
         /// <param name="splunkHost">The host of the Splunk instance with the Event collector configured</param>
         /// <param name="eventCollectorToken">The token to use when authenticating with the event collector</param>
         /// <param name="uriPath">Change the default endpoint of the Event Collector e.g. services/collector/event</param>
-        /// <param name="batchSizeLimit">The size of the batch when sending to the event collector</param>
-        /// <param name="batchIntervalInSeconds">The interval in seconds that batching should occur</param>
-        /// <param name="queueLimit">Maximum number of events in the queue</param>
         /// <param name="jsonFormatter">The text formatter used to render log events into a JSON format for consumption by Splunk</param>
         /// <param name="messageHandler">The handler used to send HTTP requests</param>
         public EventCollectorSink(
             string splunkHost,
             string eventCollectorToken,
             string uriPath,
-            int batchIntervalInSeconds,
-            int batchSizeLimit,
-            int? queueLimit,
             ITextFormatter jsonFormatter,
             HttpMessageHandler messageHandler = null)
-            : base(batchSizeLimit, TimeSpan.FromSeconds(batchIntervalInSeconds), queueLimit ?? DefaultQueueLimit)
         {
             _uriPath = uriPath;
             _splunkHost = splunkHost;
@@ -197,14 +164,8 @@ public EventCollectorSink(
                 : new EventCollectorClient(eventCollectorToken);
         }
 
-        /// <summary>
-        ///     Emit a batch of log events, running asynchronously.
-        /// </summary>
-        /// <param name="events">The events to emit.</param>
-        /// <remarks>
-        ///     Override either <see cref="PeriodicBatchingSink.EmitBatch" /> or <see cref="PeriodicBatchingSink.EmitBatchAsync" />, not both.
-        /// </remarks>
-        protected override async Task EmitBatchAsync(IEnumerable<LogEvent> events)
+        /// <inheritdoc />
+        public async Task EmitBatchAsync(IEnumerable<LogEvent> events)
         {
             var allEvents = new StringWriter();
 
@@ -233,5 +194,8 @@ protected override async Task EmitBatchAsync(IEnumerable<LogEvent> events)
                 }
             }
         }
+
+        /// <inheritdoc />
+        public Task OnEmptyBatchAsync() => Task.CompletedTask;
     }
 }

src/Serilog.Sinks.Splunk/SplunkLoggingConfigurationExtensions.cs

@@ -19,6 +19,7 @@
 using Serilog.Core;
 using Serilog.Events;
 using Serilog.Formatting;
+using Serilog.Sinks.PeriodicBatching;
 using Serilog.Sinks.Splunk;
 
 namespace Serilog
@@ -76,14 +77,12 @@ public static LoggerConfiguration EventCollector(
                 sourceType, 
                 host, 
                 index,
-                batchIntervalInSeconds,
-                batchSizeLimit,
-                queueLimit,
                 formatProvider,
                 renderTemplate,
                 messageHandler);
 
-            return configuration.Sink(eventCollectorSink, restrictedToMinimumLevel, levelSwitch);
+            return configuration.BuildPeriodicBatchingSink(eventCollectorSink, restrictedToMinimumLevel, levelSwitch,
+                batchIntervalInSeconds, batchSizeLimit, queueLimit);
         }
 
         /// <summary>
@@ -122,13 +121,12 @@ public static LoggerConfiguration EventCollector(
                 splunkHost,
                 eventCollectorToken,
                 uriPath,
-                batchIntervalInSeconds,
-                batchSizeLimit,
-                queueLimit,
+
                 jsonFormatter,
                 messageHandler);
 
-            return configuration.Sink(eventCollectorSink, restrictedToMinimumLevel, levelSwitch);
+            return configuration.BuildPeriodicBatchingSink(eventCollectorSink, restrictedToMinimumLevel, levelSwitch,
+                batchIntervalInSeconds, batchSizeLimit, queueLimit);
         }
 
 
@@ -183,15 +181,30 @@ public static LoggerConfiguration EventCollector(
                 host,
                 index,
                 fields,
-                batchIntervalInSeconds,
-                batchSizeLimit,
-                queueLimit,
                 formatProvider,
                 renderTemplate,
                 messageHandler
                 );
 
-            return configuration.Sink(eventCollectorSink, restrictedToMinimumLevel, levelSwitch);
+            return configuration.BuildPeriodicBatchingSink(eventCollectorSink, restrictedToMinimumLevel, levelSwitch,
+                batchIntervalInSeconds, batchSizeLimit, queueLimit);
+        }
+
+        private static LoggerConfiguration BuildPeriodicBatchingSink(this LoggerSinkConfiguration configuration,
+            EventCollectorSink eventCollectorSink,
+            LogEventLevel restrictedToMinimumLevel,
+            LoggingLevelSwitch levelSwitch = null,
+            int batchIntervalInSeconds = 2,
+            int batchSizeLimit = 100,
+            int? queueLimit = EventCollectorSink.DefaultQueueLimit)
+        {
+            var periodicBatchingOptions = new PeriodicBatchingSinkOptions
+            {
+                Period = TimeSpan.FromSeconds(batchIntervalInSeconds), QueueLimit = queueLimit, BatchSizeLimit = batchSizeLimit
+            };
+            var periodicBatchSink = new PeriodicBatchingSink(eventCollectorSink, periodicBatchingOptions);
+
+            return configuration.Sink(periodicBatchSink, restrictedToMinimumLevel, levelSwitch);
         }
     }
 }