Removing MinimumLevel from ILoggerFactory #298

Author: JunTaoLuo

src/Microsoft.Extensions.Logging.Abstractions/ILoggerFactory.cs

@@ -11,11 +11,6 @@ namespace Microsoft.Extensions.Logging
     /// </summary>
     public interface ILoggerFactory : IDisposable
     {
-        /// <summary>
-        /// The minimum level of log messages sent to loggers.
-        /// </summary>
-        LogLevel MinimumLevel { get; set; }
-
         /// <summary>
         /// Creates a new <see cref="ILogger"/> instance.
         /// </summary>

src/Microsoft.Extensions.Logging.Testing/NullLoggerFactory.cs

@@ -1,16 +1,12 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
-using System;
-
 namespace Microsoft.Extensions.Logging.Testing
 {
     public class NullLoggerFactory : ILoggerFactory
     {
         public static readonly NullLoggerFactory Instance = new NullLoggerFactory();
 
-        public LogLevel MinimumLevel { get; set; } = LogLevel.Verbose;
-
         public ILogger CreateLogger(string name)
         {
             return NullLogger.Instance;

src/Microsoft.Extensions.Logging.Testing/TestLoggerFactory.cs

@@ -16,8 +16,6 @@ public TestLoggerFactory(TestSink sink, bool enabled)
             _enabled = enabled;
         }
 
-        public LogLevel MinimumLevel { get; set; } = LogLevel.Verbose;
-
         public ILogger CreateLogger(string name)
         {
             return new TestLogger(name, _sink, _enabled);

src/Microsoft.Extensions.Logging/Logger.cs

@@ -37,31 +37,28 @@ public void Log(LogLevel logLevel, int eventId, object state, Exception exceptio
                 return;
             }
 
-            if (logLevel >= _loggerFactory.MinimumLevel)
+            List<Exception> exceptions = null;
+            foreach (var logger in _loggers)
             {
-                List<Exception> exceptions = null;
-                foreach (var logger in _loggers)
+                try
+                {
+                    logger.Log(logLevel, eventId, state, exception, formatter);
+                }
+                catch (Exception ex)
                 {
-                    try
+                    if (exceptions == null)
                     {
-                        logger.Log(logLevel, eventId, state, exception, formatter);
+                        exceptions = new List<Exception>();
                     }
-                    catch (Exception ex)
-                    {
-                        if (exceptions == null)
-                        {
-                            exceptions = new List<Exception>();
-                        }
 
-                        exceptions.Add(ex);
-                    }
+                    exceptions.Add(ex);
                 }
+            }
 
-                if (exceptions != null && exceptions.Count > 0)
-                {
-                    throw new AggregateException(
-                        message: "An error occurred while writing to logger(s).", innerExceptions: exceptions);
-                }
+            if (exceptions != null && exceptions.Count > 0)
+            {
+                throw new AggregateException(
+                    message: "An error occurred while writing to logger(s).", innerExceptions: exceptions);
             }
         }
 
@@ -72,11 +69,6 @@ public bool IsEnabled(LogLevel logLevel)
                 return false;
             }
 
-            if (logLevel < _loggerFactory.MinimumLevel)
-            {
-                return false;
-            }
-
             List<Exception> exceptions = null;
             foreach (var logger in _loggers)
             {

src/Microsoft.Extensions.Logging/LoggerFactory.cs

@@ -31,8 +31,6 @@ public ILogger CreateLogger(string categoryName)
             return logger;
         }
 
-        public LogLevel MinimumLevel { get; set; } = LogLevel.Verbose;
-
         public void AddProvider(ILoggerProvider provider)
         {
             lock (_sync)

test/Microsoft.Extensions.Logging.Test/ConsoleLoggerTest.cs

@@ -54,60 +54,6 @@ private Tuple<ILoggerFactory, ConsoleSink> SetUpFactory(Func<string, LogLevel, b
             return new Tuple<ILoggerFactory, ConsoleSink>(factory, sink);
         }
 
-        [Fact]
-        public void MessagesAreNotLoggedWhenBelowMinimumLevel()
-        {
-            // arrange
-            var t = SetUpFactory(null);
-            var factory = t.Item1;
-            var sink = t.Item2;
-            var logger = factory.CreateLogger(_loggerName);
-
-
-            // act
-            logger.Log(LogLevel.Debug, 0, _state, null, null);
-            logger.Log(LogLevel.Verbose, 0, _state, null, null);
-
-            // assert
-            Assert.Equal(LogLevel.Verbose, factory.MinimumLevel);
-            Assert.Equal(3, sink.Writes.Count);
-        }
-
-        [Theory]
-        [InlineData(LogLevel.Debug, 18, true, true)]
-        [InlineData(LogLevel.Verbose, 15, false, true)]
-        [InlineData(LogLevel.Information, 12, false, true)]
-        [InlineData(LogLevel.Warning, 9, false, false)]
-        [InlineData(LogLevel.Error, 6, false, false)]
-        [InlineData(LogLevel.Critical, 3, false, false)]
-        public void MinimumLogLevelCanBeChanged(
-            LogLevel minimumLevel,
-            int expectedMessageCount,
-            bool enabledDebug,
-            bool enabledInformation)
-        {
-            var t = SetUpFactory(null);
-            var factory = t.Item1;
-            var sink = t.Item2;
-            var logger = factory.CreateLogger(_loggerName);
-
-            factory.MinimumLevel = minimumLevel;
-
-            // act
-            logger.Log(LogLevel.Debug, 0, _state, null, null);
-            logger.Log(LogLevel.Verbose, 0, _state, null, null);
-            logger.Log(LogLevel.Information, 0, _state, null, null);
-            logger.Log(LogLevel.Warning, 0, _state, null, null);
-            logger.Log(LogLevel.Error, 0, _state, null, null);
-            logger.Log(LogLevel.Critical, 0, _state, null, null);
-
-            // assert
-            Assert.Equal(minimumLevel, factory.MinimumLevel);
-            Assert.Equal(expectedMessageCount, sink.Writes.Count);
-            Assert.Equal(enabledDebug, logger.IsEnabled(LogLevel.Debug));
-            Assert.Equal(enabledInformation, logger.IsEnabled(LogLevel.Information));
-        }
-
         [Fact]
         public void ThrowsException_WhenNoMessageAndExceptionAreProvided()
         {

test/Microsoft.Extensions.Logging.Test/TestLoggerFactory.cs

@@ -1,8 +1,6 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
-using System;
-
 namespace Microsoft.Extensions.Logging.Test
 {
     public class TestLoggerFactory : ILoggerFactory
@@ -16,8 +14,6 @@ public TestLoggerFactory(TestSink sink, bool enabled)
             _enabled = enabled;
         }
 
-        public LogLevel MinimumLevel { get; set; } = LogLevel.Verbose;
-
         public ILogger CreateLogger(string categoryName)
         {
             return new TestLogger(categoryName, _sink, _enabled);

test/Microsoft.Extensions.Logging.Testing.Tests/NullLoggerFactoryTest.cs

@@ -1,20 +1,12 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
-using System;
 using Xunit;
 
 namespace Microsoft.Extensions.Logging.Testing
 {
     public class NullLoggerFactoryTest
     {
-        [Fact]
-        public void MinimumLevelIsVerbose()
-        {
-            // Act & Assert
-            Assert.True(LogLevel.Verbose == NullLoggerFactory.Instance.MinimumLevel);
-        }
-
         [Fact]
         public void Create_GivesSameLogger()
         {