Adress PR comments

Author: pakrym

src/Microsoft.Extensions.Logging.AzureWebAppDiagnostics/AzureWebAppDiagnosticsFactoryExtensions.cs

@@ -17,7 +17,7 @@ public static class AzureWebAppDiagnosticsFactoryExtensions
         /// <param name="factory">The extension method argument</param>
         public static ILoggerFactory AddAzureWebAppDiagnostics(this ILoggerFactory factory)
         {
-            return AddAzureWebAppDiagnostics(factory, null);
+            return AddAzureWebAppDiagnostics(factory, new AzureWebAppDiagnosticsSettings());
         }
 
         /// <summary>

src/Microsoft.Extensions.Logging.AzureWebAppDiagnostics/AzureWebAppDiagnosticsSettings.cs

@@ -11,32 +11,32 @@ namespace Microsoft.Extensions.Logging.AzureWebAppDiagnostics
     public class AzureWebAppDiagnosticsSettings
     {
         /// <summary>
-        /// A strictly positive value representing the maximum log size in bytes. Once the log is full, no more message will be appended
+        /// Gets or sets a strictly positive value representing the maximum log size in bytes. Once the log is full, no more message will be appended
         /// </summary>
         public int FileSizeLimit { get; set; } = 10 * 1024 * 1024;
 
         /// <summary>
-        /// A strictly positive value representing the maximum retained file count
+        /// Gets or sets a strictly positive value representing the maximum retained file count
         /// </summary>
         public int RetainedFileCountLimit { get; set; } = 2;
 
         /// <summary>
-        /// A message template describing the output messages
+        /// Gets or sets a message template describing the output messages
         /// </summary>
         public string OutputTemplate { get; set; } = "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level}] {Message}{NewLine}{Exception}";
 
         /// <summary>
-        /// The maximum number of events to include in a single blob append batch.
+        /// Gets or sets a maximum number of events to include in a single blob append batch.
         /// </summary>
         public int BlobBatchSize { get; set; } = 32;
 
         /// <summary>
-        /// The time to wait between checking for blob log batches
+        /// Gets or sets a time to wait between checking for blob log batches
         /// </summary>
         public TimeSpan BlobCommitPeriod { get; set; } = TimeSpan.FromSeconds(5);
 
         /// <summary>
-        /// The last section of log blob name.
+        /// Gets or sets the last section of log blob name.
         /// </summary>
         public string BlobName { get; set; } = "applicationLog.txt";
     }

src/Microsoft.Extensions.Logging.AzureWebAppDiagnostics/Internal/AzureBlobLoggerProvider.cs

