Rename StreamWrapper to FileLifecycleHooks

Author: cocowalla

src/Serilog.Sinks.File/StreamWrapper.cs renamed to src/Serilog.Sinks.File/FileLifecycleHooks.cs

@@ -1,11 +1,12 @@
-using System.IO;
 
 namespace Serilog
 {
+    using System.IO;
+
     /// <summary>
-    /// Wraps the log file's output stream in another stream, such as a GZipStream
+    /// Enables hooking into log file lifecycle events
     /// </summary>
-    public abstract class StreamWrapper
+    public abstract class FileLifecycleHooks
     {
         /// <summary>
         /// Wraps <paramref name="sourceStream"/> in another stream, such as a GZipStream, then returns the wrapped stream

src/Serilog.Sinks.File/FileLoggerConfigurationExtensions.cs

@@ -140,7 +140,7 @@ public static LoggerConfiguration File(
         /// <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>
-        /// <param name="wrapper">Optionally enables wrapping the output stream in another stream, such as a GZipStream.</param>
+        /// <param name="hooks">Optionally enables hooking into log file lifecycle events.</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(
@@ -158,7 +158,7 @@ public static LoggerConfiguration File(
             bool rollOnFileSizeLimit = false,
             int? retainedFileCountLimit = DefaultRetainedFileCountLimit,
             Encoding encoding = null,
-            StreamWrapper wrapper = null)
+            FileLifecycleHooks hooks = null)
         {
             if (sinkConfiguration == null) throw new ArgumentNullException(nameof(sinkConfiguration));
             if (path == null) throw new ArgumentNullException(nameof(path));
@@ -167,7 +167,7 @@ public static LoggerConfiguration File(
             var formatter = new MessageTemplateTextFormatter(outputTemplate, formatProvider);
             return File(sinkConfiguration, formatter, path, restrictedToMinimumLevel, fileSizeLimitBytes,
                 levelSwitch, buffered, shared, flushToDiskInterval,
-                rollingInterval, rollOnFileSizeLimit, retainedFileCountLimit, encoding, wrapper);
+                rollingInterval, rollOnFileSizeLimit, retainedFileCountLimit, encoding, hooks);
         }
 
         /// <summary>
@@ -176,7 +176,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, int?, Encoding, StreamWrapper)"/>
+        /// overload of <see cref="File(LoggerSinkConfiguration, string, LogEventLevel, string, IFormatProvider, long?, LoggingLevelSwitch, bool, bool, TimeSpan?, RollingInterval, bool, int?, Encoding, FileLifecycleHooks)"/>
         /// and specify the outputTemplate parameter instead.
         /// </param>
         /// <param name="path">Path to the file.</param>
@@ -197,7 +197,7 @@ public static LoggerConfiguration File(
         /// <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>
-        /// <param name="wrapper">Optionally enables wrapping the output stream in another stream, such as a GZipStream.</param>
+        /// <param name="hooks">Optionally enables hooking into log file lifecycle events.</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(
@@ -214,11 +214,11 @@ public static LoggerConfiguration File(
             bool rollOnFileSizeLimit = false,
             int? retainedFileCountLimit = DefaultRetainedFileCountLimit,
             Encoding encoding = null,
-            StreamWrapper wrapper = null)
+            FileLifecycleHooks hooks = null)
         {
             return ConfigureFile(sinkConfiguration.Sink, formatter, path, restrictedToMinimumLevel, fileSizeLimitBytes, levelSwitch,
                 buffered, false, shared, flushToDiskInterval, encoding, rollingInterval, rollOnFileSizeLimit,
-                retainedFileCountLimit, wrapper);
+                retainedFileCountLimit, hooks);
         }
 
         /// <summary>
