Refactor logging extensions for improved structure and functionality; update README and add default values for log levels and labels

Author: electricessence

.editorconfig

@@ -277,6 +277,9 @@ dotnet_diagnostic.IDE0305.severity = none
 # CA1510: Use ArgumentNullException throw helper
 dotnet_diagnostic.CA1510.severity = none
 
+# CA1031: Exception specificity
+dotnet_diagnostic.CA1031.severity = none
+
 # IDE0306: Simplify collection initialization
 dotnet_diagnostic.IDE0306.severity = silent
 

Directory.Build.props

@@ -48,7 +48,6 @@
 
 	<!-- Common items to include in the package -->
 	<ItemGroup>
-		<None Include="$(MSBuildThisFileDirectory)README.md" Pack="true" PackagePath="\" Visible="false" />
 		<None Include="$(MSBuildThisFileDirectory)logo.png" Pack="true" PackagePath="\" Visible="false" Condition="Exists('$(MSBuildThisFileDirectory)\logo.png')" />
 	</ItemGroup>
 

Open.Logging.Extensions.SpectreConsole/Open.Logging.Extensions.SpectreConsole.csproj

@@ -1,19 +1,34 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <Description>Provides customizable a Microsoft.Extensions.Logging.Console.ConsoleFormatter for Spectre.Console.</Description>
+		<VersionPrefix>1.0.0</VersionPrefix>
+
+		<Description>Provides customizable a Microsoft.Extensions.Logging.Console.ConsoleFormatter for Spectre.Console.</Description>
     <GenerateDocumentationFile>True</GenerateDocumentationFile>
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
+    <PackageReadmeFile>README.md</PackageReadmeFile>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.Logging" />
-    <PackageReference Include="Microsoft.Extensions.Logging.Console" />
+    <None Include="..\README.md">
+      <Pack>True</Pack>
+      <PackagePath>\</PackagePath>
+    </None>
+  </ItemGroup>
+
+  <ItemGroup>
     <PackageReference Include="Spectre.Console" />
   </ItemGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\Open.Logging.Extensions\Open.Logging.Extensions.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <None Update="README.md">
+      <Pack>True</Pack>
+      <PackagePath>\</PackagePath>
+    </None>
+  </ItemGroup>
+
 </Project>

Open.Logging.Extensions.SpectreConsole/README.md

