Add back deprecated APIs

Move Options properties to common base class
Only Keep IConsoleLogFormatter.Format<TState>

src/libraries/Microsoft.Extensions.Logging.Console/ref/Microsoft.Extensions.Logging.Console.cs

@@ -21,15 +21,19 @@ public static partial class ConsoleLoggerExtensions
 }
 namespace Microsoft.Extensions.Logging.Console
 {
-    public partial class CompactLogFormatterOptions
+    public abstract partial class BaseOptions
     {
-        public CompactLogFormatterOptions() { }
-        public bool DisableColors { get { throw null; } set { } }
+        protected BaseOptions() { }
         public bool IncludeScopes { get { throw null; } set { } }
         public Microsoft.Extensions.Logging.LogLevel LogToStandardErrorThreshold { get { throw null; } set { } }
         public string TimestampFormat { get { throw null; } set { } }
         public bool UseUtcTimestamp { get { throw null; } set { } }
     }
+    public partial class CompactLogFormatterOptions : Microsoft.Extensions.Logging.Console.BaseOptions
+    {
+        public CompactLogFormatterOptions() { }
+        public bool DisableColors { get { throw null; } set { } }
+    }
     public static partial class ConsoleLogFormatterNames
     {
         public const string Compact = "Compact";
@@ -42,15 +46,20 @@ public enum ConsoleLoggerFormat
         Default = 0,
         Systemd = 1,
     }
-    public partial class ConsoleLoggerOptions
+    public partial class ConsoleLoggerOptions : Microsoft.Extensions.Logging.Console.BaseOptions
     {
         public ConsoleLoggerOptions() { }
+        [System.ObsoleteAttribute("ConsoleLoggerOptions.DisableColors has been deprecated. Please use DefaultConsoleLogFormatterOptions.DisableColors instead.", false)]
+        public bool DisableColors { get { throw null; } set { } }
+        [System.ObsoleteAttribute("ConsoleLoggerOptions.Format has been deprecated. Please use ConsoleLoggerOptions.FormatterName instead.", false)]
         public Microsoft.Extensions.Logging.Console.ConsoleLoggerFormat Format { get { throw null; } set { } }
-        public string Formatter { get { throw null; } set { } }
+        public string FormatterName { get { throw null; } set { } }
     }
     [Microsoft.Extensions.Logging.ProviderAliasAttribute("Console")]
     public partial class ConsoleLoggerProvider : Microsoft.Extensions.Logging.ILoggerProvider, Microsoft.Extensions.Logging.ISupportExternalScope, System.IDisposable
     {
+        [System.ObsoleteAttribute("ConsoleLoggerProvider.ctor has been deprecated.", false)]
+        public ConsoleLoggerProvider(Microsoft.Extensions.Options.IOptionsMonitor<Microsoft.Extensions.Logging.Console.ConsoleLoggerOptions> options) { }
         public ConsoleLoggerProvider(Microsoft.Extensions.Options.IOptionsMonitor<Microsoft.Extensions.Logging.Console.ConsoleLoggerOptions> options, System.Collections.Generic.IEnumerable<Microsoft.Extensions.Logging.Console.IConsoleLogFormatter> formatters) { }
         public Microsoft.Extensions.Logging.ILogger CreateLogger(string name) { throw null; }
         public void Dispose() { }
@@ -63,43 +72,31 @@ public readonly partial struct ConsoleMessage
         public readonly System.ConsoleColor? Foreground;
         public ConsoleMessage(string message, System.ConsoleColor? background = default(System.ConsoleColor?), System.ConsoleColor? foreground = default(System.ConsoleColor?)) { throw null; }
     }
-    public partial class DefaultConsoleLogFormatterOptions
+    public partial class DefaultConsoleLogFormatterOptions : Microsoft.Extensions.Logging.Console.BaseOptions
     {
         public DefaultConsoleLogFormatterOptions() { }
         public bool DisableColors { get { throw null; } set { } }
-        public bool IncludeScopes { get { throw null; } set { } }
-        public Microsoft.Extensions.Logging.LogLevel LogToStandardErrorThreshold { get { throw null; } set { } }
-        public string TimestampFormat { get { throw null; } set { } }
-        public bool UseUtcTimestamp { get { throw null; } set { } }
     }
     public partial interface IConsoleLogFormatter
     {
         string Name { get; }
-        Microsoft.Extensions.Logging.Console.LogMessageEntry Format(Microsoft.Extensions.Logging.LogLevel logLevel, string logName, int eventId, string message, System.Exception exception, Microsoft.Extensions.Logging.IExternalScopeProvider scopeProvider);
+        BaseOptions Options { get; }
         Microsoft.Extensions.Logging.Console.LogMessageEntry Format<TState>(Microsoft.Extensions.Logging.LogLevel logLevel, string logName, int eventId, TState state, System.Exception exception, System.Func<TState, System.Exception, string> formatter, Microsoft.Extensions.Logging.IExternalScopeProvider scopeProvider);
     }
-    public partial class JsonConsoleLogFormatterOptions
+    public partial class JsonConsoleLogFormatterOptions : Microsoft.Extensions.Logging.Console.BaseOptions
     {
         public JsonConsoleLogFormatterOptions() { }
-        public bool IncludeScopes { get { throw null; } set { } }
         public System.Text.Json.JsonSerializerOptions JsonSerializerOptions { get { throw null; } set { } }
         public System.Text.Json.JsonWriterOptions JsonWriterOptions { get { throw null; } set { } }
-        public Microsoft.Extensions.Logging.LogLevel LogToStandardErrorThreshold { get { throw null; } set { } }
-        public string TimestampFormat { get { throw null; } set { } }
-        public bool UseUtcTimestamp { get { throw null; } set { } }
     }
     public readonly partial struct LogMessageEntry
     {
         public readonly bool LogAsError;
         public readonly Microsoft.Extensions.Logging.Console.ConsoleMessage[] Messages;
         public LogMessageEntry(Microsoft.Extensions.Logging.Console.ConsoleMessage[] messages, bool logAsError = false) { throw null; }
     }
-    public partial class SystemdConsoleLogFormatterOptions
+    public partial class SystemdConsoleLogFormatterOptions : Microsoft.Extensions.Logging.Console.BaseOptions
     {
         public SystemdConsoleLogFormatterOptions() { }
-        public bool IncludeScopes { get { throw null; } set { } }
-        public Microsoft.Extensions.Logging.LogLevel LogToStandardErrorThreshold { get { throw null; } set { } }
-        public string TimestampFormat { get { throw null; } set { } }
-        public bool UseUtcTimestamp { get { throw null; } set { } }
     }
 }

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

