SplunkTcpSinkConnectionInfo for collecting TCP config info

Supports:
  - Host
  - Port
  - Optinally queue size

Marked other overloads as obsolete so that they can be removed
in the future.

Author: danielwertheim

src/Serilog.Sinks.Splunk.FullNetFx/LoggerConfigurationSplunkExtensions.cs

@@ -16,6 +16,7 @@
 using System.Net;
 using Serilog.Configuration;
 using Serilog.Events;
+using Serilog.Formatting;
 using Serilog.Formatting.Display;
 using Serilog.Sinks.Splunk; 
 
@@ -75,6 +76,46 @@ public static LoggerConfiguration SplunkViaUdp(
             return loggerConfiguration.Sink(sink, restrictedToMinimumLevel);
         }
 
+        /// <summary>
+        /// Adds a sink that writes log events as to a Splunk instance via TCP.
+        /// </summary>
+        /// <param name="loggerConfiguration">The logger config</param>
+        /// <param name="connectionInfo"></param>
+        /// <param name="restrictedToMinimumLevel">The minimum log event level required in order to write an event to the sink.</param>
+        /// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
+        /// <param name="renderTemplate">If true, the message template is rendered</param>
+        /// <returns></returns>
+        public static LoggerConfiguration SplunkViaTcp(
+            this LoggerSinkConfiguration loggerConfiguration,
+            SplunkTcpSinkConnectionInfo connectionInfo,
+            LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
+            IFormatProvider formatProvider = null,
+            bool renderTemplate = true)
+        {
+            var sink = new TcpSink(connectionInfo, formatProvider, renderTemplate);
+
+            return loggerConfiguration.Sink(sink, restrictedToMinimumLevel);
+        }
+
+        /// <summary>
+        /// Adds a sink that writes log events as to a Splunk instance via TCP.
+        /// </summary>
+        /// <param name="loggerConfiguration">The logger config</param>
+        /// <param name="connectionInfo"></param>
+        /// <param name="formatter">Custom formatter to use if you e.g. do not want to use the JsonFormatter.</param>
+        /// <param name="restrictedToMinimumLevel">The minimum log event level required in order to write an event to the sink.</param>
+        /// <returns></returns>
+        public static LoggerConfiguration SplunkViaTcp(
+            this LoggerSinkConfiguration loggerConfiguration,
+            SplunkTcpSinkConnectionInfo connectionInfo,
+            ITextFormatter formatter,
+            LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum)
+        {
+            var sink = new TcpSink(connectionInfo, formatter);
+
+            return loggerConfiguration.Sink(sink, restrictedToMinimumLevel);
+        }
+
         /// <summary>
         /// Adds a sink that writes log events as to a Splunk instance via TCP.
         /// </summary>
