WIP

Author: nblumhardt

example/Sample/Program.cs

@@ -14,7 +14,7 @@ public static void Main(string[] args)
             var sw = System.Diagnostics.Stopwatch.StartNew();
 
             Log.Logger = new LoggerConfiguration()
-                .WriteTo.File("log.txt")
+                .WriteTo.File("log.txt", fileSizeLimitBytes: 1000000, rollingInterval: RollingInterval.Day, rollOnFileSizeLimit: true)
                 .CreateLogger();
 
             for (var i = 0; i < 1000000; ++i)

example/Sample/Sample.csproj

@@ -1,25 +1,23 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>netcoreapp1.0;net45</TargetFrameworks>
+    <TargetFrameworks>netcoreapp2.0;net47</TargetFrameworks>
     <AssemblyName>Sample</AssemblyName>
     <OutputType>Exe</OutputType>
     <PackageId>Sample</PackageId>
-    <RuntimeIdentifiers>win10-x64</RuntimeIdentifiers>
+    <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
   </PropertyGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\..\src\Serilog.Sinks.File\Serilog.Sinks.File.csproj" />
   </ItemGroup>
 
-  <ItemGroup Condition=" '$(TargetFramework)' == 'net45' ">
+  <ItemGroup Condition=" '$(TargetFramework)' == 'net47' ">
     <Reference Include="System" />
     <Reference Include="Microsoft.CSharp" />
   </ItemGroup>
 
-  <ItemGroup>
-    <PackageReference Include="System.Threading" Version="4.3.0" />
-    <PackageReference Include="System.Threading.Thread" Version="4.3.0" />
+  <ItemGroup Condition=" '$(TargetFramework)' == 'netcoreapp2.0' ">
   </ItemGroup>
 
 </Project>

src/Serilog.Sinks.File/FileLoggerConfigurationExtensions.cs

@@ -14,6 +14,7 @@
 
 using System;
 using System.ComponentModel;
+using System.Text;
 using Serilog.Configuration;
 using Serilog.Core;
 using Serilog.Debugging;