@@ -0,0 +1,166 @@
+# Open.Logging.Extensions.SpectreConsole
+
+A lightweight integration between Microsoft's logging infrastructure and [Spectre.Console](https://spectreconsole.net/) for enhanced console logging.
+
+## Overview
+
+This library bridges the gap between the standard Microsoft.Extensions.Logging framework and Spectre.Console's rich styling capabilities, making it easy to use Spectre.Console as a logging target in your .NET applications.
+
+## Installation
+
+```sh
+dotnet add package Open.Logging.Extensions.SpectreConsole
+```
+
+## Basic Usage
+
+Add the Spectre Console logger to your dependency injection container:
+
+```csharp
+using Microsoft.Extensions.Logging;
+using Open.Logging.Extensions.SpectreConsole;
+
+// In your Startup.cs or Program.cs
+services.AddLogging(builder =>
+{
+    builder.AddSimpleSpectreConsole();
+});
+```
+
+### Inject and Use
+
+Use the logger as you would any standard ILogger:
+
+```csharp
+public class WeatherService
+{
+    private readonly ILogger<WeatherService> _logger;
+    
+    public WeatherService(ILogger<WeatherService> logger)
+    {
+        _logger = logger;
+    }
+    
+    public void GetForecastAsync()
+    {
+        using (_logger.BeginScope("Location: {Location}", "Seattle"))
+        {
+            _logger.LogInformation("Retrieving weather forecast");
+            
+            try
+            {
+                // Your code here
+                _logger.LogDebug("API request details: {Url}", "api/weather?city=Seattle");
+                
+                // Success case
+                _logger.LogInformation("Forecast: {Temperature}°C", 22.5);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Failed to retrieve forecast");
+            }
+        }
+    }
+}
+```
+
+## Customization
+
+### Theme
+
+Spectre.Console provides beautiful styling out of the box. If needed, you can customize colors and formatting:
+
+```csharp
+var customTheme = new SpectreConsoleLogTheme
+{
+    // Styles for log levels
+    Information = new Style(foreground: Color.Cyan),
+    Warning = new Style(foreground: Color.Yellow),
+    Error = new Style(foreground: Color.Red),
+    
+    // Styles for components
+    Timestamp = new Style(foreground: Color.Grey),
+    Category = new Style(foreground: Color.Grey, decoration: Decoration.Italic),
+    Message = Style.Plain
+};
+
+// Apply the custom theme
+services.AddLogging(builder =>
+{
+    var logger = new SimpleSpectreConsoleLogger(theme: customTheme);
+    builder.AddProvider(new SimpleSpectreConsoleLoggerProvider(logger));
+});
+```
+
+### Log Level Labels
+
+You can also customize the text displayed for different log levels:
+
+```csharp
+var customLabels = new LogLevelLabels
+{
+    Trace = "TRACE",
+    Debug = "DEBUG",
+    Information = "INFO",
+    Warning = "WARN",
+    Error = "ERROR",
+    Critical = "FATAL"
+};
+
+// Apply custom labels
+services.AddLogging(builder =>
+{
+    var logger = new SimpleSpectreConsoleLogger(labels: customLabels);
+    builder.AddProvider(new SimpleSpectreConsoleLoggerProvider(logger));
+});
+```
+
+### Buffered Logging
+
+For high-throughput applications:
+
+```csharp
+using Open.Logging.Extensions;
+
+// Get logger from DI
+ILogger logger = serviceProvider.GetRequiredService<ILogger<MyService>>();
+
+// Create buffered logger
+BufferedLogger bufferedLogger = logger.AsBuffered();
+
+// Use with await using for automatic flushing
+await using (bufferedLogger)
+{
+    bufferedLogger.LogInformation("This will be buffered");
+}
+```
+
+## Styling Reference
+
+This integration leverages Spectre.Console's excellent styling system. You can use any style supported by Spectre.Console:
+
+```csharp
+// Simple color names
+Error = "red"
+
+// With decorations
+Warning = "bold yellow"
+
+// With background
+Critical = "white on red"
+
+// Using Style constructor
+Debug = new Style(Color.Blue, Color.Default, Decoration.Dim)
+```
+
+For a complete style reference, see the [Spectre.Console documentation](https://spectreconsole.net/markup).
+
+## Requirements
+
+- .NET 9.0+
+- Microsoft.Extensions.Logging
+- Spectre.Console
+
+## License
+
+MIT License - see the LICENSE file for details.

Open.Logging.Extensions.SpectreConsole/SimpleSpectreConsoleFormatter.cs

@@ -6,15 +6,15 @@ namespace Open.Logging.Extensions.SpectreConsole;
 /// A formatter that outputs log entries to the console using Spectre.Console for enhanced visual styling.
 /// </summary>
 /// <param name="theme">The theme to use for console output styling. If null, uses <see cref="SpectreConsoleLogTheme.Default"/>.</param>
-/// <param name="labels">The labels to use for different log levels. If null, uses <see cref="Default.LevelLabels"/>.</param>
+/// <param name="labels">The labels to use for different log levels. If null, uses <see cref="Defaults.LevelLabels"/>.</param>
 /// <param name="writer">The console writer to use. If null, uses <see cref="AnsiConsole.Console"/>.</param>
 public sealed class SimpleSpectreConsoleFormatter(
 	SpectreConsoleLogTheme? theme = null,
 	LogLevelLabels? labels = null,
 	IAnsiConsole? writer = null)
 {
 	private readonly SpectreConsoleLogTheme _theme = theme ?? SpectreConsoleLogTheme.Default;
-	private readonly LogLevelLabels _labels = labels ?? Default.LevelLabels;
+	private readonly LogLevelLabels _labels = labels ?? Defaults.LevelLabels;
 	private readonly IAnsiConsole _writer = writer ?? AnsiConsole.Console;
 
 	/// <summary>
@@ -31,7 +31,7 @@ public ConsoleDelegateFormatter GetConsoleFormatter(
 	public void Write(PreparedLogEntry entry)
 	{
 		// Timestamp/
-		var elapsedSeconds = entry.GetElapsed().TotalSeconds;
+		var elapsedSeconds = entry.Elapsed.TotalSeconds;
 		_writer.Write(new Text($"{elapsedSeconds:000.000}s", _theme.Timestamp));
 
 		// Level
@@ -74,21 +74,28 @@ public void Write(PreparedLogEntry entry)
 			_writer.Write(" ");
 			_writer.WriteStyled(entry.Message, _theme.Message);
 		}
+
+		_writer.WriteLine();
+
 		// Add the exception details if they exist.
 		if (entry.Exception is not null)
 		{
-			_writer.Write(Environment.NewLine);
+			var rule = new Rule() { Style = Color.Grey };
+			_writer.Write(rule);
 			try
 			{
 				_writer.WriteException(entry.Exception);
 			}
-			catch (Exception ex)
+			catch
 			{
-				// Fallback if WriteException fails
-				_writer.Write($"Exception: {entry.Exception.Message}");
-				_writer.Write(Environment.NewLine);
-				_writer.Write($"Stack Trace: {entry.Exception.StackTrace}");
+				// Fall-back if WriteException fails
+				_writer.WriteLine($"Exception: {entry.Exception.Message}");
+				var st = entry.Exception.StackTrace;
+				if (!string.IsNullOrWhiteSpace(st))
+					_writer.WriteLine(st);
 			}
+
+			_writer.Write(rule);
 		}
 	}
 

Open.Logging.Extensions.SpectreConsole/SimpleSpectreConsoleLogger.cs

@@ -6,15 +6,15 @@ namespace Open.Logging.Extensions.SpectreConsole;
 /// <summary>
 /// A logger implementation that uses Spectre.Console for enhanced console output.
 /// </summary>
-/// <param name="level">The minimum log level to display. Defaults to the value in <see cref="Default.LogLevel"/>.</param>
+/// <param name="level">The minimum log level to display. Defaults to the value in <see cref="Defaults.LogLevel"/>.</param>
 /// <param name="category">The optional category name for the logger.</param>
 /// <param name="timestamp">The optional timestamp to use for log entries. Defaults to current time.</param>
-/// <param name="labels">The optional custom labels for log levels. Defaults to <see cref="Default.LevelLabels"/>.</param>
+/// <param name="labels">The optional custom labels for log levels. Defaults to <see cref="Defaults.LevelLabels"/>.</param>
 /// <param name="theme">The optional custom theme for console output. Defaults to <see cref="SpectreConsoleLogTheme.Default"/>.</param>
 /// <param name="console">The optional <see cref="IAnsiConsole"/> instance to use for writing output. Defaults to <see cref="AnsiConsole.Console"/>.</param>
 /// <param name="scoped">Whether to enable log scopes. Defaults to <see langword="true"/>.</param>
 public class SimpleSpectreConsoleLogger(
-	LogLevel level = Default.LogLevel,
+	LogLevel level = Defaults.LogLevel,
 	string? category = null,
 	DateTimeOffset? timestamp = null,
 	LogLevelLabels? labels = null,

Open.Logging.Extensions.SpectreConsole/SpectreConsoleExtensions.cs

@@ -16,6 +16,7 @@ public static class SpectreConsoleExtensions
 	/// <param name="trim">Whether to trim whitespace from the text before writing. Default is false.</param>
 	public static void WriteStyled(this IAnsiConsole console, string? text, Style style, bool trim = false)
 	{
+		ArgumentNullException.ThrowIfNull(console);
 		if (trim ? string.IsNullOrWhiteSpace(text) : string.IsNullOrEmpty(text))
 			return;
 

Open.Logging.Extensions.SpectreConsole/SpectreConsoleLogTheme.cs

@@ -89,7 +89,10 @@ public record SpectreConsoleLogTheme
 	/// <param name="labels">The labels to use for the log levels.</param>
 	/// <returns>A styled <see cref="Text"/> object for the specified log level.</returns>
 	public Text GetTextForLevel(LogLevel logLevel, LogLevelLabels labels)
-		=> _labelStyles.GetOrAdd(labels.GetLabelForLevel(logLevel), k => new(k, GetStyleForLevel(logLevel)));
+	{
+		ArgumentNullException.ThrowIfNull(labels);
+		return _labelStyles.GetOrAdd(labels.GetLabelForLevel(logLevel), k => new(k, GetStyleForLevel(logLevel)));
+	}
 
 	/// <summary>
 	/// The default theme instance.

Open.Logging.Extensions.Tests/ConsoleDelegateFormatterTests.cs

@@ -9,7 +9,7 @@ public class ConsoleDelegateFormatterTests
 	public void Write_FormatsAndInvokesHandler()
 	{
 		// Arrange
-		var textWriter = new StringWriter();
+		using var textWriter = new StringWriter();
 		PreparedLogEntry? capturedEntry = null;
 		TextWriter? capturedWriter = null;
 
@@ -44,7 +44,7 @@ public void Write_FormatsAndInvokesHandler()
 	public void Write_WithScopeProvider_PassesScopesToHandler()
 	{
 		// Arrange
-		var textWriter = new StringWriter();
+		using var textWriter = new StringWriter();
 		PreparedLogEntry? capturedEntry = null;
 		var scopeProvider = new LoggerExternalScopeProvider();
 
@@ -77,14 +77,14 @@ public void Write_WithScopeProvider_PassesScopesToHandler()
 		Assert.NotNull(capturedEntry);
 		Assert.Equal(2, capturedEntry!.Value.Scopes.Count);
 		Assert.Equal("Scope1", capturedEntry.Value.Scopes[0].ToString());
-		Assert.Contains("Scopes: 2", textWriter.ToString());
+		Assert.Contains("Scopes: 2", textWriter.ToString(), StringComparison.Ordinal);
 	}
 
 	[Fact]
 	public void Write_WithException_PassesExceptionToHandler()
 	{
 		// Arrange
-		var textWriter = new StringWriter();
+		using var textWriter = new StringWriter();
 		PreparedLogEntry? capturedEntry = null;
 		var expectedException = new InvalidOperationException("Test exception");
 
@@ -117,7 +117,7 @@ public void Write_WithException_PassesExceptionToHandler()
 	public void Write_WithEmptyMessage_DoesNotInvokeHandler()
 	{
 		// Arrange
-		var textWriter = new StringWriter();
+		using var textWriter = new StringWriter();
 		var handlerInvoked = false;
 
 		var formatter = new ConsoleDelegateFormatter(
@@ -148,7 +148,7 @@ public void Write_WithEmptyMessage_DoesNotInvokeHandler()
 	public void Constructor_WithAlternateSignature_WrapsHandlerCorrectly()
 	{
 		// Arrange
-		var textWriter = new StringWriter();
+		using var textWriter = new StringWriter();
 		PreparedLogEntry? capturedEntry = null;
 
 		var formatter = new ConsoleDelegateFormatter(
@@ -175,7 +175,7 @@ public void Constructor_WithAlternateSignature_WrapsHandlerCorrectly()
 	public void Constructor_WithCustomTimestamp_UsesProvidedTimestamp()
 	{
 		// Arrange
-		var textWriter = new StringWriter();
+		using var textWriter = new StringWriter();
 		PreparedLogEntry? capturedEntry = null;
 		var timestamp = new DateTimeOffset(2023, 1, 1, 12, 0, 0, TimeSpan.Zero);