SplunkUdpSinkConnectionInfo and injectable formatter

Supports:
  - Host
  - Port

Also ensured disposal of writer in emit.

Author: danielwertheim

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

@@ -27,6 +27,46 @@ namespace Serilog
     /// </summary>
     public static class LoggerConfigurationSplunkExtensions
     {
+        /// <summary>
+        /// Adds a sink that writes log events as to a Splunk instance via UDP.
+        /// </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 SplunkViaUdp(
+            this LoggerSinkConfiguration loggerConfiguration,
+            SplunkUdpSinkConnectionInfo connectionInfo,
+            LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
+            IFormatProvider formatProvider = null,
+            bool renderTemplate = true)
+        {
+            var sink = new UdpSink(connectionInfo, formatProvider, renderTemplate);
+
+            return loggerConfiguration.Sink(sink, restrictedToMinimumLevel);
+        }
+
+        /// <summary>
+        /// Adds a sink that writes log events as to a Splunk instance via UDP.
+        /// </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 SplunkViaUdp(
+            this LoggerSinkConfiguration loggerConfiguration,
+            SplunkUdpSinkConnectionInfo connectionInfo,
+            ITextFormatter formatter,
+            LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum)
+        {
+            var sink = new UdpSink(connectionInfo, formatter);
+
+            return loggerConfiguration.Sink(sink, restrictedToMinimumLevel);
+        }
+
         /// <summary>
         /// Adds a sink that writes log events as to a Splunk instance via UDP.
         /// </summary>
@@ -38,6 +78,7 @@ public static class LoggerConfigurationSplunkExtensions
         /// <param name="renderTemplate">If ture, the message template will be 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 SplunkViaUdp(
             this LoggerSinkConfiguration loggerConfiguration,
             string host,
