Add backchannel log replay for TUI support

Add server-side backchannel APIs to support the upcoming aspire monitor TUI:

- Add log replay buffer (1000 entries) to BackchannelLoggerProvider so
  late-connecting clients see log history, using Queue<T> for O(1) eviction
- Replay buffered entries at start of GetAppHostLogEntriesAsync stream
- Expose GetAppHostLogEntriesAsync on AuxiliaryBackchannelRpcTarget
- Update BackchannelLoggerProvider DI registration to forwarding pattern
  so AppHostRpcTarget can resolve the concrete type for replay
- Fix Dispose to use TryComplete to handle multiple disposal calls
- Add tests for replay buffer behavior (fill, eviction, snapshot isolation)

All changes are additive and backward-compatible. No CLI or TUI code included.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: Mitch Denny

src/Aspire.Hosting/Backchannel/AppHostRpcTarget.cs

@@ -35,6 +35,16 @@ public async IAsyncEnumerable<BackchannelLogEntry> GetAppHostLogEntriesAsync([En
         using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _shutdownCts.Token);
         var linkedToken = linkedCts.Token;
 
+        // Replay buffered entries first so late-connecting clients see history
+        var loggerProvider = serviceProvider.GetService<BackchannelLoggerProvider>();
+        if (loggerProvider is not null)
+        {
+            foreach (var entry in loggerProvider.GetReplaySnapshot())
+            {
+                yield return entry;
+            }
+        }
+
         Channel<BackchannelLogEntry>? channel = null;
 
         try

src/Aspire.Hosting/Backchannel/AuxiliaryBackchannelRpcTarget.cs

@@ -988,6 +988,16 @@ private HttpClientTransport CreateHttpClientTransport(Uri endpointUri)
 
     #endregion
 
+    /// <summary>
+    /// Streams AppHost log entries from the hosting process.
+    /// Delegates to <see cref="AppHostRpcTarget.GetAppHostLogEntriesAsync"/>.
+    /// </summary>
+    public IAsyncEnumerable<BackchannelLogEntry> GetAppHostLogEntriesAsync(CancellationToken cancellationToken = default)
+    {
+        var rpcTarget = serviceProvider.GetRequiredService<AppHostRpcTarget>();
+        return rpcTarget.GetAppHostLogEntriesAsync(cancellationToken);
+    }
+
     /// <summary>
     /// Converts a JsonElement to its underlying CLR type for proper serialization.
     /// </summary>

src/Aspire.Hosting/Backchannel/BackchannelLoggerProvider.cs

@@ -10,6 +10,9 @@ namespace Aspire.Hosting.Backchannel;
 internal class BackchannelLoggerProvider : ILoggerProvider
 {
     private readonly Channel<BackchannelLogEntry> _channel = Channel.CreateUnbounded<BackchannelLogEntry>();
+    private readonly Queue<BackchannelLogEntry> _replayBuffer = new();
+    private readonly object _replayLock = new();
+    private const int MaxReplayEntries = 1000;
     private readonly IServiceProvider _serviceProvider;
     private readonly object _channelRegisteredLock = new();
     private readonly CancellationTokenSource _backgroundChannelRegistrationCts = new();
@@ -21,6 +24,29 @@ public BackchannelLoggerProvider(IServiceProvider serviceProvider)
         _serviceProvider = serviceProvider;
     }
 
+    /// <summary>
+    /// Gets a snapshot of buffered log entries for replay to late-connecting clients.
+    /// </summary>
+    internal List<BackchannelLogEntry> GetReplaySnapshot()
+    {
+        lock (_replayLock)
+        {
+            return [.. _replayBuffer];
+        }
+    }
+
+    internal void AddToReplayBuffer(BackchannelLogEntry entry)
+    {
+        lock (_replayLock)
+        {
+            if (_replayBuffer.Count >= MaxReplayEntries)
+            {
+                _replayBuffer.Dequeue();
+            }
+            _replayBuffer.Enqueue(entry);
+        }
+    }
+
     private void RegisterLogChannel()
     {
         // Why do we execute this on a background task? This method is spawned on a background
@@ -49,17 +75,17 @@ public ILogger CreateLogger(string categoryName)
             }
         }
 
