Use PipelineLoggingOptions to centralize log level and exception detail configuration

Co-authored-by: davidfowl <95136+davidfowl@users.noreply.github.com>

Author: Copilot

src/Aspire.Hosting/DistributedApplicationBuilder.cs

@@ -446,13 +446,11 @@ public DistributedApplicationBuilder(DistributedApplicationOptions options)
         _innerBuilder.Services.AddSingleton<PipelineActivityReporter>();
         _innerBuilder.Services.AddSingleton<IPipelineActivityReporter, PipelineActivityReporter>(sp => sp.GetRequiredService<PipelineActivityReporter>());
         _innerBuilder.Services.AddSingleton(Pipeline);
-        _innerBuilder.Services.AddSingleton<ILoggerProvider, PipelineLoggerProvider>();
 
-        // Read this once from configuration and use it to filter logs from the pipeline
-        LogLevel? minLevel = null;
-        _innerBuilder.Logging.AddFilter<PipelineLoggerProvider>((level) =>
+        // Configure pipeline logging options
+        _innerBuilder.Services.Configure<PipelineLoggingOptions>(o =>
         {
-            minLevel ??= _innerBuilder.Configuration["Publishing:LogLevel"]?.ToLowerInvariant() switch
+            o.MinimumLogLevel = _innerBuilder.Configuration["Publishing:LogLevel"]?.ToLowerInvariant() switch
             {
                 "trace" => LogLevel.Trace,
                 "debug" => LogLevel.Debug,
@@ -462,8 +460,14 @@ public DistributedApplicationBuilder(DistributedApplicationOptions options)
                 "crit" or "critical" => LogLevel.Critical,
                 _ => LogLevel.Information
             };
+        });
 
-            return level >= minLevel;
+        _innerBuilder.Services.AddSingleton<ILoggerProvider, PipelineLoggerProvider>();
+
+        // Configure logging filter using the PipelineLoggingOptions
+        _innerBuilder.Services.AddOptions<LoggerFilterOptions>().Configure<PipelineLoggingOptions>((filterLoggingOptions, pipelineLoggingOptions) =>
+        {
+            filterLoggingOptions.AddFilter<PipelineLoggerProvider>((level) => level >= pipelineLoggingOptions.MinimumLogLevel);
         });
 
         // Register IDeploymentStateManager based on execution context

src/Aspire.Hosting/Pipelines/PipelineLoggerProvider.cs

@@ -3,6 +3,7 @@
 
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.Extensions.Options;
 
 namespace Aspire.Hosting.Pipelines;
 
@@ -16,6 +17,16 @@ namespace Aspire.Hosting.Pipelines;
 internal sealed class PipelineLoggerProvider : ILoggerProvider
 {
     private static readonly AsyncLocal<StepLoggerHolder?> s_currentLogger = new();
+    private readonly PipelineLoggingOptions _options;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="PipelineLoggerProvider"/> class.
+    /// </summary>
+    /// <param name="options">The pipeline logging options.</param>
+    public PipelineLoggerProvider(IOptions<PipelineLoggingOptions> options)
+    {
+        _options = options.Value;
+    }
 
     /// <summary>
     /// Gets or sets the current logger for the executing pipeline step.
@@ -39,7 +50,7 @@ public static ILogger CurrentLogger
 
     /// <inheritdoc/>
     public ILogger CreateLogger(string categoryName) =>
-        new PipelineLogger(() => CurrentLogger);
+        new PipelineLogger(() => CurrentLogger, _options);
 
     /// <inheritdoc/>
     public void Dispose()
@@ -61,9 +72,9 @@ private sealed class StepLoggerHolder
     /// <remarks>
     /// This logger acts as a proxy and dynamically resolves the current logger on each operation,
     /// allowing the target logger to change between calls.
-    /// When logging exceptions, stack traces are only included when the log level is Debug or Trace.
+    /// When logging exceptions, stack traces are only included when the configured minimum log level is Debug or Trace.
     /// </remarks>
-    private sealed class PipelineLogger(Func<ILogger> currentLoggerAccessor) : ILogger
+    private sealed class PipelineLogger(Func<ILogger> currentLoggerAccessor, PipelineLoggingOptions options) : ILogger
     {
         /// <inheritdoc/>
         public IDisposable? BeginScope<TState>(TState state) where TState : notnull =>
@@ -78,9 +89,9 @@ public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Except
         {
             var logger = currentLoggerAccessor();
 
-            // If there's an exception and the log level is not Debug or Trace, exclude the exception from the log
+            // If there's an exception and we should not include exception details, exclude the exception from the log
             // to avoid cluttering production logs with stack traces
-            if (exception is not null && logLevel >= LogLevel.Debug)
+            if (exception is not null && !options.IncludeExceptionDetails)
             {
                 logger.Log(logLevel, eventId, state, null, formatter);
             }

src/Aspire.Hosting/Pipelines/PipelineLoggingOptions.cs

@@ -0,0 +1,25 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.Extensions.Logging;
+
+namespace Aspire.Hosting.Pipelines;
+
+/// <summary>
+/// Options for controlling logging behavior in the pipeline.
+/// </summary>
+internal sealed class PipelineLoggingOptions
+{
+    /// <summary>
+    /// Gets or sets the minimum log level for pipeline logging.
+    /// </summary>
+    public LogLevel MinimumLogLevel { get; set; } = LogLevel.Information;
+
+    /// <summary>
+    /// Gets a value indicating whether exception details (stack traces) should be included in logs.
+    /// </summary>
+    /// <remarks>
+    /// Exception details are included when the minimum log level is Debug or Trace.
+    /// </remarks>
+    public bool IncludeExceptionDetails => MinimumLogLevel <= LogLevel.Debug;
+}

tests/Aspire.Hosting.Tests/Pipelines/PipelineLoggerProviderTests.cs

@@ -8,11 +8,17 @@
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
 using Microsoft.Extensions.Logging.Testing;
+using Microsoft.Extensions.Options;
 
 namespace Aspire.Hosting.Tests.Pipelines;
 
 public class PipelineLoggerProviderTests
 {
+    private static PipelineLoggerProvider CreateProvider(LogLevel minimumLogLevel = LogLevel.Information)
+    {
+        var options = Options.Create(new PipelineLoggingOptions { MinimumLogLevel = minimumLogLevel });
+        return new PipelineLoggerProvider(options);
+    }
     [Fact]
     public void CurrentLogger_WhenNotSet_ReturnsNullLogger()
     {
@@ -72,7 +78,7 @@ public void CurrentLogger_WhenSetToNull_ReturnsNullLogger()
     public void CreateLogger_ReturnsValidLogger()
     {
         // Arrange
-        var provider = new PipelineLoggerProvider();
+        var provider = CreateProvider();
 
         // Act
         var logger = provider.CreateLogger("TestCategory");
@@ -87,7 +93,7 @@ public async Task CurrentLogger_IsAsyncLocal_IsolatedBetweenTasks()
         // Arrange
         var fakeLogger1 = new FakeLogger();
         var fakeLogger2 = new FakeLogger();
-        var provider = new PipelineLoggerProvider();
+        var provider = CreateProvider();
 
         // Act
         var task1 = Task.Run(async () =>