Multiprocess sharing on .NET Core

.gitignore

@@ -234,3 +234,4 @@ _Pvt_Extensions
 
 # FAKE - F# Make
 .fake/
+example/Sample/log.txt

example/Sample/Program.cs

@@ -11,12 +11,12 @@ public static void Main(string[] args)
         {
             SelfLog.Enable(Console.Out);
 
+            var sw = System.Diagnostics.Stopwatch.StartNew();
+
             Log.Logger = new LoggerConfiguration()
                 .WriteTo.File("log.txt")
                 .CreateLogger();
 
-            var sw = System.Diagnostics.Stopwatch.StartNew();
-
             for (var i = 0; i < 1000000; ++i)
             {
                 Log.Information("Hello, file logger!");

src/Serilog.Sinks.File/FileLoggerConfigurationExtensions.cs

@@ -180,32 +180,20 @@ static LoggerConfiguration ConfigureFile(
             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");
-
-            if (shared)
-            {
-#if ATOMIC_APPEND
-                if (buffered)
-                    throw new ArgumentException("Buffered writes are not available when file sharing is enabled.", nameof(buffered));
-#else
-                throw new NotSupportedException("File sharing is not supported on this platform.");
-#endif
-            }
+            if (shared && buffered)
+                throw new ArgumentException("Buffered writes are not available when file sharing is enabled.", nameof(buffered));
 
             ILogEventSink sink;
             try
             {
-#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)
             {

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

@@ -52,8 +52,7 @@ public sealed class SharedFileSink : ILogEventSink, IFlushableFileSink, IDisposa
         /// <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));

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

@@ -0,0 +1,162 @@
+// 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 OS_MUTEX
+
+using System;
+using System.IO;
+using System.Text;
+using Serilog.Core;
+using Serilog.Events;
+using Serilog.Formatting;
+using System.Threading;
+using Serilog.Debugging;
+
+namespace Serilog.Sinks.File
+{
+    /// <summary>
+    /// Write log events to a disk file.
+    /// </summary>
+    public sealed class SharedFileSink : ILogEventSink, IFlushableFileSink, IDisposable
+    {
+        readonly TextWriter _output;
+        readonly FileStream _underlyingStream;
+        readonly ITextFormatter _textFormatter;
+        readonly long? _fileSizeLimitBytes;
+        readonly object _syncRoot = new object();
+
+        const string MutexNameSuffix = ".serilog";
+        const int MutexWaitTimeout = 10000;
+        readonly Mutex _mutex;
+
+        /// <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");
+
+            _textFormatter = textFormatter;
+            _fileSizeLimitBytes = fileSizeLimitBytes;
+
+            var directory = Path.GetDirectoryName(path);
+            if (!string.IsNullOrWhiteSpace(directory) && !Directory.Exists(directory))
+            {
+                Directory.CreateDirectory(directory);
+            }
+
+            var mutexName = Path.GetFullPath(path).Replace(Path.DirectorySeparatorChar, ':') + MutexNameSuffix;
+            _mutex = new Mutex(false, mutexName);
+            _underlyingStream = System.IO.File.Open(path, FileMode.Append, FileAccess.Write, FileShare.ReadWrite);
+            _output = new StreamWriter(_underlyingStream, 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));
+
+            lock (_syncRoot)
+            {
+                if (!TryAcquireMutex())
+                    return;
+
+                try
+                {
+                    _underlyingStream.Seek(0, SeekOrigin.End);
+                    if (_fileSizeLimitBytes != null)
+                    {
+                        if (_underlyingStream.Length >= _fileSizeLimitBytes.Value)
+                            return;
+                    }
+
+                    _textFormatter.Format(logEvent, _output);
+                    _output.Flush();
+                    _underlyingStream.Flush();
+                }
+                finally
+                {
+                    ReleaseMutex();
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        public void Dispose()
+        {
+            lock (_syncRoot)
+            {
+                _output.Dispose();
+                _mutex.Dispose();
+            }
+        }
+
+        /// <inheritdoc />
+        public void FlushToDisk()
+        {
+            lock (_syncRoot)
+            {
+                if (!TryAcquireMutex())
+                    return;
+
+                try
+                {
+                    _underlyingStream.Flush(true);
+                }
+                finally
+                {
+                    ReleaseMutex();
+                }
+            }
+        }
+
+        bool TryAcquireMutex()
+        {
+            try
+            {
+                if (!_mutex.WaitOne(MutexWaitTimeout))
+                {
+                    SelfLog.WriteLine("Shared file mutex could not be acquired within {0} ms", MutexWaitTimeout);
+                    return false;
+                }
+            }
+            catch (AbandonedMutexException)
+            {
+                SelfLog.WriteLine("Inherited shared file mutex after abandonment by another process");
+            }
+
+            return true;
+        }
+
+        void ReleaseMutex()
+        {
+            _mutex.ReleaseMutex();
+        }
+    }
+}
+
+#endif

src/Serilog.Sinks.File/project.json

@@ -20,12 +20,14 @@
       "buildOptions": { "define": [ "ATOMIC_APPEND" ] }
     },
     "netstandard1.3": {
+      "buildOptions": { "define": [ "OS_MUTEX" ] },
       "dependencies": {
         "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.Threading.Timer": "4.0.1" 
+        "System.Threading.Timer": "4.0.1",
+        "System.Threading": "4.0.11"
       }
     }
   }

test/Serilog.Sinks.File.Tests/SharedFileSinkTests.cs

@@ -1,6 +1,4 @@
-#if ATOMIC_APPEND
-
-using System.IO;
+using System.IO;
 using Xunit;
 using Serilog.Formatting.Json;
 using Serilog.Sinks.File.Tests.Support;
@@ -102,5 +100,3 @@ public void WhenLimitIsNotSpecifiedFileSizeIsNotRestricted()
         }
     }
 }
-
-#endif

test/Serilog.Sinks.File.Tests/project.json

@@ -19,9 +19,6 @@
       ]
     },
     "net4.5.2": {
-      "buildOptions": {
-        "define": ["ATOMIC_APPEND"]
-      }
     }
   }
 }