@@ -86,6 +127,7 @@ public static LoggerConfiguration SplunkViaUdp(
         /// <param name="renderTemplate">If true, the message template is rendered</param>
         /// <returns></returns>
         /// <remarks>TODO: Add link to splunk configuration and wiki</remarks>
+        [Obsolete("Use the overload accepting a connection info object instead. This overload will be removed.", false)]
         public static LoggerConfiguration SplunkViaTcp(
             this LoggerSinkConfiguration loggerConfiguration,
             IPAddress hostAddresss,
@@ -110,6 +152,7 @@ public static LoggerConfiguration SplunkViaTcp(
         /// <param name="renderTemplate">If ture, the message template is rendered</param>
         /// <returns></returns>
         /// <remarks>TODO: Add link to splunk configuration and wiki</remarks>
+        [Obsolete("Use the overload accepting a connection info object instead. This overload will be removed.", false)]
         public static LoggerConfiguration SplunkViaTcp(
             this LoggerSinkConfiguration loggerConfiguration,
             string host,
@@ -122,6 +165,5 @@ public static LoggerConfiguration SplunkViaTcp(
 
             return loggerConfiguration.Sink(sink, restrictedToMinimumLevel);
         }
-
     }
 }

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

@@ -85,6 +85,7 @@
       <Link>Properties\CommonAssemblyInfo.cs</Link>
     </Compile>
     <Compile Include="LoggerConfigurationSplunkExtensions.cs" />
+    <Compile Include="Sinks\Splunk\SplunkTcpSinkConnectionInfo.cs" />
     <Compile Include="Sinks\Splunk\TcpSink.cs" />
     <Compile Include="Sinks\Splunk\UdpSink.cs" />
   </ItemGroup>

src/Serilog.Sinks.Splunk.FullNetFx/Sinks/Splunk/SplunkTcpSinkConnectionInfo.cs

@@ -0,0 +1,52 @@
+using System.Net;
+
+namespace Serilog.Sinks.Splunk
+{
+    /// <summary>
+    /// Defines connection info used to connect against Splunk
+    /// using TCP.
+    /// </summary>
+    public class SplunkTcpSinkConnectionInfo
+    {
+        /// <summary>
+        /// Default size of the socket writer queue.
+        /// </summary>
+        public const int DefaultMaxQueueSize = 10000;
+
+        /// <summary>
+        /// Splunk host.
+        /// </summary>
+        public IPAddress Host { get; }
+
+        /// <summary>
+        /// Splunk port.
+        /// </summary>
+        public int Port { get; }
+
+        /// <summary>
+        /// Max Queue size for the TCP socket writer.
+        /// See <see cref="DefaultMaxQueueSize"/> for default value (10000).
+        /// </summary>
+        public int MaxQueueSize { get; set; } = DefaultMaxQueueSize;
+
+        /// <summary>
+        /// Creates an instance of <see cref="SplunkTcpSinkConnectionInfo"/> used
+        /// for defining connection info for connecting using TCP against Splunk.
+        /// </summary>
+        /// <param name="host">Splunk host.</param>
+        /// <param name="port">Splunk TCP port.</param>
+        public SplunkTcpSinkConnectionInfo(string host, int port) : this(IPAddress.Parse(host), port){ }
+
+        /// <summary>
+        /// Creates an instance of <see cref="SplunkTcpSinkConnectionInfo"/> used
+        /// for defining connection info for connecting using TCP against Splunk.
+        /// </summary>
+        /// <param name="host">Splunk host.</param>
+        /// <param name="port">Splunk TCP port.</param>
+        public SplunkTcpSinkConnectionInfo(IPAddress host, int port)
+        {
+            Host = host;
+            Port = port;
+        }
+    }
+}

src/Serilog.Sinks.Splunk.FullNetFx/Sinks/Splunk/TcpSink.cs

@@ -32,57 +32,75 @@ public class TcpSink : ILogEventSink, IDisposable
         private TcpSocketWriter _writer;
 
         /// <summary>
-        /// Creates an instance of the Splunk TCP Sink
+        /// Creates an instance of the Splunk TCP Sink.
         /// </summary>
-        /// <param name="host">The Splunk Host</param>
-        /// <param name="port">The UDP port configured in Splunk</param>
+        /// <param name="connectionInfo">Connection info used for connecting against Splunk.</param>
         /// <param name="formatProvider">Optional format provider</param>
         /// <param name="renderTemplate">If true, the message template will be rendered</param>
         public TcpSink(
-            string host,
-            int port,
+            SplunkTcpSinkConnectionInfo connectionInfo,
             IFormatProvider formatProvider = null,
-            bool renderTemplate = true) : this(IPAddress.Parse(host), port, formatProvider, renderTemplate)
+            bool renderTemplate = true)
         {
+            _writer = CreateSocketWriter(connectionInfo);
+            _formatter = CreateDefaultFormatter(formatProvider, renderTemplate);
+        }
+
+        /// <summary>
+        /// Creates an instance of the Splunk TCP Sink.
+        /// </summary>
+        /// <param name="connectionInfo">Connection info used for connecting against Splunk.</param>
+        /// <param name="formatter">Custom formatter to use if you e.g. do not want to use the JsonFormatter.</param>
+        public TcpSink(
+            SplunkTcpSinkConnectionInfo connectionInfo,
+            ITextFormatter formatter)
+        {
+            _writer = CreateSocketWriter(connectionInfo);
+            _formatter = formatter;
         }
 
         /// <summary>
         /// Creates an instance of the Splunk TCP Sink
         /// </summary>
-        /// <param name="hostAddress">The Splunk Host</param>
-        /// <param name="port">The UDP port configured in Splunk</param>
+        /// <param name="host">The Splunk Host</param>
+        /// <param name="port">The TCP port configured in Splunk</param>
         /// <param name="formatProvider">Optional format provider</param>
         /// <param name="renderTemplate">If true, the message template will be rendered</param>
+        [Obsolete("Use the overload accepting a connection info object instead. This overload will be removed.", false)]
         public TcpSink(
-            IPAddress hostAddress,
+            string host,
             int port,
             IFormatProvider formatProvider = null,
-            bool renderTemplate = true)
+            bool renderTemplate = true) : this(new SplunkTcpSinkConnectionInfo(host, port), formatProvider, renderTemplate)
         {
-            _writer = CreateSocketWriter(hostAddress, port);
-            _formatter = new SplunkJsonFormatter(renderMessage: true, formatProvider: formatProvider, renderTemplate: renderTemplate);
         }
 
         /// <summary>
-        /// Creates an instance of the Splunk TCP sink.
+        /// Creates an instance of the Splunk TCP Sink
         /// </summary>
-        /// <param name="host">The Splunk Host</param>
-        /// <param name="port">The UDP port configured in Splunk</param>
-        /// <param name="formatter">Custom formatter to use if you e.g. do not want to use the JsonFormatter.</param>
+        /// <param name="hostAddress">The Splunk Host</param>
+        /// <param name="port">The TCP port configured in Splunk</param>
+        /// <param name="formatProvider">Optional format provider</param>
+        /// <param name="renderTemplate">If true, the message template will be rendered</param>
+        [Obsolete("Use the overload accepting a connection info object instead. This overload will be removed.", false)]
         public TcpSink(
-            string host,
+            IPAddress hostAddress,
             int port,
-            ITextFormatter formatter)
+            IFormatProvider formatProvider = null,
+            bool renderTemplate = true) : this(new SplunkTcpSinkConnectionInfo(hostAddress, port), formatProvider, renderTemplate)
         {
-            _writer = CreateSocketWriter(IPAddress.Parse(host), port);
-            _formatter = formatter;
         }
 
-        private static TcpSocketWriter CreateSocketWriter(IPAddress hostAddress, int port)
+        private static TcpSocketWriter CreateSocketWriter(SplunkTcpSinkConnectionInfo connectionInfo)
         {
             var reconnectionPolicy = new ExponentialBackoffTcpReconnectionPolicy();
 
-            return new TcpSocketWriter(hostAddress, port, reconnectionPolicy, 10000);
+            return new TcpSocketWriter(connectionInfo.Host, connectionInfo.Port, reconnectionPolicy, connectionInfo.MaxQueueSize);
+        }
+
+        private static SplunkJsonFormatter CreateDefaultFormatter(IFormatProvider formatProvider, bool renderTemplate)
+        {
+            return new SplunkJsonFormatter(renderMessage: true, formatProvider: formatProvider, renderTemplate: renderTemplate);
         }
 
         /// <inheritdoc/>
@@ -103,5 +121,4 @@ public void Dispose()
             _writer = null;
         }
     }
-}
-
+}