Added portable time from Seq

Author: merbla

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

@@ -46,7 +46,6 @@ internal class EventCollectorRequest : HttpRequestMessage
     {
         internal EventCollectorRequest(string splunkHost, string jsonPayLoad)
         {
-
             var stringContent = new StringContent(jsonPayLoad, Encoding.UTF8, "application/json");
             RequestUri = new Uri(splunkHost);
             Content = stringContent;

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

@@ -42,6 +42,7 @@ public class EventCollectorSink : ILogEventSink, IDisposable
         private readonly SplunkJsonFormatter _jsonFormatter;
         private readonly ConcurrentQueue<LogEvent> _queue;
         private readonly EventCollectorClient _httpClient;
+        private readonly PortableTimer _timer;
 
         /// <summary>
         /// Taken from Splunk.Logging.Common
@@ -53,6 +54,7 @@ public class EventCollectorSink : ILogEventSink, IDisposable
             HttpStatusCode.BadRequest
         };
 
+
         /// <summary>
         /// Creates a new instance of the sink
         /// </summary>
@@ -80,9 +82,13 @@ public EventCollectorSink(
             var batchInterval = TimeSpan.FromSeconds(batchIntervalInSeconds);
 
             _httpClient = new EventCollectorClient(_eventCollectorToken);
-
+            
             var cancellationToken = new CancellationToken();
 
+          //  _timer = new PortableTimer(async c => await ProcessQueue());
+
+
+
             RepeatAction.OnInterval(
                 batchInterval,
                 async () => await ProcessQueue(),
@@ -181,8 +187,8 @@ private async Task Send(IEnumerable<LogEvent> events)
 
                 allEvents = $"{allEvents}{splunkEvent.Payload}";
             }
-            var request = new EventCollectorRequest(_splunkHost, allEvents);
 
+            var request = new EventCollectorRequest(_splunkHost, allEvents);
             var response = await _httpClient.SendAsync(request);
 
             if (response.IsSuccessStatusCode)

src/Serilog.Sinks.Splunk/Sinks/Splunk/PortableTimer.cs

@@ -0,0 +1,108 @@
+// Copyright 2013-2015 Serilog Contributors
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// 
+//     http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#if !TIMER
+using Serilog.Debugging;
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Serilog.Sinks.Splunk
+{
+    class PortableTimer : IDisposable
+    {
+        enum PortableTimerState
+        {
+            NotWaiting,
+            Waiting,
+            Active,
+            Disposed
+        }
+
+        readonly object _stateLock = new object();
+        PortableTimerState _state = PortableTimerState.NotWaiting;
+
+        readonly Action<CancellationToken> _onTick;
+        readonly CancellationTokenSource _cancel = new CancellationTokenSource();
+
+        public PortableTimer(Action<CancellationToken> onTick)
+        {
+            if (onTick == null) throw new ArgumentNullException(nameof(onTick));
+            _onTick = onTick;
+        }
+
+        public async void Start(TimeSpan interval)
+        {
+            if (interval < TimeSpan.Zero) throw new ArgumentOutOfRangeException(nameof(interval));
+
+            lock (_stateLock)
+            {
+                if (_state == PortableTimerState.Disposed)
+                    throw new ObjectDisposedException("PortableTimer");
+
+                // There's a little bit of raciness here, but it's needed to support the
+                // current API, which allows the tick handler to reenter and set the next interval.
+
+                if (_state == PortableTimerState.Waiting)
+                    throw new InvalidOperationException("The timer is already set.");
+
+                if (_cancel.IsCancellationRequested) return;
+
+                _state = PortableTimerState.Waiting;
+            }
+
+            try
+            {
+                await Task.Delay(interval, _cancel.Token).ConfigureAwait(false);
+
+                _state = PortableTimerState.Active;
+
+                if (!_cancel.Token.IsCancellationRequested)
+                {
+                    _onTick(_cancel.Token);
+                }
+            }
+            catch (TaskCanceledException tcx)
+            {
+                SelfLog.WriteLine("The timer was canceled during invocation: {0}", tcx);
+            }
+            finally
+            {
+                lock (_stateLock)
+                    _state = PortableTimerState.NotWaiting;
+            }
+        }
+
+        public void Dispose()
+        {
+            _cancel.Cancel();
+
+            while (true)
+            {
+                lock (_stateLock)
+                {
+                    if (_state == PortableTimerState.Disposed ||
+                        _state == PortableTimerState.NotWaiting)
+                    {
+                        _state = PortableTimerState.Disposed;
+                        return;
+                    }
+                }
+
+                Thread.Sleep(10);
+            }
+        }
+    }
+}
+#endif

src/Serilog.Sinks.Splunk/project.json

@@ -11,6 +11,9 @@
   },
   "frameworks": {
     "net45": {
+      "compilationOptions": {
+        "define": ["TCP", "UDP"]
+      },
       "dependencies": {
         "System.Net.Http": "2.0.20710"
       }

src/sample/Program.cs

@@ -1,19 +1,28 @@
-using System.Linq;
+using System;
+using System.Linq;
+using System.Net;
 using System.Threading;
 using Serilog;
 using Serilog.Core;
+using Serilog.Sinks.Splunk;
 
 namespace Sample
 {
     public class Program
     {
         public static void Main(string[] args)
-        { 
+        {
+            string splunkHost = "https://192.168.71.1:8088";
+            string splunkEventCollectorToken = "274AD921-FB85-429B-B09E-4EE069843218";
+         
 
             Log.Logger = new LoggerConfiguration() 
-                .WriteTo.LiterateConsole() 
+                .WriteTo.LiterateConsole()
+                .WriteTo.EventCollector (splunkHost, splunkEventCollectorToken)
                 .CreateLogger();
 
+            Serilog.Debugging.SelfLog.Out = Console.Out;
+
             Log.Information("Sample starting up");
 
             foreach (var i in Enumerable.Range(0, 1000))
@@ -23,6 +32,8 @@ public static void Main(string[] args)
                 Thread.Sleep(1000);
                 Log.Debug("Loop iteration done");
             }
+
+            Console.ReadLine();
         }
     }
 }

src/sample/project.json

@@ -16,11 +16,17 @@
   },
 
   "commands": {
-    "Sample": "Sample"
+    "Sample": "run"
   },
 
   "frameworks": {
-    "dnx451": { },
+    "dnx451": {
+      "dependencies": {
+      },
+      "frameworkAssemblies": {
+        "System.Net": "4.0.0.0"
+      }
+    },
     "dnxcore50": {
       "dependencies": {
         "Microsoft.CSharp": "4.0.1-beta-23516",

src/sample/project.lock.json

@@ -4220,7 +4220,9 @@
       "Serilog.Sinks.Literate >= 2.0.0-beta-21",
       "Serilog.Sinks.Splunk "
     ],
-    "DNX,Version=v4.5.1": [],
+    "DNX,Version=v4.5.1": [
+      "fx/System.Net >= 4.0.0"
+    ],
     "DNXCore,Version=v5.0": [
       "Microsoft.CSharp >= 4.0.1-beta-23516",
       "System.Collections >= 4.0.11-beta-23516",