@@ -30,8 +31,9 @@ namespace Serilog
     /// <summary>Extends <see cref="LoggerConfiguration"/> with methods to add file sinks.</summary>
     public static class FileLoggerConfigurationExtensions
     {
+        const int DefaultRetainedFileCountLimit = 31; // A long month of logs
         const long DefaultFileSizeLimitBytes = 1L * 1024 * 1024 * 1024;
-        const string DefaultOutputTemplate = "[{Timestamp:o} {Level:u3}] {Message:lj} {Properties}{NewLine}{Exception}";
+        const string DefaultOutputTemplate = "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] {Message:lj}{NewLine}{Exception}";
 
         /// <summary>
         /// Write log events to the specified file.
@@ -44,7 +46,7 @@ public static class FileLoggerConfigurationExtensions
         /// to be changed at runtime.</param>
         /// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
         /// <param name="outputTemplate">A message template describing the format used to write to the sink.
-        /// the default is "[{Timestamp:o} {Level:u3}] {Message:lj} {Properties}{NewLine}{Exception}".</param>
+        /// the default is "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] {Message:lj}{NewLine}{Exception}".</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>
@@ -124,7 +126,7 @@ public static LoggerConfiguration File(
         /// to be changed at runtime.</param>
         /// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
         /// <param name="outputTemplate">A message template describing the format used to write to the sink.
-        /// the default is "[{Timestamp:o} {Level:u3}] {Message:lj} {Properties}{NewLine}{Exception}".</param>
+        /// the default is "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] {Message:lj}{NewLine}{Exception}".</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>
@@ -135,6 +137,9 @@ public static LoggerConfiguration File(
         /// <param name="rollingInterval">The interval at which logging will roll over to a new file.</param>
         /// <param name="rollOnFileSizeLimit">If <code>true</code>, a new file will be created when the file size limit is reached. Filenames 
         /// will have a number appended in the format <code>_NNNNN</code>, with the first filename given no number.</param>
+        /// <param name="retainedFileCountLimit">The maximum number of log files that will be retained,
+        /// including the current log file. For unlimited retention, pass null. The default is 31.</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>
         public static LoggerConfiguration File(
@@ -149,7 +154,9 @@ public static LoggerConfiguration File(
             bool shared = false,
             TimeSpan? flushToDiskInterval = null,
             RollingInterval rollingInterval = RollingInterval.Infinite,
-            bool rollOnFileSizeLimit = false)
+            bool rollOnFileSizeLimit = false,
+            int? retainedFileCountLimit = DefaultRetainedFileCountLimit,
+            Encoding encoding = null)
         {
             if (sinkConfiguration == null) throw new ArgumentNullException(nameof(sinkConfiguration));
             if (path == null) throw new ArgumentNullException(nameof(path));
@@ -165,7 +172,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, TimeSpan?, RollingInterval, bool)"/>
+        /// overload of <see cref="File(LoggerSinkConfiguration, string, LogEventLevel, string, IFormatProvider, long?, LoggingLevelSwitch, bool, bool, TimeSpan?, RollingInterval, bool, int?, Encoding)"/>
         /// and specify the outputTemplate parameter instead.
         /// </param>
         /// <param name="path">Path to the file.</param>
@@ -183,6 +190,9 @@ public static LoggerConfiguration File(
         /// <param name="rollingInterval">The interval at which logging will roll over to a new file.</param>
         /// <param name="rollOnFileSizeLimit">If <code>true</code>, a new file will be created when the file size limit is reached. Filenames 
         /// will have a number appended in the format <code>_NNNNN</code>, with the first filename given no number.</param>
+        /// <param name="retainedFileCountLimit">The maximum number of log files that will be retained,
+        /// including the current log file. For unlimited retention, pass null. The default is 31.</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>
         public static LoggerConfiguration File(
@@ -196,9 +206,13 @@ public static LoggerConfiguration File(
             bool shared = false,
             TimeSpan? flushToDiskInterval = null,
             RollingInterval rollingInterval = RollingInterval.Infinite,
-            bool rollOnFileSizeLimit = false)
+            bool rollOnFileSizeLimit = false,
+            int? retainedFileCountLimit = DefaultRetainedFileCountLimit,
+            Encoding encoding = null)
         {
-            return ConfigureFile(sinkConfiguration.Sink, formatter, path, restrictedToMinimumLevel, fileSizeLimitBytes, levelSwitch, buffered: buffered, shared: shared, flushToDiskInterval: flushToDiskInterval, rollingInterval: rollingInterval, rollOnFileSizeLimit: rollOnFileSizeLimit);
+            return ConfigureFile(sinkConfiguration.Sink, formatter, path, restrictedToMinimumLevel, fileSizeLimitBytes, levelSwitch,
+                buffered: buffered, shared: shared, flushToDiskInterval: flushToDiskInterval, rollingInterval: rollingInterval,
+                rollOnFileSizeLimit: rollOnFileSizeLimit, retainedFileCountLimit: retainedFileCountLimit, encoding: encoding);
         }
 
         /// <summary>
@@ -212,7 +226,7 @@ public static LoggerConfiguration File(
         /// to be changed at runtime.</param>
         /// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
         /// <param name="outputTemplate">A message template describing the format used to write to the sink.
-        /// the default is "[{Timestamp:o} {Level:u3}] {Message:lj} {Properties}{NewLine}{Exception}".</param>
+        /// the default is "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] {Message:lj}{NewLine}{Exception}".</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(
@@ -268,36 +282,48 @@ static LoggerConfiguration ConfigureFile(
             bool propagateExceptions = false,
             bool shared = false,
             TimeSpan? flushToDiskInterval = null,
+            Encoding encoding = null,
             RollingInterval rollingInterval = RollingInterval.Infinite,
-            bool rollOnFileSizeLimit = false)
+            bool rollOnFileSizeLimit = false,
+            int? retainedFileCountLimit = DefaultRetainedFileCountLimit)
         {
             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");
-            if (shared && buffered)
-                throw new ArgumentException("Buffered writes are not available when file sharing is enabled.", nameof(buffered));
+            if (fileSizeLimitBytes.HasValue && fileSizeLimitBytes < 0) throw new ArgumentException("Negative value provided; file size limit must be non-negative.", nameof(fileSizeLimitBytes));
+            if (retainedFileCountLimit.HasValue && retainedFileCountLimit < 1) throw new ArgumentException("At least one file must be retained.", nameof(retainedFileCountLimit));
+            if (shared && buffered) throw new ArgumentException("Buffered writes are not available when file sharing is enabled.", nameof(buffered));
 
             ILogEventSink sink;
-            try
+
+            if (rollOnFileSizeLimit || rollingInterval != RollingInterval.Infinite)
+            {
+                sink = new RollingFileSink(path, formatter, fileSizeLimitBytes, retainedFileCountLimit, encoding, buffered, shared, rollingInterval, rollOnFileSizeLimit);
+            }
+            else
             {
-                if (shared)
+                try
                 {
-                    sink = new SharedFileSink(path, formatter, fileSizeLimitBytes);
+#pragma warning disable 618
+                    if (shared)
+                    {
+                        sink = new SharedFileSink(path, formatter, fileSizeLimitBytes);
+                    }
+                    else
+                    {
+                        sink = new FileSink(path, formatter, fileSizeLimitBytes, buffered: buffered);
+                    }
+#pragma warning restore 618
                 }
-                else
+                catch (Exception ex)
                 {
-                    sink = new FileSink(path, formatter, fileSizeLimitBytes, buffered: buffered);
-                }
-            }
-            catch (Exception ex)
-            {
-                SelfLog.WriteLine("Unable to open file sink for {0}: {1}", path, ex);
+                    SelfLog.WriteLine("Unable to open file sink for {0}: {1}", path, ex);
 
-                if (propagateExceptions)
-                    throw;
+                    if (propagateExceptions)
+                        throw;
 
-                return addSink(new NullSink(), LevelAlias.Maximum, null);
+                    return addSink(new NullSink(), LevelAlias.Maximum, null);
+                }
             }
 
             if (flushToDiskInterval.HasValue)

src/Serilog.Sinks.File/Serilog.Sinks.File.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <Description>Write Serilog events to a text file in plain or JSON format.</Description>
+    <Description>Write Serilog events to text files in plain or JSON format.</Description>
     <VersionPrefix>4.0.0</VersionPrefix>
     <Authors>Serilog Contributors</Authors>
     <TargetFrameworks>net45;netstandard1.3</TargetFrameworks>
@@ -11,25 +11,30 @@
     <SignAssembly>true</SignAssembly>
     <PublicSign Condition=" '$(OS)' != 'Windows_NT' ">true</PublicSign>
     <PackageId>Serilog.Sinks.File</PackageId>
-    <PackageTags>serilog;file;io</PackageTags>
+    <PackageTags>serilog;file</PackageTags>
     <PackageIconUrl>http://serilog.net/images/serilog-sink-nuget.png</PackageIconUrl>
     <PackageProjectUrl>http://serilog.net</PackageProjectUrl>
     <PackageLicenseUrl>http://www.apache.org/licenses/LICENSE-2.0</PackageLicenseUrl>
     <GenerateAssemblyVersionAttribute>false</GenerateAssemblyVersionAttribute>
     <RootNamespace>Serilog</RootNamespace>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <AssemblyName>Serilog.Sinks.File</AssemblyName>
+    <!-- Don't reference the full NETStandard.Library -->
+    <DisableImplicitFrameworkReferences>true</DisableImplicitFrameworkReferences>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Serilog" Version="2.3.0" />
+    <PackageReference Include="Serilog" Version="2.5.0" />
   </ItemGroup>
 
   <ItemGroup Condition=" '$(TargetFramework)' == 'net45' ">
     <Reference Include="System" />
+    <Reference Include="System.Core" />
     <Reference Include="Microsoft.CSharp" />
   </ItemGroup>
 
   <PropertyGroup Condition=" '$(TargetFramework)' == 'net45' ">
-    <DefineConstants>$(DefineConstants);ATOMIC_APPEND</DefineConstants>
+    <DefineConstants>$(DefineConstants);ATOMIC_APPEND;HRESULTS</DefineConstants>
   </PropertyGroup>
 
   <PropertyGroup Condition=" '$(TargetFramework)' == 'netstandard1.3' ">
@@ -43,6 +48,7 @@
     <PackageReference Include="System.Text.Encoding.Extensions" Version="4.0.11" />
     <PackageReference Include="System.Threading.Timer" Version="4.0.1" />
     <PackageReference Include="System.Threading" Version="4.0.11" />
+    <PackageReference Include="System.Runtime.InteropServices" Version="4.1.0" />
   </ItemGroup>
 
 </Project>

src/Serilog.Sinks.File/Sinks/File/Clock.cs

@@ -0,0 +1,38 @@
+// 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.
+
+using System;
+
+namespace Serilog.Sinks.File
+{
+    static class Clock
+    {
+        static Func<DateTime> _dateTimeNow = () => DateTime.Now;
+
+        [ThreadStatic]
+        static DateTime _testDateTimeNow;
+
+        public static DateTime DateTimeNow => _dateTimeNow();
+
+        // Time is set per thread to support parallel
+        // If any thread uses the clock in test mode, all threads
+        // must use it in test mode; once set to test mode only
+        // terminating the application returns it to normal use.
+        public static void SetTestDateTimeNow(DateTime now)
+        {
+            _testDateTimeNow = now;
+            _dateTimeNow = () => _testDateTimeNow;
+        }
+    }
+}

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

@@ -15,7 +15,6 @@
 using System;
 using System.IO;
 using System.Text;
-using Serilog.Core;
 using Serilog.Events;
 using Serilog.Formatting;
 
@@ -24,7 +23,8 @@ namespace Serilog.Sinks.File
     /// <summary>
     /// Write log events to a disk file.
     /// </summary>
-    public sealed class FileSink : ILogEventSink, IFlushableFileSink, IDisposable
+    [Obsolete("This type will be removed from the public API in a future version; use `WriteTo.File()` instead.")]
+    public sealed class FileSink : IFileSink, IDisposable
     {
         readonly TextWriter _output;
         readonly FileStream _underlyingStream;
@@ -50,7 +50,7 @@ public FileSink(string path, ITextFormatter textFormatter, long? fileSizeLimitBy
         {
             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.");
 
             _textFormatter = textFormatter;
             _fileSizeLimitBytes = fileSizeLimitBytes;
@@ -71,27 +71,34 @@ public FileSink(string path, ITextFormatter textFormatter, long? fileSizeLimitBy
             _output = new StreamWriter(outputStream, 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)
+        bool IFileSink.EmitOrOverflow(LogEvent logEvent)
         {
             if (logEvent == null) throw new ArgumentNullException(nameof(logEvent));
             lock (_syncRoot)
             {
                 if (_fileSizeLimitBytes != null)
                 {
                     if (_countingStreamWrapper.CountedLength >= _fileSizeLimitBytes.Value)
-                        return;
+                        return false;
                 }
 
                 _textFormatter.Format(logEvent, _output);
                 if (!_buffered)
                     _output.Flush();
+
+                return true;
             }
         }
 
+        /// <summary>
+        /// Emit the provided log event to the sink.
+        /// </summary>
+        /// <param name="logEvent">The log event to write.</param>
+        public void Emit(LogEvent logEvent)
+        {
+            ((IFileSink) this).EmitOrOverflow(logEvent);
+        }
+
         /// <inheritdoc />
         public void Dispose()
         {