Merge pull request #14 from nblumhardt/f-multiprocess

nblumhardt · web-flow · commit ed7cee7063f5 · 2016-08-19T18:59:43.000+10:00
Multi-process shared files
diff --git a/example/Sample/Program.cs b/example/Sample/Program.cs
@@ -1,13 +1,16 @@
 ﻿using System;
 using System.IO;
 using Serilog;
+using Serilog.Debugging;
 
 namespace Sample
 {
     public class Program
     {
         public static void Main(string[] args)
         {
+            SelfLog.Enable(Console.Out);
+
             Log.Logger = new LoggerConfiguration()
                 .WriteTo.File("log.txt")
                 .CreateLogger();
@@ -24,6 +27,10 @@ public static void Main(string[] args)
             sw.Stop();
 
             Console.WriteLine($"Elapsed: {sw.ElapsedMilliseconds} ms");
+            Console.WriteLine($"Size: {new FileInfo("log.txt").Length}");
+
+            Console.WriteLine("Press any key to delete the temporary log file...");
+            Console.ReadKey(true);
 
             File.Delete("log.txt");
         }
diff --git a/example/Sample/Properties/AssemblyInfo.cs b/example/Sample/Properties/AssemblyInfo.cs
diff --git a/example/Sample/project.json b/example/Sample/project.json
@@ -1,20 +1,23 @@
 ﻿{
-  "version": "1.0.0-*",
   "buildOptions": {
     "emitEntryPoint": true
   },
 
   "dependencies": {
-    "Serilog.Sinks.File": { "target": "project" },
-    "Microsoft.NETCore.App": {
-      "type": "platform",
-      "version": "1.0.0"
-    }
+    "Serilog.Sinks.File": { "target": "project" }
   },
 
   "frameworks": {
     "netcoreapp1.0": {
-      "imports": "dnxcore50"
-    }
-  }
+      "imports": "dnxcore50",
+      "dependencies": {
+        "Microsoft.NETCore.App": {
+          "type": "platform",
+          "version": "1.0.0"
+        }
+      }
+    },
+    "net4.5": {}
+  },
+  "runtimes": { "win10-x64": {} }
 }
diff --git a/src/Serilog.Sinks.File/FileLoggerConfigurationExtensions.cs b/src/Serilog.Sinks.File/FileLoggerConfigurationExtensions.cs
@@ -47,6 +47,7 @@ public static class FileLoggerConfigurationExtensions
         /// will be written in full even if it exceeds the limit.</param>
         /// <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>
         /// <returns>Configuration object allowing method chaining.</returns>
         /// <remarks>The file will be written using the UTF-8 character set.</remarks>
         public static LoggerConfiguration File(
@@ -57,14 +58,15 @@ public static LoggerConfiguration File(
             IFormatProvider formatProvider = null,
             long? fileSizeLimitBytes = DefaultFileSizeLimitBytes,
             LoggingLevelSwitch levelSwitch = null,
-            bool buffered = false)
+            bool buffered = false,
+            bool shared = false)
         {
             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);
+            return File(sinkConfiguration, formatter, path, restrictedToMinimumLevel, fileSizeLimitBytes, levelSwitch, buffered: buffered, shared: shared);
         }
 
         /// <summary>
@@ -73,7 +75,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)"/>
+        /// overload of <see cref="File(LoggerSinkConfiguration, string, LogEventLevel, string, IFormatProvider, long?, LoggingLevelSwitch, bool, bool)"/>
         /// and specify the outputTemplate parameter instead.
         /// </param>
         /// <param name="path">Path to the file.</param>
@@ -86,6 +88,7 @@ public static LoggerConfiguration File(
         /// will be written in full even if it exceeds the limit.</param>
         /// <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>
         /// <returns>Configuration object allowing method chaining.</returns>
         /// <remarks>The file will be written using the UTF-8 character set.</remarks>
         public static LoggerConfiguration File(
@@ -95,9 +98,10 @@ public static LoggerConfiguration File(
             LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
             long? fileSizeLimitBytes = DefaultFileSizeLimitBytes,
             LoggingLevelSwitch levelSwitch = null,
-            bool buffered = false)
+            bool buffered = false,
+            bool shared = false)
         {
-            return ConfigureFile(sinkConfiguration.Sink, formatter, path, restrictedToMinimumLevel, fileSizeLimitBytes, levelSwitch, buffered);
+            return ConfigureFile(sinkConfiguration.Sink, formatter, path, restrictedToMinimumLevel, fileSizeLimitBytes, levelSwitch, buffered: buffered, shared: shared);
         }
 
         /// <summary>
@@ -136,7 +140,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)"/>
+        /// overload of <see cref="File(LoggerAuditSinkConfiguration, string, LogEventLevel, string, IFormatProvider, LoggingLevelSwitch)"/>
         /// and specify the outputTemplate parameter instead.
         /// </param>
         /// <param name="path">Path to the file.</param>