-        return new BackchannelLogger(categoryName, _channel);
+        return new BackchannelLogger(categoryName, _channel, this);
     }
 
     public void Dispose()
     {
         _backgroundChannelRegistrationCts.Cancel();
-        _channel.Writer.Complete();
+        _channel.Writer.TryComplete();
     }
 }
 
-internal class BackchannelLogger(string categoryName, Channel<BackchannelLogEntry> channel) : ILogger
+internal class BackchannelLogger(string categoryName, Channel<BackchannelLogEntry> channel, BackchannelLoggerProvider provider) : ILogger
 {
     public IDisposable? BeginScope<TState>(TState state) where TState : notnull
     {
@@ -84,6 +110,7 @@ public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Except
                 Message = formatter(state, exception),
             };
 
+            provider.AddToReplayBuffer(entry);
             channel.Writer.TryWrite(entry);
         }
     }

src/Aspire.Hosting/DistributedApplicationBuilder.cs

@@ -188,7 +188,8 @@ public DistributedApplicationBuilder(DistributedApplicationOptions options)
 
         _innerBuilder.Services.AddSingleton(TimeProvider.System);
 
-        _innerBuilder.Services.AddSingleton<ILoggerProvider, BackchannelLoggerProvider>();
+        _innerBuilder.Services.AddSingleton<BackchannelLoggerProvider>();
+        _innerBuilder.Services.AddSingleton<ILoggerProvider>(sp => sp.GetRequiredService<BackchannelLoggerProvider>());
         _innerBuilder.Logging.AddFilter("Microsoft.Hosting.Lifetime", LogLevel.Warning);
         _innerBuilder.Logging.AddFilter("Microsoft.AspNetCore.Server.Kestrel", LogLevel.Error);
         _innerBuilder.Logging.AddFilter("Aspire.Hosting.Dashboard", LogLevel.Error);

tests/Aspire.Hosting.Tests/Backchannel/BackchannelLoggerProviderTests.cs

