Fixes serilog#18 - flush to disk option; re-enables (and fixes) shared file sink tests.

Author: nblumhardt

src/Serilog.Sinks.File/FileLoggerConfigurationExtensions.cs

@@ -48,6 +48,7 @@ public static class FileLoggerConfigurationExtensions
         /// <param name="buffered">Indicates if flushing to the output file can be buffered or not. The default
         /// is false.</param>
         /// <param name="shared">Allow the log file to be shared by multiple processes. The default is false.</param>
+        /// <param name="flushToDiskInterval">If provided, a full disk flush will be performed periodically at the specified interval.</param>
         /// <returns>Configuration object allowing method chaining.</returns>
         /// <remarks>The file will be written using the UTF-8 character set.</remarks>
         public static LoggerConfiguration File(
@@ -59,14 +60,15 @@ public static LoggerConfiguration File(
             long? fileSizeLimitBytes = DefaultFileSizeLimitBytes,
             LoggingLevelSwitch levelSwitch = null,
             bool buffered = false,
-            bool shared = false)
+            bool shared = false,
+            TimeSpan? flushToDiskInterval = null)
         {
             if (sinkConfiguration == null) throw new ArgumentNullException(nameof(sinkConfiguration));
             if (path == null) throw new ArgumentNullException(nameof(path));
             if (outputTemplate == null) throw new ArgumentNullException(nameof(outputTemplate));
 
             var formatter = new MessageTemplateTextFormatter(outputTemplate, formatProvider);
-            return File(sinkConfiguration, formatter, path, restrictedToMinimumLevel, fileSizeLimitBytes, levelSwitch, buffered: buffered, shared: shared);
+            return File(sinkConfiguration, formatter, path, restrictedToMinimumLevel, fileSizeLimitBytes, levelSwitch, buffered: buffered, shared: shared, flushToDiskInterval: flushToDiskInterval);
         }
 
         /// <summary>
@@ -75,7 +77,7 @@ public static LoggerConfiguration File(
         /// <param name="sinkConfiguration">Logger sink configuration.</param>
         /// <param name="formatter">A formatter, such as <see cref="JsonFormatter"/>, to convert the log events into
         /// text for the file. If control of regular text formatting is required, use the other
-        /// overload of <see cref="File(LoggerSinkConfiguration, string, LogEventLevel, string, IFormatProvider, long?, LoggingLevelSwitch, bool, bool)"/>
+        /// overload of <see cref="File(LoggerSinkConfiguration, string, LogEventLevel, string, IFormatProvider, long?, LoggingLevelSwitch, bool, bool, TimeSpan?)"/>
         /// and specify the outputTemplate parameter instead.
         /// </param>
         /// <param name="path">Path to the file.</param>
@@ -89,6 +91,7 @@ public static LoggerConfiguration File(
         /// <param name="buffered">Indicates if flushing to the output file can be buffered or not. The default
         /// is false.</param>
         /// <param name="shared">Allow the log file to be shared by multiple processes. The default is false.</param>
+        /// <param name="flushToDiskInterval">If provided, a full disk flush will be performed periodically at the specified interval.</param>
         /// <returns>Configuration object allowing method chaining.</returns>
         /// <remarks>The file will be written using the UTF-8 character set.</remarks>
         public static LoggerConfiguration File(
@@ -99,9 +102,10 @@ public static LoggerConfiguration File(
             long? fileSizeLimitBytes = DefaultFileSizeLimitBytes,
             LoggingLevelSwitch levelSwitch = null,
             bool buffered = false,
-            bool shared = false)
+            bool shared = false,
+            TimeSpan? flushToDiskInterval = null)
         {
-            return ConfigureFile(sinkConfiguration.Sink, formatter, path, restrictedToMinimumLevel, fileSizeLimitBytes, levelSwitch, buffered: buffered, shared: shared);
+            return ConfigureFile(sinkConfiguration.Sink, formatter, path, restrictedToMinimumLevel, fileSizeLimitBytes, levelSwitch, buffered: buffered, shared: shared, flushToDiskInterval: flushToDiskInterval);
         }
 
         /// <summary>
@@ -169,7 +173,8 @@ static LoggerConfiguration ConfigureFile(
             LoggingLevelSwitch levelSwitch = null,
             bool buffered = false,
             bool propagateExceptions = false,
-            bool shared = false)
+            bool shared = false,
+            TimeSpan? flushToDiskInterval = null)
         {
             if (addSink == null) throw new ArgumentNullException(nameof(addSink));
             if (formatter == null) throw new ArgumentNullException(nameof(formatter));
@@ -192,12 +197,28 @@ static LoggerConfiguration ConfigureFile(
 #if ATOMIC_APPEND
                 if (shared)
                 {
-                    sink = new SharedFileSink(path, formatter, fileSizeLimitBytes);
+                    var sfs = new SharedFileSink(path, formatter, fileSizeLimitBytes);
+                    if (flushToDiskInterval.HasValue)
+                    {
+                        sink = new PeriodicFlushToDiskSink<SharedFileSink>(sfs, flushToDiskInterval.Value);
+                    }
+                    else
+                    {
+                        sink = sfs;
+                    }
                 }
                 else
                 {
 #endif
-                    sink = new FileSink(path, formatter, fileSizeLimitBytes, buffered: buffered);
+                    var fs = new FileSink(path, formatter, fileSizeLimitBytes, buffered: buffered);
+                    if (flushToDiskInterval.HasValue)
+                    {
+                        sink = new PeriodicFlushToDiskSink<FileSink>(fs, flushToDiskInterval.Value);
+                    }
+                    else
+                    {
+                        sink = fs;
+                    }
 #if ATOMIC_APPEND
                 }
 #endif
@@ -212,6 +233,7 @@ static LoggerConfiguration ConfigureFile(
                 return addSink(new NullSink(), LevelAlias.Maximum, null);
             }
 
+
             return addSink(sink, restrictedToMinimumLevel, levelSwitch);
         }
     }  

src/Serilog.Sinks.File/Sinks/File/FileSink.cs

@@ -24,9 +24,10 @@ namespace Serilog.Sinks.File
     /// <summary>
     /// Write log events to a disk file.
     /// </summary>
-    public sealed class FileSink : ILogEventSink, IDisposable
+    public sealed class FileSink : ILogEventSink, IFlushableFileSink, IDisposable
     {
         readonly TextWriter _output;
+        readonly FileStream _underlyingStream;
         readonly ITextFormatter _textFormatter;
         readonly long? _fileSizeLimitBytes;
         readonly bool _buffered;
@@ -61,13 +62,13 @@ public FileSink(string path, ITextFormatter textFormatter, long? fileSizeLimitBy
                 Directory.CreateDirectory(directory);
             }
 
-            Stream file = System.IO.File.Open(path, FileMode.Append, FileAccess.Write, FileShare.Read);
+            Stream outputStream = _underlyingStream = System.IO.File.Open(path, FileMode.Append, FileAccess.Write, FileShare.Read);
             if (_fileSizeLimitBytes != null)
             {
-                file = _countingStreamWrapper = new WriteCountingStream(file);
+                outputStream = _countingStreamWrapper = new WriteCountingStream(_underlyingStream);
             }
 
-            _output = new StreamWriter(file, encoding ?? new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
+            _output = new StreamWriter(outputStream, encoding ?? new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
         }
 
         /// <summary>
@@ -91,10 +92,17 @@ public void Emit(LogEvent logEvent)
             }
         }
 
-        /// <summary>
-        /// Performs application-defined tasks associated with freeing, releasing, or
-        /// resetting unmanaged resources.
-        /// </summary>
+        /// <inheritdoc />
         public void Dispose() => _output.Dispose();
+
+        /// <inheritdoc />
+        public void FlushToDisk()
+        {
+            lock (_syncRoot)
+            {
+                _output.Flush();
+                _underlyingStream.Flush(true);
+            }
+        }
     }
 }

