Improve WebApplication debugging (#48827)

Author: JamesNK

src/DefaultBuilder/src/WebApplication.cs

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.Hosting.Server;
@@ -18,6 +19,8 @@ namespace Microsoft.AspNetCore.Builder;
 /// <summary>
 /// The web application used to configure the HTTP pipeline, and routes.
 /// </summary>
+[DebuggerDisplay("{DebuggerToString(),nq}")]
+[DebuggerTypeProxy(typeof(WebApplicationDebugView))]
 public sealed class WebApplication : IHost, IApplicationBuilder, IEndpointRouteBuilder, IAsyncDisposable
 {
     internal const string GlobalEndpointRouteBuilderKey = "__GlobalEndpointRouteBuilder";
@@ -237,4 +240,39 @@ private void Listen(string? url)
         addresses.Clear();
         addresses.Add(url);
     }
+
+    private string DebuggerToString()
+    {
+        return $@"ApplicationName = ""{Environment.ApplicationName}"", IsRunning = {(IsRunning ? "true" : "false")}";
+    }
+
+    // Web app is running if the app has been started and hasn't been stopped.
+    private bool IsRunning => Lifetime.ApplicationStarted.IsCancellationRequested && !Lifetime.ApplicationStopped.IsCancellationRequested;
+
+    internal sealed class WebApplicationDebugView(WebApplication webApplication)
+    {
+        private readonly WebApplication _webApplication = webApplication;
+
+        public IServiceProvider Services => _webApplication.Services;
+        public IConfiguration Configuration => _webApplication.Configuration;
+        public IWebHostEnvironment Environment => _webApplication.Environment;
+        public IHostApplicationLifetime Lifetime => _webApplication.Lifetime;
+        public ILogger Logger => _webApplication.Logger;
+        public string Urls => string.Join(", ", _webApplication.Urls);
+        public IReadOnlyList<Endpoint> Endpoints => _webApplication.Services.GetRequiredService<EndpointDataSource>().Endpoints;
+        public bool IsRunning => _webApplication.IsRunning;
+        public IList<string>? Middleware
+        {
+            get
+            {
+                if (_webApplication.Properties.TryGetValue("__MiddlewareDescriptions", out var value) &&
+                    value is IList<string> descriptions)
+                {
+                    return descriptions;
+                }
+
+                throw new NotSupportedException("Unable to get configured middleware.");
+            }
+        }
+    }
 }

src/DefaultBuilder/src/WebApplicationBuilder.cs

@@ -6,6 +6,7 @@
 using Microsoft.AspNetCore.Authentication;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Http;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
@@ -386,18 +387,17 @@ private void ConfigureApplication(WebHostBuilderContext context, IApplicationBui
         }
 
         // Wire the source pipeline to run in the destination pipeline
-        app.Use(next =>
-        {
-            _builtApplication.Run(next);
-            return _builtApplication.BuildRequestDelegate();
-        });
+        var wireSourcePipeline = new WireSourcePipeline(_builtApplication);
+        app.Use(wireSourcePipeline.CreateMiddleware);
 
         if (_builtApplication.DataSources.Count > 0)
         {
             // We don't know if user code called UseEndpoints(), so we will call it just in case, UseEndpoints() will ignore duplicate DataSources
             app.UseEndpoints(_ => { });
         }
 