@@ -0,0 +1,117 @@
+// 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.DependencyInjection;
+using Microsoft.Extensions.Logging;
+
+namespace Aspire.Hosting.Backchannel;
+
+public class BackchannelLoggerProviderTests
+{
+    [Fact]
+    public void ReplayBuffer_ReturnsLoggedEntries()
+    {
+        var services = new ServiceCollection();
+        services.AddSingleton<BackchannelLoggerProvider>();
+        services.AddSingleton<ILoggerProvider>(sp => sp.GetRequiredService<BackchannelLoggerProvider>());
+        services.AddSingleton<AppHostRpcTarget>();
+        services.AddLogging();
+
+        // Add required AppHostRpcTarget dependencies with minimal stubs
+        services.AddSingleton(Aspire.Hosting.Tests.Utils.ResourceNotificationServiceTestHelpers.Create());
+        services.AddSingleton<Aspire.Hosting.Pipelines.PipelineActivityReporter>();
+        services.AddSingleton(new DistributedApplicationOptions { AssemblyName = "Test" });
+        services.AddSingleton<Microsoft.Extensions.Hosting.IHostApplicationLifetime, TestHostApplicationLifetime>();
+
+        using var sp = services.BuildServiceProvider();
+        var provider = sp.GetRequiredService<BackchannelLoggerProvider>();
+
+        var logger = provider.CreateLogger("TestCategory");
+        logger.LogInformation("Message 1");
+        logger.LogWarning("Message 2");
+        logger.LogError("Message 3");
+
+        var snapshot = provider.GetReplaySnapshot();
+
+        Assert.Equal(3, snapshot.Count);
+        Assert.Equal("Message 1", snapshot[0].Message);
+        Assert.Equal("Message 2", snapshot[1].Message);
+        Assert.Equal("Message 3", snapshot[2].Message);
+        Assert.Equal("TestCategory", snapshot[0].CategoryName);
+        Assert.Equal(LogLevel.Information, snapshot[0].LogLevel);
+        Assert.Equal(LogLevel.Warning, snapshot[1].LogLevel);
+        Assert.Equal(LogLevel.Error, snapshot[2].LogLevel);
+    }
+
+    [Fact]
+    public void ReplayBuffer_EvictsOldestWhenFull()
+    {
+        var services = new ServiceCollection();
+        services.AddSingleton<BackchannelLoggerProvider>();
+        services.AddSingleton<ILoggerProvider>(sp => sp.GetRequiredService<BackchannelLoggerProvider>());
+        services.AddSingleton<AppHostRpcTarget>();
+        services.AddLogging();
+
+        services.AddSingleton(Aspire.Hosting.Tests.Utils.ResourceNotificationServiceTestHelpers.Create());
+        services.AddSingleton<Aspire.Hosting.Pipelines.PipelineActivityReporter>();
+        services.AddSingleton(new DistributedApplicationOptions { AssemblyName = "Test" });
+        services.AddSingleton<Microsoft.Extensions.Hosting.IHostApplicationLifetime, TestHostApplicationLifetime>();
+
+        using var sp = services.BuildServiceProvider();
+        var provider = sp.GetRequiredService<BackchannelLoggerProvider>();
+
+        var logger = provider.CreateLogger("TestCategory");
+
+        // Write 1001 entries — the first should be evicted
+        for (var i = 0; i < 1001; i++)
+        {
+            logger.LogInformation("Message {Index}", i);
+        }
+
+        var snapshot = provider.GetReplaySnapshot();
+
+        Assert.Equal(1000, snapshot.Count);
+        // First entry should be "Message 1" (index 0 was evicted)
+        Assert.Equal("Message 1", snapshot[0].Message);
+        Assert.Equal("Message 1000", snapshot[999].Message);
+    }
+
+    [Fact]
+    public void ReplaySnapshot_ReturnsIndependentCopy()
+    {
+        var services = new ServiceCollection();
+        services.AddSingleton<BackchannelLoggerProvider>();
+        services.AddSingleton<ILoggerProvider>(sp => sp.GetRequiredService<BackchannelLoggerProvider>());
+        services.AddSingleton<AppHostRpcTarget>();
+        services.AddLogging();
+
+        services.AddSingleton(Aspire.Hosting.Tests.Utils.ResourceNotificationServiceTestHelpers.Create());
+        services.AddSingleton<Aspire.Hosting.Pipelines.PipelineActivityReporter>();
+        services.AddSingleton(new DistributedApplicationOptions { AssemblyName = "Test" });
+        services.AddSingleton<Microsoft.Extensions.Hosting.IHostApplicationLifetime, TestHostApplicationLifetime>();
+
+        using var sp = services.BuildServiceProvider();
+        var provider = sp.GetRequiredService<BackchannelLoggerProvider>();
+
+        var logger = provider.CreateLogger("TestCategory");
+        logger.LogInformation("Before snapshot");
+
+        var snapshot1 = provider.GetReplaySnapshot();
+
+        logger.LogInformation("After snapshot");
+
+        var snapshot2 = provider.GetReplaySnapshot();
+
+        // First snapshot should not be affected by subsequent writes
+        Assert.Single(snapshot1);
+        Assert.Equal(2, snapshot2.Count);
+    }
+
+    private sealed class TestHostApplicationLifetime : Microsoft.Extensions.Hosting.IHostApplicationLifetime
+    {
+        public CancellationToken ApplicationStarted => CancellationToken.None;
+        public CancellationToken ApplicationStopping => CancellationToken.None;
+        public CancellationToken ApplicationStopped => CancellationToken.None;
+        public void StopApplication() { }
+    }
+}