Renaming LogLevel.Verbose to Trace #299

samples/SampleApp/Program.cs

@@ -43,7 +43,7 @@ public Program()
             //    IncludeScopes = true,
             //    Switches =
             //    {
-            //        ["Default"] = LogLevel.Verbose,
+            //        ["Default"] = LogLevel.Debug,
             //        ["Microsoft"] = LogLevel.Information,
             //    }
             //};

samples/SampleApp/logging.json

@@ -1,7 +1,7 @@
 {
   "IncludeScopes" : "false",
   "LogLevel": {
-    "Default": "Verbose",
+    "Default": "Debug",
     "System": "Information",
     "Microsoft": "Information"
   }

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

@@ -12,13 +12,13 @@ public enum LogLevel
         /// Logs that contain the most detailed messages. These messages may contain sensitive application data.
         /// These messages are disabled by default and should never be enabled in a production environment.
         /// </summary>
-        Debug = 1,
+        Trace = 1,
 
         /// <summary>
         /// Logs that are used for interactive investigation during development.  These logs should primarily contain
         /// information useful for debugging and have no long-term value.
         /// </summary>
-        Verbose = 2,
+        Debug = 2,
 
         /// <summary>
         /// Logs that track the general flow of the application. These logs should have long-term value.

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

@@ -121,80 +121,80 @@ public static void LogDebug(
             logger.LogWithEvent(LogLevel.Debug, eventId, state, error);
         }
 
-        //------------------------------------------VERBOSE------------------------------------------//
+        //------------------------------------------TRACE------------------------------------------//
 
         /// <summary>
-        /// Writes a verbose log message.
+        /// Writes a trace log message.
         /// </summary>
         /// <param name="logger">The <see cref="ILogger"/> to write to.</param>
         /// <param name="data">The message to log.</param>
         // FYI, this field is called data because naming it message triggers CA1303 and CA2204 for callers.
-        public static void LogVerbose(this ILogger logger, string data)
+        public static void LogTrace(this ILogger logger, string data)
         {
             if (logger == null)
             {
                 throw new ArgumentNullException(nameof(logger));
             }
 
-            logger.Log(LogLevel.Verbose, 0, data, null, _messageFormatter);
+            logger.Log(LogLevel.Trace, 0, data, null, _messageFormatter);
         }
 
         /// <summary>
-        /// Writes a verbose log message.
+        /// Writes a trace log message.
         /// </summary>
         /// <param name="logger">The <see cref="ILogger"/> to write to.</param>
         /// <param name="eventId">The event id associated with the log.</param>
         /// <param name="data">The message to log.</param>
-        public static void LogVerbose(this ILogger logger, int eventId, string data)
+        public static void LogTrace(this ILogger logger, int eventId, string data)
         {
             if (logger == null)
             {
                 throw new ArgumentNullException(nameof(logger));
             }
 
-            logger.Log(LogLevel.Verbose, eventId, data, null, _messageFormatter);
+            logger.Log(LogLevel.Trace, eventId, data, null, _messageFormatter);
         }
 
         /// <summary>
-        /// Formats and writes a verbose log message.
+        /// Formats and writes a trace log message.
         /// </summary>
         /// <param name="logger">The <see cref="ILogger"/> to write to.</param>
         /// <param name="format">Format string of the log message.</param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
-        public static void LogVerbose(this ILogger logger, string format, params object[] args)
+        public static void LogTrace(this ILogger logger, string format, params object[] args)
         {
             if (logger == null)
             {
                 throw new ArgumentNullException(nameof(logger));
             }
 
-            logger.Log(LogLevel.Verbose, 0, new FormattedLogValues(format, args), null, _messageFormatter);
+            logger.Log(LogLevel.Trace, 0, new FormattedLogValues(format, args), null, _messageFormatter);
         }
 
         /// <summary>
-        /// Formats and writes a verbose log message.
+        /// Formats and writes a trace log message.
         /// </summary>
         /// <param name="logger">The <see cref="ILogger"/> to write to.</param>
         /// <param name="eventId">The event id associated with the log.</param>
         /// <param name="format">Format string of the log message.</param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
-        public static void LogVerbose(this ILogger logger, int eventId, string format, params object[] args)
+        public static void LogTrace(this ILogger logger, int eventId, string format, params object[] args)
         {
             if (logger == null)
             {
                 throw new ArgumentNullException(nameof(logger));
             }
 
-            logger.Log(LogLevel.Verbose, eventId, new FormattedLogValues(format, args), null, _messageFormatter);
+            logger.Log(LogLevel.Trace, eventId, new FormattedLogValues(format, args), null, _messageFormatter);
         }
 
         /// <summary>
-        /// Formats the given <see cref="ILogValues"/> and writes a verbose log message.
+        /// Formats the given <see cref="ILogValues"/> and writes a trace log message.
         /// </summary>
         /// <param name="logger">The <see cref="ILogger"/> to write to.</param>
         /// <param name="state">The <see cref="ILogValues"/> to write.</param>
         /// <param name="error">The exception to log.</param>
-        public static void LogVerbose(
+        public static void LogTrace(
             this ILogger logger,
             ILogValues state,
             Exception error = null)
@@ -204,17 +204,17 @@ public static void LogVerbose(
                 throw new ArgumentNullException(nameof(logger));
             }
 
-            logger.Log(LogLevel.Verbose, state, error);
+            logger.Log(LogLevel.Trace, state, error);
         }
 
         /// <summary>
-        /// Formats the given <see cref="ILogValues"/> and writes a verbose log message.
+        /// Formats the given <see cref="ILogValues"/> and writes a trace log message.
         /// </summary>
         /// <param name="logger">The <see cref="ILogger"/> to write to.</param>
         /// <param name="eventId">The event id associated with the log.</param>
         /// <param name="state">The <see cref="ILogValues"/> to write.</param>
         /// <param name="error">The exception to log.</param>
-        public static void LogVerbose(
+        public static void LogTrace(
             this ILogger logger,
             int eventId,
             ILogValues state,
@@ -225,7 +225,7 @@ public static void LogVerbose(
                 throw new ArgumentNullException(nameof(logger));
             }
 
-            logger.LogWithEvent(LogLevel.Verbose, eventId, state, error);
+            logger.LogWithEvent(LogLevel.Trace, eventId, state, error);
         }
 
         //------------------------------------------INFORMATION------------------------------------------//

src/Microsoft.Extensions.Logging.Console/ConsoleLogger.cs

@@ -254,10 +254,10 @@ private static string GetLogLevelString(LogLevel logLevel)
         {
             switch (logLevel)
             {
+                case LogLevel.Trace:
+                    return "trce";
                 case LogLevel.Debug:
                     return "dbug";
-                case LogLevel.Verbose:
-                    return "verb";
                 case LogLevel.Information:
                     return "info";
                 case LogLevel.Warning:
@@ -285,7 +285,7 @@ private ConsoleColors GetLogLevelConsoleColors(LogLevel logLevel)
                 case LogLevel.Information:
                     return new ConsoleColors(ConsoleColor.DarkGreen, DefaultConsoleColor);
                 case LogLevel.Debug:
-                case LogLevel.Verbose:
+                case LogLevel.Trace:
                 default:
                     return new ConsoleColors(ConsoleColor.Gray, DefaultConsoleColor);
             }

src/Microsoft.Extensions.Logging.EventLog/EventLogLogger.cs

@@ -106,7 +106,7 @@ private EventLogEntryType GetEventLogEntryType(LogLevel level)
             {
                 case LogLevel.Information:
                 case LogLevel.Debug:
-                case LogLevel.Verbose:
+                case LogLevel.Trace:
                     return EventLogEntryType.Information;
                 case LogLevel.Warning:
                     return EventLogEntryType.Warning;

src/Microsoft.Extensions.Logging.NLog/NLogLoggerProvider.cs

@@ -75,7 +75,7 @@ public bool IsEnabled(LogLevel logLevel)
             {
                 switch (logLevel)
                 {
-                    case LogLevel.Verbose: return global::NLog.LogLevel.Trace;
+                    case LogLevel.Trace: return global::NLog.LogLevel.Trace;
                     case LogLevel.Debug: return global::NLog.LogLevel.Debug;
                     case LogLevel.Information: return global::NLog.LogLevel.Info;
                     case LogLevel.Warning: return global::NLog.LogLevel.Warn;

src/Microsoft.Extensions.Logging.TraceSource/TraceSourceLogger.cs

@@ -58,7 +58,7 @@ private static TraceEventType GetEventType(LogLevel logLevel)
                 case LogLevel.Error: return TraceEventType.Error;
                 case LogLevel.Warning: return TraceEventType.Warning;
                 case LogLevel.Information: return TraceEventType.Information;
-                case LogLevel.Verbose:
+                case LogLevel.Trace:
                 default: return TraceEventType.Verbose;
             }
         }

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

@@ -228,7 +228,7 @@ public void InformationFilter_LogsWhenAppropriate()
             var sink = t.Item2;
 
             // Act
-            logger.Log(LogLevel.Verbose, 0, _state, null, null);
+            logger.Log(LogLevel.Debug, 0, _state, null, null);
 
             // Assert
             Assert.Equal(0, sink.Writes.Count);
@@ -241,10 +241,31 @@ public void InformationFilter_LogsWhenAppropriate()
         }
 
         [Fact]
-        public void VerboseFilter_LogsWhenAppropriate()
+        public void DebugFilter_LogsWhenAppropriate()
         {
             // Arrange
-            var t = SetUp((category, logLevel) => logLevel >= LogLevel.Verbose);
+            var t = SetUp((category, logLevel) => logLevel >= LogLevel.Debug);
+            var logger = t.Item1;
+            var sink = t.Item2;
+
+            // Act
+            logger.Log(LogLevel.Trace, 0, _state, null, null);
+
+            // Assert
+            Assert.Equal(0, sink.Writes.Count);
+
+            // Act
+            logger.Log(LogLevel.Debug, 0, _state, null, null);
+
+            // Assert
+            Assert.Equal(3, sink.Writes.Count);
+        }
+
+        [Fact]
+        public void TraceFilter_LogsWhenAppropriate()
+        {
+            // Arrange
+            var t = SetUp((category, logLevel) => logLevel >= LogLevel.Trace);
             var logger = t.Item1;
             var sink = t.Item2;
 
@@ -253,10 +274,11 @@ public void VerboseFilter_LogsWhenAppropriate()
             logger.Log(LogLevel.Error, 0, _state, null, null);
             logger.Log(LogLevel.Warning, 0, _state, null, null);
             logger.Log(LogLevel.Information, 0, _state, null, null);
-            logger.Log(LogLevel.Verbose, 0, _state, null, null);
+            logger.Log(LogLevel.Debug, 0, _state, null, null);
+            logger.Log(LogLevel.Trace, 0, _state, null, null);
 
             // Assert
-            Assert.Equal(15, sink.Writes.Count);
+            Assert.Equal(18, sink.Writes.Count);
         }
 
         [Fact]
@@ -356,15 +378,39 @@ public void WriteInformation_LogsCorrectColors()
         }
 
         [Fact]
-        public void WriteVerbose_LogsCorrectColors()
+        public void WriteDebug_LogsCorrectColors()
+        {
+            // Arrange
+            var t = SetUp(null);
+            var logger = t.Item1;
+            var sink = t.Item2;
+
+            // Act
+            logger.Log(LogLevel.Debug, 0, _state, null, null);
+
+            // Assert
+            Assert.Equal(3, sink.Writes.Count);
+            var write = sink.Writes[0];
+            Assert.Equal(TestConsole.DefaultBackgroundColor, write.BackgroundColor);
+            Assert.Equal(ConsoleColor.Gray, write.ForegroundColor);
+            write = sink.Writes[1];
+            Assert.Equal(TestConsole.DefaultBackgroundColor, write.BackgroundColor);
+            Assert.Equal(ConsoleColor.Gray, write.ForegroundColor);
+            write = sink.Writes[2];
+            Assert.Equal(TestConsole.DefaultBackgroundColor, write.BackgroundColor);
+            Assert.Equal(ConsoleColor.White, write.ForegroundColor);
+        }
+
+        [Fact]
+        public void WriteTrace_LogsCorrectColors()
         {
             // Arrange
             var t = SetUp(null);
             var logger = t.Item1;
             var sink = t.Item2;
 
             // Act
-            logger.Log(LogLevel.Verbose, 0, _state, null, null);
+            logger.Log(LogLevel.Trace, 0, _state, null, null);
 
             // Assert
             Assert.Equal(3, sink.Writes.Count);
@@ -394,17 +440,17 @@ public void WriteCore_LogsCorrectMessages()
             logger.Log(LogLevel.Error, 0, _state, ex, _theMessageAndError);
             logger.Log(LogLevel.Warning, 0, _state, ex, _theMessageAndError);
             logger.Log(LogLevel.Information, 0, _state, ex, _theMessageAndError);
-            logger.Log(LogLevel.Verbose, 0, _state, ex, _theMessageAndError);
             logger.Log(LogLevel.Debug, 0, _state, ex, _theMessageAndError);
+            logger.Log(LogLevel.Trace, 0, _state, ex, _theMessageAndError);
 
             // Assert
             Assert.Equal(18, sink.Writes.Count);
             Assert.Equal(GetMessage("crit", 0, ex), GetMessage(sink.Writes.GetRange(0, 3)));
             Assert.Equal(GetMessage("fail", 0, ex), GetMessage(sink.Writes.GetRange(3, 3)));
             Assert.Equal(GetMessage("warn", 0, ex), GetMessage(sink.Writes.GetRange(6, 3)));
             Assert.Equal(GetMessage("info", 0, ex), GetMessage(sink.Writes.GetRange(9, 3)));
-            Assert.Equal(GetMessage("verb", 0, ex), GetMessage(sink.Writes.GetRange(12, 3)));
-            Assert.Equal(GetMessage("dbug", 0, ex), GetMessage(sink.Writes.GetRange(15, 3)));
+            Assert.Equal(GetMessage("dbug", 0, ex), GetMessage(sink.Writes.GetRange(12, 3)));
+            Assert.Equal(GetMessage("trce", 0, ex), GetMessage(sink.Writes.GetRange(15, 3)));
         }
 
         [Fact]
@@ -613,9 +659,9 @@ public void ConsoleLogger_ReloadSettings_CanChangeLogLevel()
             loggerFactory.AddConsole(settings);
 
             var logger = loggerFactory.CreateLogger("Test");
-            Assert.False(logger.IsEnabled(LogLevel.Verbose));
+            Assert.False(logger.IsEnabled(LogLevel.Trace));
 
-            settings.Switches["Test"] = LogLevel.Verbose;
+            settings.Switches["Test"] = LogLevel.Trace;
 
             var cancellationTokenSource = settings.Cancel;
             settings.Cancel = new CancellationTokenSource();
@@ -624,7 +670,7 @@ public void ConsoleLogger_ReloadSettings_CanChangeLogLevel()
             cancellationTokenSource.Cancel();
 
             // Assert
-            Assert.True(logger.IsEnabled(LogLevel.Verbose));
+            Assert.True(logger.IsEnabled(LogLevel.Trace));
         }
 
         [Fact]
@@ -644,19 +690,19 @@ public void ConsoleLogger_ReloadSettings_CanReloadMultipleTimes()
             loggerFactory.AddConsole(settings);
 
             var logger = loggerFactory.CreateLogger("Test");
-            Assert.False(logger.IsEnabled(LogLevel.Verbose));
+            Assert.False(logger.IsEnabled(LogLevel.Trace));
 
             // Act & Assert
             for (var i = 0; i < 10; i++)
             {
-                settings.Switches["Test"] = i % 2 == 0 ? LogLevel.Information : LogLevel.Verbose;
+                settings.Switches["Test"] = i % 2 == 0 ? LogLevel.Information : LogLevel.Trace;
 
                 var cancellationTokenSource = settings.Cancel;
                 settings.Cancel = new CancellationTokenSource();
 
                 cancellationTokenSource.Cancel();
 
-                Assert.Equal(i % 2 == 1, logger.IsEnabled(LogLevel.Verbose));
+                Assert.Equal(i % 2 == 1, logger.IsEnabled(LogLevel.Trace));
             }
         }