Made PeriodicFlushToDiskSink non-generic

Author: nblumhardt

src/Serilog.Sinks.File/FileLoggerConfigurationExtensions.cs

@@ -197,28 +197,12 @@ static LoggerConfiguration ConfigureFile(
 #if ATOMIC_APPEND
                 if (shared)
                 {
-                    var sfs = new SharedFileSink(path, formatter, fileSizeLimitBytes);
-                    if (flushToDiskInterval.HasValue)
-                    {
-                        sink = new PeriodicFlushToDiskSink<SharedFileSink>(sfs, flushToDiskInterval.Value);
-                    }
-                    else
-                    {
-                        sink = sfs;
-                    }
+                    sink = new SharedFileSink(path, formatter, fileSizeLimitBytes);
                 }
                 else
                 {
 #endif
-                    var fs = new FileSink(path, formatter, fileSizeLimitBytes, buffered: buffered);
-                    if (flushToDiskInterval.HasValue)
-                    {
-                        sink = new PeriodicFlushToDiskSink<FileSink>(fs, flushToDiskInterval.Value);
-                    }
-                    else
-                    {
-                        sink = fs;
-                    }
+                    sink = new FileSink(path, formatter, fileSizeLimitBytes, buffered: buffered);
 #if ATOMIC_APPEND
                 }
 #endif
@@ -233,6 +217,10 @@ static LoggerConfiguration ConfigureFile(
                 return addSink(new NullSink(), LevelAlias.Maximum, null);
             }
 
+            if (flushToDiskInterval.HasValue)
+            {
+                sink = new PeriodicFlushToDiskSink(sink, flushToDiskInterval.Value);
+            }
 
             return addSink(sink, restrictedToMinimumLevel, levelSwitch);
         }

src/Serilog.Sinks.File/Sinks/File/PeriodicFlushToDiskSink`1.cs renamed to src/Serilog.Sinks.File/Sinks/File/PeriodicFlushToDiskSink.cs

@@ -9,27 +9,35 @@ namespace Serilog.Sinks.File
     /// <summary>
     /// A sink wrapper that periodically flushes the wrapped sink to disk.
     /// </summary>
-    /// <typeparam name="TSink">The type of the wrapped sink.</typeparam>
-    public class PeriodicFlushToDiskSink<TSink> : ILogEventSink, IDisposable
-        where TSink : ILogEventSink, IFlushableFileSink
+    public class PeriodicFlushToDiskSink : ILogEventSink, IDisposable
     {
-        readonly TSink _sink;
+        readonly ILogEventSink _sink;
         readonly Timer _timer;
         int _flushRequired;
 
         /// <summary>
-        /// Construct a <see cref="PeriodicFlushToDiskSink{TSink}"/> that wraps
+        /// Construct a <see cref="PeriodicFlushToDiskSink"/> that wraps
         /// <paramref name="sink"/> and flushes it at the specified <paramref name="flushInterval"/>.
         /// </summary>
         /// <param name="sink">The sink to wrap.</param>
         /// <param name="flushInterval">The interval at which to flush the underlying sink.</param>
         /// <exception cref="ArgumentNullException"></exception>
-        public PeriodicFlushToDiskSink(TSink sink, TimeSpan flushInterval)
+        public PeriodicFlushToDiskSink(ILogEventSink sink, TimeSpan flushInterval)
         {
             if (sink == null) throw new ArgumentNullException(nameof(sink));
 
             _sink = sink;
-            _timer = new Timer(_ => FlushToDisk(), null, flushInterval, flushInterval);
+
+            var flushable = sink as IFlushableFileSink;
+            if (flushable != null)
+            {
+                _timer = new Timer(_ => FlushToDisk(flushable), null, flushInterval, flushInterval);
+            }
+            else
+            {
+                _timer = new Timer(_ => { }, null, Timeout.InfiniteTimeSpan, Timeout.InfiniteTimeSpan);
+                SelfLog.WriteLine("{0} configured to flush {1}, but {2} not implemented", typeof(PeriodicFlushToDiskSink), sink, nameof(IFlushableFileSink));
+            }
         }
 
         /// <inheritdoc />
@@ -46,20 +54,20 @@ public void Dispose()
             (_sink as IDisposable)?.Dispose();
         }
 
-        void FlushToDisk()
+        void FlushToDisk(IFlushableFileSink flushable)
         {
             try
             {
                 if (Interlocked.CompareExchange(ref _flushRequired, 0, 1) == 1)
                 {
                     // May throw ObjectDisposedException, since we're not trying to synchronize
                     // anything here in the wrapper.
-                    _sink.FlushToDisk();
+                    flushable.FlushToDisk();
                 }
             }
             catch (Exception ex)
             {
-                SelfLog.WriteLine("Could not flush the underlying sink to disk: {0}", ex);
+                SelfLog.WriteLine("{0} could not flush the underlying sink to disk: {1}", typeof(PeriodicFlushToDiskSink), ex);
             }
         }
     }