src/Serilog.Sinks.File/Sinks/File/IFlushableFileSink.cs

@@ -0,0 +1,13 @@
+namespace Serilog.Sinks.File
+{
+    /// <summary>
+    /// Supported by (file-based) sinks that can be explicitly flushed.
+    /// </summary>
+    public interface IFlushableFileSink
+    {
+        /// <summary>
+        /// Flush buffered contents to disk.
+        /// </summary>
+        void FlushToDisk();
+    }
+}

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

@@ -0,0 +1,66 @@
+using System;
+using System.Threading;
+using Serilog.Core;
+using Serilog.Debugging;
+using Serilog.Events;
+
+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
+    {
+        readonly TSink _sink;
+        readonly Timer _timer;
+        int _flushRequired;
+
+        /// <summary>
+        /// Construct a <see cref="PeriodicFlushToDiskSink{TSink}"/> 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)
+        {
+            if (sink == null) throw new ArgumentNullException(nameof(sink));
+
+            _sink = sink;
+            _timer = new Timer(_ => FlushToDisk(), null, flushInterval, flushInterval);
+        }
+
+        /// <inheritdoc />
+        public void Emit(LogEvent logEvent)
+        {
+            _sink.Emit(logEvent);
+            Interlocked.Exchange(ref _flushRequired, 1);
+        }
+
+        /// <inheritdoc />
+        public void Dispose()
+        {
+            _timer.Dispose();
+            (_sink as IDisposable)?.Dispose();
+        }
+
+        void FlushToDisk()
+        {
+            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();
+                }
+            }
+            catch (Exception ex)
+            {
+                SelfLog.WriteLine("Could not flush the underlying sink to disk: {0}", ex);
+            }
+        }
+    }
+}

src/Serilog.Sinks.File/Sinks/File/SharedFileSink.cs

@@ -27,15 +27,14 @@ namespace Serilog.Sinks.File
     /// <summary>
     /// Write log events to a disk file.
     /// </summary>