+        MergeMiddlewareDescriptions(app);
+
         // Copy the properties to the destination app builder
         foreach (var item in _builtApplication.Properties)
         {
@@ -416,4 +416,45 @@ private void ConfigureApplication(WebHostBuilderContext context, IApplicationBui
 
     void IHostApplicationBuilder.ConfigureContainer<TContainerBuilder>(IServiceProviderFactory<TContainerBuilder> factory, Action<TContainerBuilder>? configure) =>
         _hostApplicationBuilder.ConfigureContainer(factory, configure);
+
+    private void MergeMiddlewareDescriptions(IApplicationBuilder app)
+    {
+        // A user's app builds up a list of middleware. Then when the WebApplication is started, middleware is automatically added
+        // if it is required. For example, the app has mapped endpoints but hasn't configured UseRouting/UseEndpoints.
+        //
+        // This method updates the middleware descriptions to include automatically added middleware.
+        // The app's middleware list is inserted into the new pipeline to create the best representation possible of the middleware pipeline.
+        //
+        // If the debugger isn't attached then there won't be middleware description collections in the properties and this does nothing.
+
+        Debug.Assert(_builtApplication is not null);
+
+        const string MiddlewareDescriptionsKey = "__MiddlewareDescriptions";
+        if (_builtApplication.Properties.TryGetValue(MiddlewareDescriptionsKey, out var sourceValue) &&
+            app.Properties.TryGetValue(MiddlewareDescriptionsKey, out var destinationValue) &&
+            sourceValue is List<string> sourceDescriptions &&
+            destinationValue is List<string> destinationDescriptions)
+        {
+            var wireUpIndex = destinationDescriptions.IndexOf(typeof(WireSourcePipeline).FullName!);
+            if (wireUpIndex != -1)
+            {
+                destinationDescriptions.RemoveAt(wireUpIndex);
+                destinationDescriptions.InsertRange(wireUpIndex, sourceDescriptions);
+
+                _builtApplication.Properties[MiddlewareDescriptionsKey] = destinationDescriptions;
+            }
+        }
+    }
+
+    // This type exists so the place where the source pipeline is wired into the destination pipeline can be identified.
+    private sealed class WireSourcePipeline(IApplicationBuilder builtApplication)
+    {
+        private readonly IApplicationBuilder _builtApplication = builtApplication;
+
+        public RequestDelegate CreateMiddleware(RequestDelegate next)
+        {
+            _builtApplication.Run(next);
+            return _builtApplication.Build();
+        }
+    }
 }

src/DefaultBuilder/test/Microsoft.AspNetCore.Tests/WebApplicationTests.cs

@@ -1729,6 +1729,7 @@ public void WebApplicationBuilder_ThrowsFromExtensionMethodsNotSupportedByHostAn
     public async Task EndpointDataSourceOnlyAddsOnce(CreateBuilderFunc createBuilder)
     {
         var builder = createBuilder();
+        builder.WebHost.UseTestServer();
         await using var app = builder.Build();
 
         app.UseRouting();
@@ -1883,6 +1884,7 @@ public async Task BranchingPipelineHasOwnRoutes(CreateBuilderFunc createBuilder)
     public async Task PropertiesPreservedFromInnerApplication(CreateBuilderFunc createBuilder)
     {
         var builder = createBuilder();
+        builder.WebHost.UseTestServer();
         builder.Services.AddSingleton<IStartupFilter, PropertyFilter>();
         await using var app = builder.Build();
 
@@ -2526,6 +2528,141 @@ public async Task UsingCreateSlimBuilderWorksIfRegexConstraintAddedViaAddRouting
         Assert.Equal("RegexRoute", chosenRoute);
     }
 
+    private sealed class TestDebugger : IDebugger
+    {
+        private bool _isAttached;
+        public TestDebugger(bool isAttached) => _isAttached = isAttached;
+        public bool IsAttached => _isAttached;
+    }
+
+    [Fact]
+    public void UseMiddleware_DebugView_HasMiddleware()
+    {
+        var builder = WebApplication.CreateBuilder();
+        builder.Services.AddSingleton<IDebugger>(new TestDebugger(true));
+
+        var app = builder.Build();
+
+        app.UseMiddleware<MiddlewareWithInterface>();
+        app.UseAuthentication();
+        app.Use(next =>
+        {
+            return next;
+        });
+
+        var debugView = new WebApplication.WebApplicationDebugView(app);
+
+        // Contains three strings:
+        // 1. Middleware that implements IMiddleware from app.UseMiddleware<T>()
+        // 2. AuthenticationMiddleware type from app.UseAuthentication()
+        // 3. Generated delegate name from app.Use(...)
+        Assert.Collection(debugView.Middleware,
+            m => Assert.Equal(typeof(MiddlewareWithInterface).FullName, m),
+            m => Assert.Equal("Microsoft.AspNetCore.Authentication.AuthenticationMiddleware", m),
+            m =>
+            {
+                Assert.Contains(nameof(UseMiddleware_DebugView_HasMiddleware), m);
+                Assert.DoesNotContain(nameof(RequestDelegate), m);
+            });
+    }
+
+    [Fact]
+    public void NoDebugger_DebugView_NoMiddleware()
+    {
+        var builder = WebApplication.CreateBuilder();
+        builder.Services.AddSingleton<IDebugger>(new TestDebugger(false));
+
+        var app = builder.Build();
+
+        app.UseMiddleware<MiddlewareWithInterface>();
+        app.UseAuthentication();
+        app.Use(next =>
+        {
+            return next;
+        });
+
+        var debugView = new WebApplication.WebApplicationDebugView(app);
+
+        Assert.Throws<NotSupportedException>(() => debugView.Middleware);
+    }
+
+    [Fact]
+    public async Task UseMiddleware_HasEndpointsAndAuth_Run_DebugView_HasAutomaticMiddleware()
+    {
+        var builder = WebApplication.CreateBuilder();
+        builder.WebHost.UseTestServer();
+        builder.Services.AddAuthenticationCore();
+        builder.Services.AddAuthorization();
+        builder.Services.AddSingleton<IDebugger>(new TestDebugger(true));
+
+        await using var app = builder.Build();
+
+        app.UseMiddleware<MiddlewareWithInterface>();
+        app.MapGet("/hello", () => "hello world");
+
+        // Starting the app automatically adds middleware as needed.
+        _ = app.RunAsync();
+
+        var debugView = new WebApplication.WebApplicationDebugView(app);
+
+        Assert.Collection(debugView.Middleware,
+            m => Assert.Equal("Microsoft.AspNetCore.HostFiltering.HostFilteringMiddleware", m),
+            m => Assert.Equal("Microsoft.AspNetCore.Routing.EndpointRoutingMiddleware", m),
+            m => Assert.Equal("Microsoft.AspNetCore.Authentication.AuthenticationMiddleware", m),
+            m => Assert.Equal("Microsoft.AspNetCore.Authorization.AuthorizationMiddleware", m),
+            m => Assert.Equal(typeof(MiddlewareWithInterface).FullName, m),
+            m => Assert.Equal("Microsoft.AspNetCore.Routing.EndpointMiddleware", m));
+    }
+
+    [Fact]
+    public async Task NoMiddleware_Run_DebugView_HasAutomaticMiddleware()
+    {
+        var builder = WebApplication.CreateBuilder();
+        builder.WebHost.UseTestServer();
+        builder.Services.AddSingleton<IDebugger>(new TestDebugger(true));
+
+        await using var app = builder.Build();
+
+        // Starting the app automatically adds middleware as needed.
+        _ = app.RunAsync();
+
+        var debugView = new WebApplication.WebApplicationDebugView(app);
+
+        Assert.Collection(debugView.Middleware,
+            m => Assert.Equal("Microsoft.AspNetCore.HostFiltering.HostFilteringMiddleware", m));
+    }
+
+    [Fact]
+    public void NestedMiddleware_DebugView_OnlyContainsTopLevelMiddleware()
+    {
+        var builder = WebApplication.CreateBuilder();
+        builder.Services.AddSingleton<IDebugger>(new TestDebugger(true));
+
+        var app = builder.Build();
+
+        app.MapWhen(c => true, nested =>
+        {
+            nested.UseStatusCodePages();
+        });
+        app.UseWhen(c => false, nested =>
+        {
+            nested.UseDeveloperExceptionPage();
+        });
+        app.UseExceptionHandler();
+
+        var debugView = new WebApplication.WebApplicationDebugView(app);
+
+        Assert.Equal(3, debugView.Middleware.Count);
+    }
+
+    private class MiddlewareWithInterface : IMiddleware
+    {
+        public Task InvokeAsync(HttpContext context, RequestDelegate next)
+        {
+            throw new NotImplementedException();
+        }
+    }
+
     private class UberHandler : AuthenticationHandler<AuthenticationSchemeOptions>
     {
         public UberHandler(IOptionsMonitor<AuthenticationSchemeOptions> options, ILoggerFactory logger, UrlEncoder encoder) : base(options, logger, encoder) { }

src/Hosting/Hosting/src/Internal/ApplicationLifetime.cs

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 
@@ -9,6 +10,9 @@ namespace Microsoft.AspNetCore.Hosting;
 /// <summary>
 /// Allows consumers to perform cleanup during a graceful shutdown.
 /// </summary>
+[DebuggerDisplay("ApplicationStarted = {ApplicationStarted.IsCancellationRequested}, " +
+    "ApplicationStopping = {ApplicationStopping.IsCancellationRequested}, " +
+    "ApplicationStopped = {ApplicationStopped.IsCancellationRequested}")]
 #pragma warning disable CS0618 // Type or member is obsolete
 internal sealed class ApplicationLifetime : IApplicationLifetime, Extensions.Hosting.IApplicationLifetime, IHostApplicationLifetime
 #pragma warning restore CS0618 // Type or member is obsolete

src/Hosting/Hosting/src/Internal/HostingEnvironment.cs

@@ -1,9 +1,12 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics;
 using Microsoft.Extensions.FileProviders;
 
 namespace Microsoft.AspNetCore.Hosting;
+
+[DebuggerDisplay("ApplicationName = {ApplicationName}, EnvironmentName = {EnvironmentName}")]
 #pragma warning disable CS0618 // Type or member is obsolete
 internal sealed class HostingEnvironment : IHostingEnvironment, Extensions.Hosting.IHostingEnvironment, IWebHostEnvironment
 #pragma warning restore CS0618 // Type or member is obsolete