Move all JSON formatting into SplunkJsonFormatter; fixes #29 also

Author: nblumhardt

src/Serilog.Sinks.Splunk/Sinks/Splunk/EventCollectorRequest.cs

@@ -14,55 +14,11 @@
 
 
 using System;
-using System.Globalization;
 using System.Net.Http;
 using System.Text;
 
 namespace Serilog.Sinks.Splunk
 {
-    internal class SplunkEvent
-    {
-        private string _payload;
-
-        internal SplunkEvent(string logEvent, string source, string sourceType, string host, string index, double time)
-        {
-            _payload = string.Empty;
-
-            var jsonPayLoad = @"{""event"":" + logEvent
-            .Replace("\r\n", string.Empty);
-
-            if (!string.IsNullOrWhiteSpace(source))
-            {
-                jsonPayLoad = jsonPayLoad + @",""source"":""" + source + @"""";
-            }
-            if (!string.IsNullOrWhiteSpace(sourceType))
-            {
-                jsonPayLoad = jsonPayLoad + @",""sourceType"":""" + sourceType + @"""";
-            }
-            if (!string.IsNullOrWhiteSpace(host))
-            {
-                jsonPayLoad = jsonPayLoad + @",""host"":""" + host + @"""";
-            }
-            if (!string.IsNullOrWhiteSpace(index))
-            {
-                jsonPayLoad = jsonPayLoad + @",""index"":""" + index + @"""";
-            }
-
-            if (time > 0)
-            {
-                jsonPayLoad = jsonPayLoad + @",""time"":" +  time.ToString(CultureInfo.InvariantCulture);
-            }
-
-            jsonPayLoad = jsonPayLoad + "}";
-            _payload = jsonPayLoad;
-        }
-
-        public string Payload
-        {
-            get { return _payload; }
-        }
-    }
-
     internal class EventCollectorRequest : HttpRequestMessage
     {
         internal EventCollectorRequest(string splunkHost, string jsonPayLoad, string uri ="services/collector")

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

@@ -18,7 +18,6 @@
 using System.IO;
 using System.Linq;
 using System.Net;
-using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
 using Serilog.Core;
@@ -33,20 +32,11 @@ namespace Serilog.Sinks.Splunk
     public class EventCollectorSink : ILogEventSink, IDisposable
     {
         private readonly string _splunkHost;
-        private readonly string _eventCollectorToken;
-        private readonly string _source;
-        private readonly string _sourceType;
-        private readonly string _host;
-        private readonly string _index;
         private readonly string _uriPath;
         private readonly int _batchSizeLimitLimit;
         private readonly SplunkJsonFormatter _jsonFormatter;
         private readonly ConcurrentQueue<LogEvent> _queue;
         private readonly EventCollectorClient _httpClient;
-        private const string DefaultSource = "";
-        private const string DefaultSourceType = "";
-        private const string DefaultHost = "";
-        private const string DefaultIndex = "";
 
         /// <summary>
         /// Taken from Splunk.Logging.Common
@@ -56,7 +46,7 @@ public class EventCollectorSink : ILogEventSink, IDisposable
             HttpStatusCode.Forbidden,
             HttpStatusCode.MethodNotAllowed,
             HttpStatusCode.BadRequest
-        }; 
+        };
 
         /// <summary>
         /// Creates a new instance of the sink
@@ -73,24 +63,16 @@ public EventCollectorSink(
             int batchIntervalInSeconds = 5,
             int batchSizeLimit = 100,
             IFormatProvider formatProvider = null,
-            bool renderTemplate = true
-            )
+            bool renderTemplate = true)
+            : this(
+                splunkHost,
+                eventCollectorToken,
+                null, null, null, null, null, 
+                batchIntervalInSeconds, 
+                batchSizeLimit,
+                formatProvider,
+                renderTemplate)
         {
-            _splunkHost = splunkHost;
-            _eventCollectorToken = eventCollectorToken;
-            _queue = new ConcurrentQueue<LogEvent>();
-            _jsonFormatter = new SplunkJsonFormatter(renderMessage: true, formatProvider: formatProvider, renderTemplate: renderTemplate);
-            _batchSizeLimitLimit = batchSizeLimit;
-
-            var batchInterval = TimeSpan.FromSeconds(batchIntervalInSeconds);
-            _httpClient = new EventCollectorClient(_eventCollectorToken);
-            
-            var cancellationToken = new CancellationToken();
-            
-            RepeatAction.OnInterval(
-                batchInterval,
-                async () => await ProcessQueue(),
-                cancellationToken);
         } 
 
         /// <summary>
@@ -118,19 +100,23 @@ public EventCollectorSink(
             int batchIntervalInSeconds,
             int batchSizeLimit,
             IFormatProvider formatProvider = null,
-            bool renderTemplate = true
-            ) : this(splunkHost,
-                eventCollectorToken,
-                batchIntervalInSeconds,
-                batchSizeLimit,
-                formatProvider,
-                renderTemplate)
+            bool renderTemplate = true)
         {
-            _source = source;
-            _sourceType = sourceType;
-            _host = host;
-            _index = index;
             _uriPath = uriPath;
+            _splunkHost = splunkHost;
+            _queue = new ConcurrentQueue<LogEvent>();
+            _jsonFormatter = new SplunkJsonFormatter(renderTemplate, formatProvider, source, sourceType, host, index);
+            _batchSizeLimitLimit = batchSizeLimit;
+
+            var batchInterval = TimeSpan.FromSeconds(batchIntervalInSeconds);
+            _httpClient = new EventCollectorClient(eventCollectorToken);
+
+            var cancellationToken = new CancellationToken();
+
+            RepeatAction.OnInterval(
+                batchInterval,
+                async () => await ProcessQueue(),
+                cancellationToken);
         }
 
         /// <summary>
@@ -175,21 +161,14 @@ private async Task ProcessQueue()
 
         private async Task Send(IEnumerable<LogEvent> events)
         {
-            string allEvents = string.Empty;
+            var allEvents = new StringWriter();
 
             foreach (var logEvent in events)
             {
-                var sw = new StringWriter();
-                _jsonFormatter.Format(logEvent, sw);
-
-                var serialisedEvent = sw.ToString();
-
-                var splunkEvent = new SplunkEvent(serialisedEvent, _source, _sourceType, _host, _index, logEvent.Timestamp.ToEpoch());
-
-                allEvents = $"{allEvents}{splunkEvent.Payload}";
+                _jsonFormatter.Format(logEvent, allEvents);
             }
 
-            var request = new EventCollectorRequest(_splunkHost, allEvents, _uriPath);
+            var request = new EventCollectorRequest(_splunkHost, allEvents.ToString(), _uriPath);
             var response = await _httpClient.SendAsync(request);
 
             if (response.IsSuccessStatusCode)

src/Serilog.Sinks.Splunk/Sinks/Splunk/SplunkJsonFormatter.cs

@@ -14,6 +14,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.IO;
 using Serilog.Events;
 using Serilog.Formatting;
@@ -29,24 +30,69 @@ public class SplunkJsonFormatter : ITextFormatter
         static readonly JsonValueFormatter ValueFormatter = new JsonValueFormatter();
 
         readonly bool _renderTemplate;
-        readonly bool _renderMessage;
         readonly IFormatProvider _formatProvider;
+        readonly string _suffix;
 
         /// <summary>
         /// Construct a <see cref="SplunkJsonFormatter"/>.
         /// </summary>
-        /// <param name="renderMessage">If true, the message will be rendered and written to the output as a
-        /// property named RenderedMessage.</param>
         /// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
         /// <param name="renderTemplate">If true, the template used will be rendered and written to the output as a property named MessageTemplate</param>
         public SplunkJsonFormatter(
-            bool renderTemplate = true,
-            bool renderMessage = false,
-            IFormatProvider formatProvider = null)
+            bool renderTemplate,
+            IFormatProvider formatProvider)
+            : this(renderTemplate, formatProvider, null, null, null, null)
+        {
+        }
+
+        /// <summary>
+        /// Construct a <see cref="SplunkJsonFormatter"/>.
+        /// </summary>
+        /// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
+        /// <param name="renderTemplate">If true, the template used will be rendered and written to the output as a property named MessageTemplate</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>
+        /// <param name="host">The host of the event</param>
+        public SplunkJsonFormatter(
+            bool renderTemplate,
+            IFormatProvider formatProvider,
+            string source,
+            string sourceType,
+            string host,
+            string index)
         {
             _renderTemplate = renderTemplate;
-            _renderMessage = renderMessage;
             _formatProvider = formatProvider;
+
+            var suffixWriter = new StringWriter();
+            suffixWriter.Write("}"); // Terminates "event"
+
+            if (!string.IsNullOrWhiteSpace(source))
+            {
+                suffixWriter.Write(",\"source\":");
+                JsonValueFormatter.WriteQuotedJsonString(source, suffixWriter);
+            }
+
+            if (!string.IsNullOrWhiteSpace(sourceType))
+            {
+                suffixWriter.Write(",\"sourceType\":");
+                JsonValueFormatter.WriteQuotedJsonString(sourceType, suffixWriter);
+            }
+
+            if (!string.IsNullOrWhiteSpace(host))
+            {
+                suffixWriter.Write(",\"host\":");
+                JsonValueFormatter.WriteQuotedJsonString(host, suffixWriter);
+            }
+
+            if (!string.IsNullOrWhiteSpace(index))
+            {
+                suffixWriter.Write(",\"index\":");
+                JsonValueFormatter.WriteQuotedJsonString(index, suffixWriter);
+            }
+            suffixWriter.Write('}'); // Terminates the payload
+            _suffix = suffixWriter.ToString();
         }
 
         /// <inheritdoc/>
@@ -55,22 +101,20 @@ public void Format(LogEvent logEvent, TextWriter output)
             if (logEvent == null) throw new ArgumentNullException(nameof(logEvent));
             if (output == null) throw new ArgumentNullException(nameof(output));
 
-            output.Write("{\"Timestamp\":\"");
-            output.Write(logEvent.Timestamp.ToString("o"));
-            output.Write("\",\"Level\":\"");
+            output.Write("{\"time\":\"");
+            output.Write(logEvent.Timestamp.ToEpoch().ToString(CultureInfo.InvariantCulture));
+            output.Write("\",\"event\":{\"Level\":\"");
             output.Write(logEvent.Level);
+            output.Write('"');
 
             if (_renderTemplate)
             {
                 output.Write("\",\"MessageTemplate\":");
                 JsonValueFormatter.WriteQuotedJsonString(logEvent.MessageTemplate.Text, output);
             }
 
-            if (_renderMessage)
-            {
-                output.Write(",\"RenderedMessage\":");
-                JsonValueFormatter.WriteQuotedJsonString(logEvent.RenderMessage(_formatProvider), output);
-            }
+            output.Write(",\"RenderedMessage\":");
+            JsonValueFormatter.WriteQuotedJsonString(logEvent.RenderMessage(_formatProvider), output);
 
             if (logEvent.Exception != null)
             {
@@ -81,8 +125,7 @@ public void Format(LogEvent logEvent, TextWriter output)
             if (logEvent.Properties.Count != 0)
                 WriteProperties(logEvent.Properties, output);
 
-            output.Write('}');
-            output.WriteLine();
+            output.WriteLine(_suffix);
         }
 
         static void WriteProperties(IReadOnlyDictionary<string, LogEventPropertyValue> properties, TextWriter output)

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

@@ -102,7 +102,7 @@ private static TcpSocketWriter CreateSocketWriter(SplunkTcpSinkConnectionInfo co
 
         private static SplunkJsonFormatter CreateDefaultFormatter(IFormatProvider formatProvider, bool renderTemplate)
         {
-            return new SplunkJsonFormatter(renderMessage: true, formatProvider: formatProvider, renderTemplate: renderTemplate);
+            return new SplunkJsonFormatter(renderTemplate, formatProvider);
         }
 
         /// <inheritdoc/>

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

@@ -96,7 +96,7 @@ public UdpSink(IPAddress hostAddress, int port, IFormatProvider formatProvider =
 
         private static SplunkJsonFormatter CreateDefaultFormatter(IFormatProvider formatProvider, bool renderTemplate)
         {
-            return new SplunkJsonFormatter(renderMessage: true, formatProvider: formatProvider, renderTemplate: renderTemplate);
+            return new SplunkJsonFormatter(renderTemplate, formatProvider);
         }
 
         /// <inheritdoc/>

test/Serilog.Sinks.Splunk.Tests/SplunkJsonFormatterTests.cs

@@ -11,7 +11,7 @@ public class SplunkJsonFormatterTests
         void AssertValidJson(Action<ILogger> act)
         {
             var output = new StringWriter();
-            var formatter = new SplunkJsonFormatter();
+            var formatter = new SplunkJsonFormatter(false, null);
             var log = new LoggerConfiguration()
                 .WriteTo.Sink(new TextWriterSink(output, formatter))
                 .CreateLogger();