-    public sealed class SharedFileSink : ILogEventSink, IDisposable
+    public sealed class SharedFileSink : ILogEventSink, IFlushableFileSink, IDisposable
     {
         readonly MemoryStream _writeBuffer;
         readonly string _path;
         readonly TextWriter _output;
         readonly ITextFormatter _textFormatter;
         readonly long? _fileSizeLimitBytes;
         readonly object _syncRoot = new object();
-        readonly FileInfo _fileInfo;
 
         // The stream is reopened with a larger buffer if atomic writes beyond the current buffer size are needed.
         FileStream _fileOutput;
@@ -53,11 +52,13 @@ public sealed class SharedFileSink : ILogEventSink, IDisposable
         /// <returns>Configuration object allowing method chaining.</returns>
         /// <remarks>The file will be written using the UTF-8 character set.</remarks>
         /// <exception cref="IOException"></exception>
-        public SharedFileSink(string path, ITextFormatter textFormatter, long? fileSizeLimitBytes, Encoding encoding = null)
+        public SharedFileSink(string path, ITextFormatter textFormatter, long? fileSizeLimitBytes,
+            Encoding encoding = null)
         {
             if (path == null) throw new ArgumentNullException(nameof(path));
             if (textFormatter == null) throw new ArgumentNullException(nameof(textFormatter));
-            if (fileSizeLimitBytes.HasValue && fileSizeLimitBytes < 0) throw new ArgumentException("Negative value provided; file size limit must be non-negative");
+            if (fileSizeLimitBytes.HasValue && fileSizeLimitBytes < 0)
+                throw new ArgumentException("Negative value provided; file size limit must be non-negative");
 
             _path = path;
             _textFormatter = textFormatter;
@@ -72,20 +73,16 @@ public SharedFileSink(string path, ITextFormatter textFormatter, long? fileSizeL
             // FileSystemRights.AppendData sets the Win32 FILE_APPEND_DATA flag. On Linux this is O_APPEND, but that API is not yet
             // exposed by .NET Core.
             _fileOutput = new FileStream(
-                path, 
+                path,
                 FileMode.Append,
                 FileSystemRights.AppendData,
                 FileShare.ReadWrite,
                 _fileStreamBufferLength,
                 FileOptions.None);
 
-            if (_fileSizeLimitBytes != null)
-            {
-                _fileInfo = new FileInfo(path);
-            }
-
             _writeBuffer = new MemoryStream();
-            _output = new StreamWriter(_writeBuffer, encoding ?? new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
+            _output = new StreamWriter(_writeBuffer,
+                encoding ?? new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
         }
 
         /// <summary>
@@ -96,20 +93,14 @@ public void Emit(LogEvent logEvent)
         {
             if (logEvent == null) throw new ArgumentNullException(nameof(logEvent));
 
-            if (_fileSizeLimitBytes != null)
-            {
-                if (_fileInfo.Length >= _fileSizeLimitBytes.Value)
-                    return;
-            }
-
             lock (_syncRoot)
             {
                 try
                 {
                     _textFormatter.Format(logEvent, _output);
                     _output.Flush();
                     var bytes = _writeBuffer.GetBuffer();
-                    var length = (int)_writeBuffer.Length;
+                    var length = (int) _writeBuffer.Length;
                     if (length > _fileStreamBufferLength)
                     {
                         var oldOutput = _fileOutput;
@@ -126,6 +117,16 @@ public void Emit(LogEvent logEvent)
                         oldOutput.Dispose();
                     }
 
+                    if (_fileSizeLimitBytes != null)
+                    {
+                        try
+                        {
+                            if (_fileOutput.Length >= _fileSizeLimitBytes.Value)
+                                return;
+                        }
+                        catch (FileNotFoundException) { } // Cheaper and more reliable than checking existence
+                    }
+
                     _fileOutput.Write(bytes, 0, length);
                     _fileOutput.Flush();
                 }
@@ -143,11 +144,19 @@ public void Emit(LogEvent logEvent)
             }
         }
 
-        /// <summary>
-        /// Performs application-defined tasks associated with freeing, releasing, or
-        /// resetting unmanaged resources.
-        /// </summary>
+
+        /// <inheritdoc />
         public void Dispose() => _fileOutput.Dispose();
+
+        /// <inheritdoc />
+        public void FlushToDisk()
+        {
+            lock (_syncRoot)
+            {
+                _output.Flush();
+                _fileOutput.Flush(true);
+            }
+        }
     }
 }
 

src/Serilog.Sinks.File/Sinks/File/WriteCountingStream.cs

@@ -51,6 +51,7 @@ public override void Write(byte[] buffer, int offset, int count)
         public override bool CanWrite => true;
         public override long Length => _stream.Length;
 
+
         public override long Position
         {
             get { return _stream.Position; }

src/Serilog.Sinks.File/project.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.0.2-*",
+  "version": "3.1.0-*",
   "description": "Write Serilog events to a text file in plain or JSON format.",
   "authors": [ "Serilog Contributors" ],
   "packOptions": {
@@ -24,7 +24,8 @@
         "System.IO": "4.1.0",
         "System.IO.FileSystem": "4.0.1",
         "System.IO.FileSystem.Primitives": "4.0.1",
-        "System.Text.Encoding.Extensions": "4.0.11"
+        "System.Text.Encoding.Extensions": "4.0.11",
+        "System.Threading.Timer": "4.0.1" 
       }
     }
   }