@@ -63,6 +104,7 @@ public static LoggerConfiguration SplunkViaUdp(
         /// <param name="renderTemplate">If ture, the message template is rendered</param>
         /// <returns>The logger configuration</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 SplunkViaUdp(
             this LoggerSinkConfiguration loggerConfiguration,
             IPAddress hostAddresss,

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

@@ -86,6 +86,7 @@
     </Compile>
     <Compile Include="LoggerConfigurationSplunkExtensions.cs" />
     <Compile Include="Sinks\Splunk\SplunkTcpSinkConnectionInfo.cs" />
+    <Compile Include="Sinks\Splunk\SplunkUdpSinkConnectionInfo.cs" />
     <Compile Include="Sinks\Splunk\TcpSink.cs" />
     <Compile Include="Sinks\Splunk\UdpSink.cs" />
   </ItemGroup>

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

@@ -0,0 +1,41 @@
+using System.Net;
+
+namespace Serilog.Sinks.Splunk
+{
+    /// <summary>
+    /// Defines connection info used to connect against Splunk
+    /// using UDP.
+    /// </summary>
+    public class SplunkUdpSinkConnectionInfo
+    {
+        /// <summary>
+        /// Splunk host.
+        /// </summary>
+        public IPAddress Host { get; }
+
+        /// <summary>
+        /// Splunk port.
+        /// </summary>
+        public int Port { get; }
+
+        /// <summary>
+        /// Creates an instance of <see cref="SplunkUdpSinkConnectionInfo"/> used
+        /// for defining connection info for connecting using UDP against Splunk.
+        /// </summary>
+        /// <param name="host">Splunk host.</param>
+        /// <param name="port">Splunk UDP port.</param>
+        public SplunkUdpSinkConnectionInfo(string host, int port) : this(IPAddress.Parse(host), port){ }
+
+        /// <summary>
+        /// Creates an instance of <see cref="SplunkUdpSinkConnectionInfo"/> used
+        /// for defining connection info for connecting using UDP against Splunk.
+        /// </summary>
+        /// <param name="host">Splunk host.</param>
+        /// <param name="port">Splunk UDP port.</param>
+        public SplunkUdpSinkConnectionInfo(IPAddress host, int port)
+        {
+            Host = host;
+            Port = port;
+        }
+    }
+}

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

@@ -19,7 +19,7 @@
 using System.Text;
 using Serilog.Core;
 using Serilog.Events;
-using Serilog.Formatting.Json;
+using Serilog.Formatting;
 
 namespace Serilog.Sinks.Splunk
 {
@@ -28,22 +28,41 @@ namespace Serilog.Sinks.Splunk
     /// </summary>
     public class UdpSink : ILogEventSink, IDisposable
     {
-        readonly Socket _socket;
-        readonly JsonFormatter _jsonFormatter;
+        Socket _socket;
+        readonly ITextFormatter _formatter;
 
         /// <summary>
-        /// Creates an instance of the Splunk UDP Sink
+        /// 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="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 UdpSink(IPAddress hostAddress, int port, IFormatProvider formatProvider = null, bool renderTemplate = true)
+        public UdpSink(
+            SplunkUdpSinkConnectionInfo connectionInfo,
+            IFormatProvider formatProvider = null,
+            bool renderTemplate = true)
         {
-            _socket = new Socket(SocketType.Dgram, ProtocolType.Udp);
-            _socket.Connect(hostAddress, port);
+            Connect(connectionInfo);
+            _formatter = CreateDefaultFormatter(formatProvider, renderTemplate);
+        }
 
-            _jsonFormatter = new SplunkJsonFormatter(renderMessage: true, formatProvider: formatProvider, renderTemplate: 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 UdpSink(
+            SplunkUdpSinkConnectionInfo connectionInfo,
+            ITextFormatter formatter)
+        {
+            Connect(connectionInfo);
+            _formatter = formatter;
+        }
+
+        private void Connect(SplunkUdpSinkConnectionInfo connectionInfo)
+        {
+            _socket = new Socket(SocketType.Dgram, ProtocolType.Udp);
+            _socket.Connect(connectionInfo.Host, connectionInfo.Port);
         }
 
         /// <summary>
@@ -53,34 +72,47 @@ public UdpSink(IPAddress hostAddress, int port, IFormatProvider formatProvider =
         /// <param name="port">The UDP port configured in Splunk</param>
         /// <param name="formatProvider">Optional format provider</param>
         /// <param name="renderTemplate">If true, the message template is rendered</param>
-        public UdpSink(string host, int port, IFormatProvider formatProvider = null,
-             bool renderTemplate = true)
+        [Obsolete("Use the overload accepting a connection info object instead. This overload will be removed.", false)]
+        public UdpSink(string host, int port, IFormatProvider formatProvider = null, bool renderTemplate = true)
+            : this(new SplunkUdpSinkConnectionInfo(host, port), formatProvider, renderTemplate)
         {
-            _socket = new Socket(SocketType.Dgram, ProtocolType.Udp);
-            _socket.Connect(host, port);
+        }
 
-            _jsonFormatter = new SplunkJsonFormatter(renderMessage: true, formatProvider: formatProvider, renderTemplate:renderTemplate);
+        /// <summary>
+        /// Creates an instance of the Splunk UDP Sink
+        /// </summary>
+        /// <param name="hostAddress">The Splunk Host</param>
+        /// <param name="port">The UDP 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 UdpSink(IPAddress hostAddress, int port, IFormatProvider formatProvider = null, bool renderTemplate = true)
+            : this(new SplunkUdpSinkConnectionInfo(hostAddress, port),formatProvider, renderTemplate)
+        {
+        }
+
+        private static SplunkJsonFormatter CreateDefaultFormatter(IFormatProvider formatProvider, bool renderTemplate)
+        {
+            return new SplunkJsonFormatter(renderMessage: true, formatProvider: formatProvider, renderTemplate: renderTemplate);
         }
 
         /// <inheritdoc/>
         public void Emit(LogEvent logEvent)
         {
-            var sw = new StringWriter();
+            var sb = new StringBuilder();
 
-            _jsonFormatter.Format(logEvent, sw);
+            using (var sw = new StringWriter(sb))
+                _formatter.Format(logEvent, sw);
 
-            var message = sw.ToString();
-
-            _socket.Send(Encoding.UTF8.GetBytes(message));
+            _socket.Send(Encoding.UTF8.GetBytes(sb.ToString()));
         }
 
         /// <inheritdoc/>
         public void Dispose()
         {
-            _socket.Close();
-            _socket.Dispose();
+            _socket?.Close();
+            _socket?.Dispose();
+            _socket = null;
         }
     }
 }
-
-