@@ -51,13 +51,6 @@ public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Except
             }
         }
 
-        public virtual void WriteMessage(LogLevel logLevel, string logName, int eventId, string message, Exception exception)
-        {
-            var entry = Formatter.Format(logLevel, logName, eventId, message, exception, ScopeProvider);
-            _queueProcessor.EnqueueMessage(entry);
-        }
-
-
         public bool IsEnabled(LogLevel logLevel)
         {
             return logLevel != LogLevel.None;

src/libraries/Microsoft.Extensions.Logging.Console/src/ConsoleLoggerOptions.cs

@@ -10,38 +10,50 @@ namespace Microsoft.Extensions.Logging.Console
     /// <summary>
     /// Options for a <see cref="ConsoleLogger"/>.
     /// </summary>
-    public class ConsoleLoggerOptions
+    public class ConsoleLoggerOptions : BaseOptions
     {
+        [System.ObsoleteAttribute("ConsoleLoggerOptions.DisableColors has been deprecated. Please use DefaultConsoleLogFormatterOptions.DisableColors instead.", false)]
+        public bool DisableColors { get; set; }
+
         /// <summary>
         /// Gets or sets log message format. Defaults to <see cref="ConsoleLoggerFormat.Default" />.
         /// </summary>
+        [System.ObsoleteAttribute("ConsoleLoggerOptions.Format has been deprecated. Please use ConsoleLoggerOptions.FormatterName instead.", false)]
         public ConsoleLoggerFormat Format
         {
             get
             {
-                try {
-                    return (ConsoleLoggerFormat) Enum.Parse(typeof(ConsoleLoggerFormat), Formatter);
-                }
-                catch (ArgumentException) {
-                    return ConsoleLoggerFormat.Default;
-                }
+                if (FormatterName != null && FormatterName.Equals(ConsoleLogFormatterNames.Systemd, StringComparison.OrdinalIgnoreCase))
+                    return ConsoleLoggerFormat.Systemd;
+                return ConsoleLoggerFormat.Default;
             }
             set
             {
                 if (value == ConsoleLoggerFormat.Systemd)
                 {
-                    Formatter = Enum.GetName(typeof(ConsoleLoggerFormat), ConsoleLoggerFormat.Systemd);
+                    FormatterName = ConsoleLogFormatterNames.Systemd;
                 }
                 else
                 {
-                    Formatter = Enum.GetName(typeof(ConsoleLoggerFormat), ConsoleLoggerFormat.Default);
+                    FormatterName = ConsoleLogFormatterNames.Default;
                 }
             }
         }
 
         /// <summary>
         /// 
         /// </summary>
-        public string Formatter { get; set; }
+        public string FormatterName { get; set; }
+    }
+
+    public abstract class BaseOptions
+    {
+        public bool IncludeScopes { get; set; }
+
+        public Microsoft.Extensions.Logging.LogLevel LogToStandardErrorThreshold { get; set; }
+
+        public string TimestampFormat { get; set; }
+
+        public bool UseUtcTimestamp { get; set; }
     }
 }