@@ -10,9 +10,9 @@
 namespace Microsoft.Extensions.Logging.AzureWebAppDiagnostics.Internal
 {
     /// <summary>
-    /// The <see cref="SerilogLoggerProvider"/> implemenation that creates instances of <see cref="Serilog.Core.Logger"/> connected to <see cref="AzureBlobSink"/>.
+    /// The implemenation of logger provider that creates instances of <see cref="Serilog.Core.Logger"/> connected to <see cref="AzureBlobSink"/>.
     /// </summary>
-    public class AzureBlobLoggerProvider : SerilogLoggerProvider
+    public class AzureBlobLoggerProvider
     {
         private readonly string _outputTemplate;
         private readonly string _appName;
@@ -23,13 +23,34 @@ public class AzureBlobLoggerProvider : SerilogLoggerProvider
         /// <summary>
         /// Creates a new instance of the <see cref="AzureBlobLoggerProvider"/> class.
         /// </summary>
-        /// <param name="outputTemplate"></param>
-        /// <param name="appName"></param>
-        /// <param name="fileName"></param>
-        /// <param name="batchSize"></param>
-        /// <param name="period"></param>
+        /// <param name="outputTemplate">A message template describing the output messages</param>
+        /// <param name="appName">The application name to use in blob name</param>
+        /// <param name="fileName">The last section in log blob name</param>
+        /// <param name="batchSize">A maximum number of events to include in a single blob append batch</param>
+        /// <param name="period">A time to wait between checking for blob log batches</param>
         public AzureBlobLoggerProvider(string outputTemplate, string appName, string fileName, int batchSize, TimeSpan period)
         {
+            if (outputTemplate == null)
+            {
+                throw new ArgumentNullException(nameof(outputTemplate));
+            }
+            if (appName == null)
+            {
+                throw new ArgumentNullException(nameof(appName));
+            }
+            if (fileName == null)
+            {
+                throw new ArgumentNullException(nameof(fileName));
+            }
+            if (batchSize <= 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(batchSize), $"{nameof(batchSize)} should be a positive number.");
+            }
+            if (period <= TimeSpan.Zero)
+            {
+                throw new ArgumentOutOfRangeException(nameof(period), $"{nameof(period)} should be longer then zero.");
+            }
+
             _outputTemplate = outputTemplate;
             _appName = appName;
             _fileName = fileName;
@@ -38,7 +59,7 @@ public AzureBlobLoggerProvider(string outputTemplate, string appName, string fil
         }
 
         /// <inheritdoc />
-        public override Logger ConfigureLogger(IWebAppLogConfigurationReader reader)
+        public Logger ConfigureLogger(IWebAppLogConfigurationReader reader)
         {
             var messageFormatter = new MessageTemplateTextFormatter(_outputTemplate, null);
             var container = new CloudBlobContainer(new Uri(reader.Current.BlobContainerUrl));

src/Microsoft.Extensions.Logging.AzureWebAppDiagnostics/Internal/AzureBlobSink.cs

@@ -43,13 +43,30 @@ public AzureBlobSink(CloudBlobContainer container,
             int batchSizeLimit,
             TimeSpan period) : base(batchSizeLimit, period)
         {
+            if (appName == null)
+            {
+                throw new ArgumentNullException(nameof(appName));
+            }
+            if (fileName == null)
+            {
+                throw new ArgumentNullException(nameof(fileName));
+            }
+            if (formatter == null)
+            {
+                throw new ArgumentNullException(nameof(formatter));
+            }
+            if (batchSizeLimit <= 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(batchSizeLimit), $"{nameof(batchSizeLimit)} should be a positive number.");
+            }
+            if (period <= TimeSpan.Zero)
+            {
+                throw new ArgumentOutOfRangeException(nameof(period), $"{nameof(period)} should be longer then zero.");
+            }
+
             _appName = appName;
             _fileName = fileName;
             _formatter = formatter;
-            if (batchSizeLimit < 1)
-            {
-                throw new ArgumentException(nameof(batchSizeLimit));
-            }
             _container = container;
         }
 

src/Microsoft.Extensions.Logging.AzureWebAppDiagnostics/Internal/FileLoggerProvider.cs

@@ -11,9 +11,9 @@
 namespace Microsoft.Extensions.Logging.AzureWebAppDiagnostics.Internal
 {
     /// <summary>
-    /// The <see cref="SerilogLoggerProvider"/> implemenation that creates instances of <see cref="Serilog.Core.Logger"/> connected to <see cref="RollingFileSink"/>.
+    /// The logger provider that creates instances of <see cref="Serilog.Core.Logger"/> connected to <see cref="RollingFileSink"/>.
     /// </summary>
-    public class FileLoggerProvider: SerilogLoggerProvider
+    public class FileLoggerProvider
     {
         private readonly int _fileSizeLimit;
         private readonly int _retainedFileCountLimit;
@@ -25,17 +25,30 @@ public class FileLoggerProvider: SerilogLoggerProvider
         /// Creates a new instance of the <see cref="FileLoggerProvider"/> class.
         /// </summary>
         /// <param name="fileSizeLimit">A strictly positive value representing the maximum log size in megabytes. Once the log is full, no more message will be appended</param>
-        /// <param name="retainedFileCountLimit"></param>
-        /// <param name="outputTemplate"></param>
+        /// <param name="retainedFileCountLimit">A strictly positive value representing the maximum retained file count</param>
+        /// <param name="outputTemplate">A message template describing the output messages</param>
         public FileLoggerProvider(int fileSizeLimit, int retainedFileCountLimit, string outputTemplate)
         {
+            if (outputTemplate == null)
+            {
+                throw new ArgumentNullException(nameof(outputTemplate));
+            }
+            if (fileSizeLimit <= 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(fileSizeLimit), $"{nameof(fileSizeLimit)} should be positive.");
+            }
+            if (retainedFileCountLimit <= 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(retainedFileCountLimit), $"{nameof(retainedFileCountLimit)} should be positive.");
+            }
+
             _fileSizeLimit = fileSizeLimit;
             _retainedFileCountLimit = retainedFileCountLimit;
             _outputTemplate = outputTemplate;
         }
 
         /// <inheritdoc />
-        public override Logger ConfigureLogger(IWebAppLogConfigurationReader reader)
+        public Logger ConfigureLogger(IWebAppLogConfigurationReader reader)
         {
             var webAppConfiguration = reader.Current;
             if (string.IsNullOrEmpty(webAppConfiguration.FileLoggingFolder))