@@ -293,7 +293,7 @@ static LoggerConfiguration ConfigureFile(
             RollingInterval rollingInterval,
             bool rollOnFileSizeLimit,
             int? retainedFileCountLimit,
-            StreamWrapper wrapper)
+            FileLifecycleHooks hooks)
         {
             if (addSink == null) throw new ArgumentNullException(nameof(addSink));
             if (formatter == null) throw new ArgumentNullException(nameof(formatter));
@@ -306,7 +306,7 @@ static LoggerConfiguration ConfigureFile(
 
             if (rollOnFileSizeLimit || rollingInterval != RollingInterval.Infinite)
             {
-                sink = new RollingFileSink(path, formatter, fileSizeLimitBytes, retainedFileCountLimit, encoding, buffered, shared, rollingInterval, rollOnFileSizeLimit, wrapper);
+                sink = new RollingFileSink(path, formatter, fileSizeLimitBytes, retainedFileCountLimit, encoding, buffered, shared, rollingInterval, rollOnFileSizeLimit, hooks);
             }
             else
             {
@@ -315,7 +315,7 @@ static LoggerConfiguration ConfigureFile(
 #pragma warning disable 618
                     if (shared)
                     {
-                        if (wrapper != null)
+                        if (hooks != null)
                         {
                             SelfLog.WriteLine("Unable to use output stream wrapper - these are not supported for shared log files");
                         }
@@ -324,7 +324,7 @@ static LoggerConfiguration ConfigureFile(
                     }
                     else
                     {
-                        sink = new FileSink(path, formatter, fileSizeLimitBytes, buffered: buffered, wrapper: wrapper);
+                        sink = new FileSink(path, formatter, fileSizeLimitBytes, buffered: buffered, hooks: hooks);
                     }
 #pragma warning restore 618
                 }

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

@@ -43,12 +43,12 @@ public sealed class FileSink : IFileSink, IDisposable
         /// <param name="encoding">Character encoding used to write the text file. The default is UTF-8 without BOM.</param>
         /// <param name="buffered">Indicates if flushing to the output file can be buffered or not. The default
         /// is false.</param>
-        /// <param name="wrapper">Optionally enables wrapping the output stream in another stream, such as a GZipStream.</param>
+        /// <param name="hooks">Optionally enables hooking into log file lifecycle events.</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 FileSink(string path, ITextFormatter textFormatter, long? fileSizeLimitBytes, Encoding encoding = null, bool buffered = false,
-            StreamWrapper wrapper = null)
+            FileLifecycleHooks hooks = null)
         {
             if (path == null) throw new ArgumentNullException(nameof(path));
             if (textFormatter == null) throw new ArgumentNullException(nameof(textFormatter));
@@ -70,9 +70,9 @@ public FileSink(string path, ITextFormatter textFormatter, long? fileSizeLimitBy
                 outputStream = _countingStreamWrapper = new WriteCountingStream(_underlyingStream);
             }
 
-            if (wrapper != null)
+            if (hooks != null)
             {
-                outputStream = wrapper.Wrap(outputStream);
+                outputStream = hooks.Wrap(outputStream);
             }
 
             _output = new StreamWriter(outputStream, encoding ?? new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));

src/Serilog.Sinks.File/Sinks/File/RollingFileSink.cs

@@ -35,7 +35,7 @@ sealed class RollingFileSink : ILogEventSink, IFlushableFileSink, IDisposable
         readonly bool _buffered;
         readonly bool _shared;
         readonly bool _rollOnFileSizeLimit;
-        readonly StreamWrapper _wrapper;
+        readonly FileLifecycleHooks _hooks;
 
         readonly object _syncRoot = new object();
         bool _isDisposed;
@@ -52,7 +52,7 @@ public RollingFileSink(string path,
                               bool shared,
                               RollingInterval rollingInterval,
                               bool rollOnFileSizeLimit,
-                              StreamWrapper wrapper = null)
+                              FileLifecycleHooks hooks = null)
         {
             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");
@@ -66,7 +66,7 @@ public RollingFileSink(string path,
             _buffered = buffered;
             _shared = shared;
             _rollOnFileSizeLimit = rollOnFileSizeLimit;
-            _wrapper = wrapper;
+            _hooks = hooks;
         }
 
         public void Emit(LogEvent logEvent)
@@ -147,7 +147,7 @@ void OpenFile(DateTime now, int? minSequence = null)
                 {
                     _currentFile = _shared ?
                         (IFileSink)new SharedFileSink(path, _textFormatter, _fileSizeLimitBytes, _encoding) :
-                        new FileSink(path, _textFormatter, _fileSizeLimitBytes, _encoding, _buffered, _wrapper);
+                        new FileSink(path, _textFormatter, _fileSizeLimitBytes, _encoding, _buffered, _hooks);
                     _currentFileSequence = sequence;
                 }
                 catch (IOException ex)

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

@@ -146,14 +146,14 @@ public void WhenLimitIsNotSpecifiedAndEncodingHasNoPreambleDataIsCorrectlyAppend
         [Fact]
         public void WhenStreamWrapperIsSpecifiedOutputStreamIsWrapped()
         {
-            var gzipWrapper = new GZipStreamWrapper();
+            var gzipWrapper = new GZipHooks();
 
             using (var tmp = TempFolder.ForCaller())
             {
                 var nonexistent = tmp.AllocateFilename("txt");
                 var evt = Some.LogEvent("Hello, world!");
 
-                using (var sink = new FileSink(nonexistent, new JsonFormatter(), null, wrapper: gzipWrapper))
+                using (var sink = new FileSink(nonexistent, new JsonFormatter(), null, hooks: gzipWrapper))
                 {
                     sink.Emit(evt);
                     sink.Emit(evt);

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

@@ -100,7 +100,7 @@ public void WhenSizeLimitIsBreachedNewFilesCreated()
         [Fact]
         public void WhenStreamWrapperSpecifiedIsUsedForRolledFiles()
         {
-            var gzipWrapper = new GZipStreamWrapper();
+            var gzipWrapper = new GZipHooks();
             var fileName = Some.String() + ".txt";
 
             using (var temp = new TempFolder())
@@ -114,7 +114,7 @@ public void WhenStreamWrapperSpecifiedIsUsedForRolledFiles()
                 };
 
                 using (var log = new LoggerConfiguration()
-                    .WriteTo.File(Path.Combine(temp.Path, fileName), rollOnFileSizeLimit: true, fileSizeLimitBytes: 1, wrapper: gzipWrapper)
+                    .WriteTo.File(Path.Combine(temp.Path, fileName), rollOnFileSizeLimit: true, fileSizeLimitBytes: 1, hooks: gzipWrapper)
                     .CreateLogger())
                 {
 

test/Serilog.Sinks.File.Tests/Support/GZipStreamWrapper.cs renamed to test/Serilog.Sinks.File.Tests/Support/GZipHooks.cs

@@ -5,13 +5,13 @@ namespace Serilog.Sinks.File.Tests.Support
 {
     /// <inheritdoc />
     /// <summary>
-    /// Demonstrates the use of <seealso cref="T:Serilog.StreamWrapper" />, by compressing log output using GZip
+    /// Demonstrates the use of <seealso cref="T:Serilog.FileLifecycleHooks" />, by compressing log output using GZip
     /// </summary>
-    public class GZipStreamWrapper : StreamWrapper
+    public class GZipHooks : FileLifecycleHooks
     {
         readonly int _bufferSize;
 
-        public GZipStreamWrapper(int bufferSize = 1024 * 32)
+        public GZipHooks(int bufferSize = 1024 * 32)
         {
             _bufferSize = bufferSize;
         }