src/libraries/Microsoft.Extensions.Logging.Console/src/ConsoleLoggerProvider.cs

@@ -25,6 +25,13 @@ public class ConsoleLoggerProvider : ILoggerProvider, ISupportExternalScope
         private IDisposable _optionsReloadToken;
         private IExternalScopeProvider _scopeProvider = NullExternalScopeProvider.Instance;
 
+        [System.ObsoleteAttribute("ConsoleLoggerProvider.ctor has been deprecated.", false)]
+        public ConsoleLoggerProvider(Microsoft.Extensions.Options.IOptionsMonitor<Microsoft.Extensions.Logging.Console.ConsoleLoggerOptions> options) 
+            : this(options, Enumerable.Empty<IConsoleLogFormatter>())
+        {
+            ; // todo: check workflow. maybe we should always have 4 formatters prepped instead?
+        }
+
         /// <summary>
         /// Creates an instance of <see cref="ConsoleLoggerProvider"/>.
         /// </summary>
@@ -56,27 +63,40 @@ public ConsoleLoggerProvider(IOptionsMonitor<ConsoleLoggerOptions> options, IEnu
         private void ReloadLoggerOptions(ConsoleLoggerOptions options)
         {
             string nameFromFormat = Enum.GetName(typeof(ConsoleLoggerFormat), options?.Format);
-            _formatters.TryGetValue(options?.Formatter ?? nameFromFormat, out IConsoleLogFormatter logFormatter);
+            _formatters.TryGetValue(options?.FormatterName ?? nameFromFormat, out IConsoleLogFormatter logFormatter);
             if (logFormatter == null)
             {
                 logFormatter = _formatters[nameFromFormat];
             }
+            UpdateFormatterOptions(logFormatter, options);
 
             foreach (var logger in _loggers)
             {
                 logger.Value.Formatter = logFormatter;
             }
         }
 
+        private void UpdateFormatterOptions(IConsoleLogFormatter formatter, ConsoleLoggerOptions fromOptions)
+        {
+            formatter.Options.IncludeScopes = fromOptions.IncludeScopes;
+            formatter.Options.LogToStandardErrorThreshold = fromOptions.LogToStandardErrorThreshold;
+            formatter.Options.TimestampFormat = fromOptions.TimestampFormat;
+            formatter.Options.UseUtcTimestamp = fromOptions.UseUtcTimestamp;
+            // kept for deprecated api:
+            if (formatter is DefaultConsoleLogFormatter dFormatter)
+                dFormatter.FormatterOptions.DisableColors = fromOptions.DisableColors;
+        }
+
         /// <inheritdoc />
         public ILogger CreateLogger(string name)
         {
             string nameFromFormat = Enum.GetName(typeof(ConsoleLoggerFormat), _options.CurrentValue.Format);
-            _formatters.TryGetValue(_options.CurrentValue.Formatter ?? nameFromFormat, out IConsoleLogFormatter logFormatter);
+            _formatters.TryGetValue(_options.CurrentValue.FormatterName ?? nameFromFormat, out IConsoleLogFormatter logFormatter);
             if (logFormatter == null)
             {
                 logFormatter = _formatters[nameFromFormat];
             }
+            UpdateFormatterOptions(logFormatter, _options.CurrentValue);
 
             return _loggers.GetOrAdd(name, loggerName => new ConsoleLogger(name, _messageQueue)
             {

src/libraries/Microsoft.Extensions.Logging.Console/src/Formatter/CompactLogFormatter.cs

@@ -45,6 +45,14 @@ public void Dispose()
             _optionsReloadToken?.Dispose();
         }
 
+        public BaseOptions Options 
+        {
+            get
+            {
+                return FormatterOptions as BaseOptions;
+            }
+        }
+
         public CompactLogFormatterOptions FormatterOptions { get; set; }
 
         public string Name => ConsoleLogFormatterNames.Compact;
@@ -56,14 +64,10 @@ public LogMessageEntry Format<TState>(LogLevel logLevel, string logName, int eve
             {
                 return FormatHelper(logLevel, logName, eventId, message, exception, scopeProvider, state);
             }
+            // TODO: test use case:
             return default;
         }
 
-        public LogMessageEntry Format(LogLevel logLevel, string logName, int eventId, string message, Exception exception, IExternalScopeProvider scopeProvider)
-        {
-            return FormatHelper<object>(logLevel, logName, eventId, message, exception, scopeProvider, null);
-        }
-
         private LogMessageEntry FormatHelper<TState>(LogLevel logLevel, string logName, int eventId, string message, Exception exception, IExternalScopeProvider scopeProvider, TState scope)
         {
             var messages = new List<ConsoleMessage>();

src/libraries/Microsoft.Extensions.Logging.Console/src/Formatter/CompactLogFormatterOptions.cs

@@ -8,33 +8,13 @@
 
 namespace Microsoft.Extensions.Logging.Console
 {
-    public class CompactLogFormatterOptions
+    public class CompactLogFormatterOptions : BaseOptions
     {
         public CompactLogFormatterOptions() { }
 
-        /// <summary>
-        /// Includes scopes when <see langword="true" />.
-        /// </summary>
-        public bool IncludeScopes { get; set; }
-
         /// <summary>
         /// Disables colors when <see langword="true" />.
         /// </summary>
         public bool DisableColors { get; set; }
-
-        /// <summary>
-        /// Gets or sets value indicating the minimum level of messaged that would get written to <c>Console.Error</c>.
-        /// </summary>
-        public LogLevel LogToStandardErrorThreshold { get; set; } = LogLevel.None;
-
-        /// <summary>
-        /// Gets or sets format string used to format timestamp in logging messages. Defaults to <c>null</c>.
-        /// </summary>
-        public string TimestampFormat { get; set; }
-
-        /// <summary>
-        /// Gets or sets indication whether or not UTC timezone should be used to for timestamps in logging messages. Defaults to <c>false</c>.
-        /// </summary>
-        public bool UseUtcTimestamp { get; set; }
     }
 }

src/libraries/Microsoft.Extensions.Logging.Console/src/Formatter/DefaultConsoleLogFormatter.cs

@@ -48,6 +48,14 @@ public void Dispose()
 
         public string Name => ConsoleLogFormatterNames.Default;
 
+        public BaseOptions Options 
+        {
+            get
+            {
+                return FormatterOptions as BaseOptions;
+            }
+        }
+
         public DefaultConsoleLogFormatterOptions FormatterOptions { get; set; }
 
         public LogMessageEntry Format<TState>(LogLevel logLevel, string logName, int eventId, TState state, Exception exception, Func<TState, Exception, string> formatter, IExternalScopeProvider scopeProvider)
@@ -60,7 +68,7 @@ public LogMessageEntry Format<TState>(LogLevel logLevel, string logName, int eve
             return default;
         }
 
-        public LogMessageEntry Format(LogLevel logLevel, string logName, int eventId, string message, Exception exception, IExternalScopeProvider scopeProvider)
+        private LogMessageEntry Format(LogLevel logLevel, string logName, int eventId, string message, Exception exception, IExternalScopeProvider scopeProvider)
         {
             var logBuilder = _logBuilder;
             _logBuilder = null;

src/libraries/Microsoft.Extensions.Logging.Console/src/Formatter/DefaultConsoleLogFormatterOptions.cs

@@ -8,33 +8,13 @@
 
 namespace Microsoft.Extensions.Logging.Console
 {
-    public class DefaultConsoleLogFormatterOptions
+    public class DefaultConsoleLogFormatterOptions : BaseOptions
     {
         public DefaultConsoleLogFormatterOptions() { }
 
-        /// <summary>
-        /// Includes scopes when <see langword="true" />.
-        /// </summary>
-        public bool IncludeScopes { get; set; }
-
         /// <summary>
         /// Disables colors when <see langword="true" />.
         /// </summary>
         public bool DisableColors { get; set; }
-
-        /// <summary>
-        /// Gets or sets value indicating the minimum level of messaged that would get written to <c>Console.Error</c>.
-        /// </summary>
-        public LogLevel LogToStandardErrorThreshold { get; set; } = LogLevel.None;
-
-        /// <summary>
-        /// Gets or sets format string used to format timestamp in logging messages. Defaults to <c>null</c>.
-        /// </summary>
-        public string TimestampFormat { get; set; }
-
-        /// <summary>
-        /// Gets or sets indication whether or not UTC timezone should be used to for timestamps in logging messages. Defaults to <c>false</c>.
-        /// </summary>
-        public bool UseUtcTimestamp { get; set; }
     }
 }

src/libraries/Microsoft.Extensions.Logging.Console/src/Formatter/IConsoleLogFormatter.cs

@@ -9,7 +9,7 @@ namespace Microsoft.Extensions.Logging.Console
     public interface IConsoleLogFormatter
     {
         string Name { get; }
-        LogMessageEntry Format(LogLevel logLevel, string logName, int eventId, string message, Exception exception, IExternalScopeProvider scopeProvider);
+        BaseOptions Options { get; }
         LogMessageEntry Format<TState>(LogLevel logLevel, string logName, int eventId, TState state, Exception exception, Func<TState, Exception, string> formatter, IExternalScopeProvider scopeProvider);
     }
 }

src/libraries/Microsoft.Extensions.Logging.Console/src/Formatter/JsonConsoleLogFormatter.cs

@@ -96,7 +96,7 @@ public LogMessageEntry Format<TState>(LogLevel logLevel, string logName, int eve
             return default;
         }
 
-        public LogMessageEntry Format(LogLevel logLevel, string logName, int eventId, string message, Exception exception, IExternalScopeProvider scopeProvider)
+        private LogMessageEntry Format(LogLevel logLevel, string logName, int eventId, string message, Exception exception, IExternalScopeProvider scopeProvider)
         {
             var logBuilder = _logBuilder;
             _logBuilder = null;
@@ -190,6 +190,14 @@ private void GetScopeInformation(Utf8JsonWriter writer, IExternalScopeProvider s
             }
         }
 
+        public BaseOptions Options 
+        {
+            get
+            {
+                return FormatterOptions as BaseOptions;
+            }
+        }
+
         public JsonConsoleLogFormatterOptions FormatterOptions { get; set; }
 
         private void ReloadLoggerOptions(JsonConsoleLogFormatterOptions options)