Merge pull request #8 from danielwertheim/feature/injectable-formatter

Feature/injectable formatter

Author: merbla

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; 
 
@@ -26,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>
@@ -37,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,
@@ -62,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,
@@ -75,6 +118,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 +169,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 +194,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 +207,5 @@ public static LoggerConfiguration SplunkViaTcp(
 
             return loggerConfiguration.Sink(sink, restrictedToMinimumLevel);
         }
-
     }
 }

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

@@ -85,6 +85,8 @@
       <Link>Properties\CommonAssemblyInfo.cs</Link>
     </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/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/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/TcpSink.cs

@@ -15,11 +15,10 @@
 using System;
 using System.IO;
 using System.Net;
-using System.Net.Sockets;
 using System.Text;
 using Serilog.Core;
 using Serilog.Events;
-using Serilog.Formatting.Json;
+using Serilog.Formatting;
 using Splunk.Logging;
 
 namespace Serilog.Sinks.Splunk
@@ -29,68 +28,97 @@ namespace Serilog.Sinks.Splunk
     /// </summary>
     public class TcpSink : ILogEventSink, IDisposable
     {
-        readonly JsonFormatter _jsonFormatter;
+        readonly ITextFormatter _formatter;
         private TcpSocketWriter _writer;
 
         /// <summary>
-        /// Creates an instance of the Splunk TCP 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 TcpSink(
-            IPAddress hostAddress,
-            int port,
+            SplunkTcpSinkConnectionInfo connectionInfo,
             IFormatProvider formatProvider = null,
             bool renderTemplate = true)
         {
-            var reconnectionPolicy = new ExponentialBackoffTcpReconnectionPolicy();
-
-            _writer = new TcpSocketWriter(hostAddress, port, reconnectionPolicy, 10000);
+            _writer = CreateSocketWriter(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 TcpSink(
+            SplunkTcpSinkConnectionInfo connectionInfo,
+            ITextFormatter formatter)
+        {
+            _writer = CreateSocketWriter(connectionInfo);
+            _formatter = formatter;
         }
 
         /// <summary>
         /// 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="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,
             int port,
             IFormatProvider formatProvider = null,
-            bool renderTemplate = true)
+            bool renderTemplate = true) : this(new SplunkTcpSinkConnectionInfo(host, port), formatProvider, renderTemplate)
+        {
+        }
+
+        /// <summary>
+        /// Creates an instance of the Splunk TCP Sink
+        /// </summary>
+        /// <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(
+            IPAddress hostAddress,
+            int port,
+            IFormatProvider formatProvider = null,
+            bool renderTemplate = true) : this(new SplunkTcpSinkConnectionInfo(hostAddress, port), formatProvider, renderTemplate)
+        {
+        }
+
+        private static TcpSocketWriter CreateSocketWriter(SplunkTcpSinkConnectionInfo connectionInfo)
         {
             var reconnectionPolicy = new ExponentialBackoffTcpReconnectionPolicy();
-            var ipAddress = IPAddress.Parse(host);
 
-            _writer = new TcpSocketWriter(ipAddress, port, reconnectionPolicy, 10000);
+            return new TcpSocketWriter(connectionInfo.Host, connectionInfo.Port, reconnectionPolicy, connectionInfo.MaxQueueSize);
+        }
 
-            _jsonFormatter = new SplunkJsonFormatter(renderMessage: true, formatProvider: formatProvider, renderTemplate: 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();
-
-            _writer.Enqueue(message);
+            _writer.Enqueue(sb.ToString());
         }
 
         /// <inheritdoc/>
         public void Dispose()
         {
-            _writer.Dispose();
+            _writer?.Dispose();
+            _writer = null;
         }
     }
-}
-
+}