@@ -164,17 +168,39 @@ static LoggerConfiguration ConfigureFile(
             long? fileSizeLimitBytes = DefaultFileSizeLimitBytes,
             LoggingLevelSwitch levelSwitch = null,
             bool buffered = false,
-            bool propagateExceptions = false)
+            bool propagateExceptions = false,
+            bool shared = false)
         {
             if (addSink == null) throw new ArgumentNullException(nameof(addSink));
             if (formatter == null) throw new ArgumentNullException(nameof(formatter));
             if (path == null) throw new ArgumentNullException(nameof(path));
             if (fileSizeLimitBytes.HasValue && fileSizeLimitBytes < 0) throw new ArgumentException("Negative value provided; file size limit must be non-negative");
 
-            FileSink sink;
+            if (shared)
+            {
+#if !ATOMIC_APPEND
+                throw new NotSupportedException("File sharing is not supported on this platform.");
+#endif
+
+                if (buffered)
+                    throw new ArgumentException("Buffered writes are not available when file sharing is enabled.", nameof(buffered));
+            }
+
+            ILogEventSink sink;
             try
             {
-                sink = new FileSink(path, formatter, fileSizeLimitBytes, buffered: buffered);
+#if ATOMIC_APPEND
+                if (shared)
+                {
+                    sink = new SharedFileSink(path, formatter, fileSizeLimitBytes);
+                }
+                else
+                {
+#endif
+                    sink = new FileSink(path, formatter, fileSizeLimitBytes, buffered: buffered);
+#if ATOMIC_APPEND
+                }
+#endif
             }
             catch (Exception ex)
             {
diff --git a/src/Serilog.Sinks.File/Sinks/File/FileSink.cs b/src/Serilog.Sinks.File/Sinks/File/FileSink.cs
@@ -14,6 +14,9 @@
 
 using System;
 using System.IO;
+#if ATOMIC_APPEND
+using System.Security.AccessControl;
+#endif
 using System.Text;
 using Serilog.Core;
 using Serilog.Events;
@@ -61,7 +64,13 @@ public FileSink(string path, ITextFormatter textFormatter, long? fileSizeLimitBy
                 Directory.CreateDirectory(directory);
             }
 
+#if ATOMIC_APPEND
+            // FileSystemRights.AppendData improves performance substantially (~30%) when available.
+            Stream file = new FileStream(path, FileMode.Append, FileSystemRights.AppendData, FileShare.Read, 4096, FileOptions.None);
+#else
             Stream file = System.IO.File.Open(path, FileMode.Append, FileAccess.Write, FileShare.Read);
+#endif
+
             if (_fileSizeLimitBytes != null)
             {
                 file = _countingStreamWrapper = new WriteCountingStream(file);
diff --git a/src/Serilog.Sinks.File/Sinks/File/SharedFileSink.cs b/src/Serilog.Sinks.File/Sinks/File/SharedFileSink.cs
@@ -0,0 +1,154 @@
+﻿// Copyright 2013-2016 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 ATOMIC_APPEND
+
+using System;
+using System.IO;
+using System.Security.AccessControl;
+using System.Text;
+using Serilog.Core;
+using Serilog.Events;
+using Serilog.Formatting;
+
+namespace Serilog.Sinks.File
+{
+    /// <summary>
+    /// Write log events to a disk file.
+    /// </summary>
+    public sealed class SharedFileSink : ILogEventSink, 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;
+        int _fileStreamBufferLength = DefaultFileStreamBufferLength;
+
+        const int DefaultFileStreamBufferLength = 4096;
+
+        /// <summary>Construct a <see cref="FileSink"/>.</summary>
+        /// <param name="path">Path to the file.</param>
+        /// <param name="textFormatter">Formatter used to convert log events to text.</param>
+        /// <param name="fileSizeLimitBytes">The approximate maximum size, in bytes, to which a log file will be allowed to grow.
+        /// For unrestricted growth, pass null. The default is 1 GB. To avoid writing partial events, the last event within the limit
+        /// will be written in full even if it exceeds the limit.</param>
+        /// <param name="encoding">Character encoding used to write the text file. The default is UTF-8 without BOM.</param>
+        /// <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)
+        {
+            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");
+
+            _path = path;
+            _textFormatter = textFormatter;
+            _fileSizeLimitBytes = fileSizeLimitBytes;
+
+            var directory = Path.GetDirectoryName(path);
+            if (!string.IsNullOrWhiteSpace(directory) && !Directory.Exists(directory))
+            {
+                Directory.CreateDirectory(directory);
+            }
+
+            // 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, 
+                FileMode.Append,
+                FileSystemRights.AppendData,
+                FileShare.Write,
+                _fileStreamBufferLength,
+                FileOptions.None);
+
+            if (_fileSizeLimitBytes != null)
+            {
+                _fileInfo = new FileInfo(path);
+            }
+
+            _writeBuffer = new MemoryStream();
+            _output = new StreamWriter(_writeBuffer, encoding ?? new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
+        }
+
+        /// <summary>
+        /// Emit the provided log event to the sink.
+        /// </summary>
+        /// <param name="logEvent">The log event to write.</param>
+        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;
+                    if (length > _fileStreamBufferLength)
+                    {
+                        var oldOutput = _fileOutput;
+
+                        _fileOutput = new FileStream(
+                            _path,
+                            FileMode.Append,
+                            FileSystemRights.AppendData,
+                            FileShare.Write,
+                            length,
+                            FileOptions.None);
+                        _fileStreamBufferLength = length;
+
+                        oldOutput.Dispose();
+                    }
+
+                    _fileOutput.Write(bytes, 0, length);
+                    _fileOutput.Flush();
+                }
+                catch
+                {
+                    // Make sure there's no leftover cruft in there.
+                    _output.Flush();
+                    throw;
+                }
+                finally
+                {
+                    _writeBuffer.Position = 0;
+                    _writeBuffer.SetLength(0);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Performs application-defined tasks associated with freeing, releasing, or
+        /// resetting unmanaged resources.
+        /// </summary>
+        public void Dispose() => _fileOutput.Dispose();
+    }
+}
+
+#endif
diff --git a/src/Serilog.Sinks.File/project.json b/src/Serilog.Sinks.File/project.json
@@ -1,5 +1,5 @@
 ﻿{
-  "version": "2.3.0-*",
+  "version": "3.0.0-*",
   "description": "Write Serilog events to a text file in plain or JSON format.",
   "authors": [ "Serilog Contributors" ],
   "packOptions": {
@@ -16,7 +16,9 @@
     "xmlDoc": true
   },
   "frameworks": {
-    "net4.5": {},
+    "net4.5": {
+      "buildOptions": { "define": [ "ATOMIC_APPEND" ] }
+    },
     "netstandard1.3": {
       "dependencies": {
         "System.IO": "4.1.0",
diff --git a/test/Serilog.Sinks.File.Tests/SharedFileSinkTests.cs b/test/Serilog.Sinks.File.Tests/SharedFileSinkTests.cs

Original file line number	Diff line number	Diff line change
`@@ -1,13 +1,16 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.IO;`
`3`	`3`	`using Serilog;`
	`4`	`+using Serilog.Debugging;`
`4`	`5`
`5`	`6`	`namespace Sample`
`6`	`7`	`{`
`7`	`8`	`public class Program`
`8`	`9`	`{`
`9`	`10`	`public static void Main(string[] args)`
`10`	`11`	`{`
	`12`	`+ SelfLog.Enable(Console.Out);`
	`13`	`+`
`11`	`14`	`Log.Logger = new LoggerConfiguration()`
`12`	`15`	`.WriteTo.File("log.txt")`
`13`	`16`	`.CreateLogger();`
`@@ -24,6 +27,10 @@ public static void Main(string[] args)`
`24`	`27`	`sw.Stop();`
`25`	`28`
`26`	`29`	`Console.WriteLine($"Elapsed: {sw.ElapsedMilliseconds} ms");`
	`30`	`+ Console.WriteLine($"Size: {new FileInfo("log.txt").Length}");`
	`31`	`+`
	`32`	`+ Console.WriteLine("Press any key to delete the temporary log file...");`
	`33`	`+ Console.ReadKey(true);`
`27`	`34`
`28`	`35`	`File.Delete("log.txt");`
`29`	`36`	`}`