Only push output device messages to Test Explorer, don't push logs

src/Platform/Microsoft.Testing.Platform/CommandLine/ICommandLineHandler.cs

@@ -10,5 +10,5 @@ internal interface ICommandLineHandler
 {
     bool IsHelpInvoked();
 
-    Task PrintHelpAsync(IPlatformOutputDevice platformOutputDevice, IReadOnlyList<ITool>? availableTools = null);
+    Task PrintHelpAsync(IOutputDevice outputDevice, IReadOnlyList<ITool>? availableTools = null);
 }

src/Platform/Microsoft.Testing.Platform/Hosts/CommonTestHost.cs

@@ -69,7 +69,11 @@ public async Task<int> RunAsync()
             await DisposeServiceProviderAsync(ServiceProvider, isProcessShutdown: true);
             await DisposeHelper.DisposeAsync(ServiceProvider.GetService<FileLoggerProvider>());
             await DisposeHelper.DisposeAsync(PushOnlyProtocol);
-            await DisposeHelper.DisposeAsync(ServiceProvider.GetTestApplicationCancellationTokenSource());
+
+            // This is intentional that we are not disposing the CTS.
+            // An unobserved task exception could be raised after the dispose, and we want to use OutputDevice there
+            // which needs CTS down the path.
+            // await DisposeHelper.DisposeAsync(ServiceProvider.GetTestApplicationCancellationTokenSource());
         }
 
         if (testApplicationCancellationToken.IsCancellationRequested)
@@ -119,7 +123,7 @@ private async Task<int> RunTestAppAsync(CancellationToken testApplicationCancell
 
     protected abstract Task<int> InternalRunAsync();
 
-    protected static async Task ExecuteRequestAsync(IPlatformOutputDevice outputDevice, ITestSessionContext testSessionInfo,
+    protected static async Task ExecuteRequestAsync(ProxyOutputDevice outputDevice, ITestSessionContext testSessionInfo,
         ServiceProvider serviceProvider, BaseMessageBus baseMessageBus, ITestFramework testFramework, TestHost.ClientInfo client)
     {
         CancellationToken testSessionCancellationToken = serviceProvider.GetTestSessionContext().CancellationToken;
@@ -142,26 +146,26 @@ protected static async Task ExecuteRequestAsync(IPlatformOutputDevice outputDevi
         await DisplayAfterSessionEndRunAsync(outputDevice, testSessionInfo, testSessionCancellationToken);
     }
 
-    private static async Task DisplayBeforeSessionStartAsync(IPlatformOutputDevice outputDevice, ITestSessionContext sessionInfo, CancellationToken cancellationToken)
+    private static async Task DisplayBeforeSessionStartAsync(ProxyOutputDevice outputDevice, ITestSessionContext sessionInfo, CancellationToken cancellationToken)
     {
         // Display before session start
         await outputDevice.DisplayBeforeSessionStartAsync();
 
-        if (outputDevice is ITestSessionLifetimeHandler testSessionLifetimeHandler)
+        if (outputDevice.OriginalOutputDevice is ITestSessionLifetimeHandler testSessionLifetimeHandler)
         {
             await testSessionLifetimeHandler.OnTestSessionStartingAsync(
                 sessionInfo.SessionId,
                 cancellationToken);
         }
     }
 
-    private static async Task DisplayAfterSessionEndRunAsync(IPlatformOutputDevice outputDevice, ITestSessionContext sessionInfo, CancellationToken cancellationToken)
+    private static async Task DisplayAfterSessionEndRunAsync(ProxyOutputDevice outputDevice, ITestSessionContext sessionInfo, CancellationToken cancellationToken)
     {
         // Display after session end
         await outputDevice.DisplayAfterSessionEndRunAsync();
 
         // We want to ensure that the output service is the last one to run
-        if (outputDevice is ITestSessionLifetimeHandler testSessionLifetimeHandlerFinishing)
+        if (outputDevice.OriginalOutputDevice is ITestSessionLifetimeHandler testSessionLifetimeHandlerFinishing)
         {
             await testSessionLifetimeHandlerFinishing.OnTestSessionFinishingAsync(
                 sessionInfo.SessionId,

src/Platform/Microsoft.Testing.Platform/Hosts/ConsoleTestHost.cs

@@ -10,6 +10,7 @@
 using Microsoft.Testing.Platform.Helpers;
 using Microsoft.Testing.Platform.Logging;
 using Microsoft.Testing.Platform.Messages;
+using Microsoft.Testing.Platform.OutputDevice;
 using Microsoft.Testing.Platform.Requests;
 using Microsoft.Testing.Platform.Services;
 using Microsoft.Testing.Platform.Telemetry;
@@ -83,7 +84,7 @@ protected override async Task<int> InternalRunAsync()
             ITestSessionContext testSessionInfo = ServiceProvider.GetTestSessionContext();
 
             await ExecuteRequestAsync(
-                ServiceProvider.GetPlatformOutputDevice(),
+                (ProxyOutputDevice)ServiceProvider.GetOutputDevice(),
                 testSessionInfo,
                 ServiceProvider,
                 ServiceProvider.GetBaseMessageBus(),

src/Platform/Microsoft.Testing.Platform/Hosts/ServerTestHost.cs

@@ -3,24 +3,28 @@
 
 using System.Collections.Concurrent;
 using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
 using System.Net.Sockets;
 
 using Microsoft.Testing.Internal.Framework;
 using Microsoft.Testing.Platform.Capabilities.TestFramework;
 using Microsoft.Testing.Platform.Extensions.Messages;
+using Microsoft.Testing.Platform.Extensions.OutputDevice;
 using Microsoft.Testing.Platform.Extensions.TestFramework;
 using Microsoft.Testing.Platform.Helpers;
 using Microsoft.Testing.Platform.Logging;
 using Microsoft.Testing.Platform.Messages;
+using Microsoft.Testing.Platform.OutputDevice;
 using Microsoft.Testing.Platform.Requests;
+using Microsoft.Testing.Platform.Resources;
 using Microsoft.Testing.Platform.ServerMode;
 using Microsoft.Testing.Platform.Services;
 using Microsoft.Testing.Platform.Telemetry;
 using Microsoft.Testing.Platform.TestHost;
 
 namespace Microsoft.Testing.Platform.Hosts;
 
-internal sealed partial class ServerTestHost : CommonTestHost, IServerTestHost, IDisposable
+internal sealed partial class ServerTestHost : CommonTestHost, IServerTestHost, IDisposable, IOutputDeviceDataProducer
 {
     public const string ProtocolVersion = "1.0.0";
     private readonly Func<TestFrameworkBuilderData, Task<ITestFramework>> _buildTestFrameworkAsync;
@@ -93,13 +97,36 @@ public ServerTestHost(
 
     protected override bool RunTestApplicationLifeCycleCallbacks => true;
 
+    public string Uid => nameof(ServerTestHost);
+
+    public string Version => AppVersion.DefaultSemVer;
+
+    public string DisplayName => PlatformResources.ServerTestHostDisplayName;
+
+    public string Description => PlatformResources.ServerTestHostDescription;
+
     private void OnCurrentDomainUnhandledException(object sender, UnhandledExceptionEventArgs e)
-        => _logger.LogWarning($"[ServerTestHost.OnCurrentDomainUnhandledException] {e.ExceptionObject}{_environment.NewLine}IsTerminating: {e.IsTerminating}");
+    {
+        _logger.LogWarning($"[ServerTestHost.OnCurrentDomainUnhandledException] {e.ExceptionObject}{_environment.NewLine}IsTerminating: {e.IsTerminating}");
+
+        // Looks like nothing in this message to really be localized?
+        // All are class names, method names, property names, and placeholders. So none is localizable?
+        ServiceProvider.GetOutputDevice().DisplayAsync(
+            this,
+            new WarningMessageOutputDeviceData(
+                $"[ServerTestHost.OnCurrentDomainUnhandledException] {e.ExceptionObject}{_environment.NewLine}IsTerminating: {e.IsTerminating}"))
+            .GetAwaiter().GetResult();
+    }
 
     private void OnTaskSchedulerUnobservedTaskException(object? sender, UnobservedTaskExceptionEventArgs e)
     {
         e.SetObserved();
         _logger.LogWarning($"[ServerTestHost.OnTaskSchedulerUnobservedTaskException] Unhandled exception: {e.Exception}");
+
+        // Looks like nothing in this message to really be localized?
+        // All are class names, method names, property names, and placeholders. So none is localizable?
+        ServiceProvider.GetOutputDevice().DisplayAsync(this, new WarningMessageOutputDeviceData(PlatformResources.UnobservedTaskExceptionWarningMessage))
+            .GetAwaiter().GetResult();
     }
 
     [MemberNotNull(nameof(_messageHandler))]
@@ -118,13 +145,6 @@ protected override async Task<int> InternalRunAsync()
             await _logger.LogDebugAsync("Starting server mode");
             _messageHandler = await _messageHandlerFactory.CreateMessageHandlerAsync(_testApplicationCancellationTokenSource.CancellationToken);
 
-            // Initialize the ServerLoggerForwarderProvider, it can be null if diagnostic is disabled.
-            ServerLoggerForwarderProvider? serviceLoggerForwarder = ServiceProvider.GetService<ServerLoggerForwarderProvider>();
-            if (serviceLoggerForwarder is not null)
-            {
-                await serviceLoggerForwarder.InitializeAsync(this);
-            }
-
             await HandleMessagesAsync();
 
             (_messageHandler as IDisposable)?.Dispose();
@@ -268,7 +288,14 @@ private async Task HandleNotificationAsync(NotificationMessage message, Cancella
                         Exception? cancellationException = rpcState.CancelRequest();
                         if (cancellationException is null)
                         {
+                            // This is intentionally not using PlatformResources.ExceptionDuringCancellationWarningMessage
+                            // It's meant for troubleshooting and shouldn't be localized.
+                            // The localized message that is user-facing will be displayed in the DisplayAsync call next line.
                             await _logger.LogWarningAsync($"Exception during the cancellation of request id '{args.CancelRequestId}'");
+
+                            await ServiceProvider.GetOutputDevice().DisplayAsync(
+                                this,
+                                new WarningMessageOutputDeviceData(string.Format(CultureInfo.InvariantCulture, PlatformResources.ExceptionDuringCancellationWarningMessage, args.CancelRequestId)));
                         }
                     }
 
@@ -450,13 +477,16 @@ private async Task<ResponseArgsBase> ExecuteRequestAsync(RequestArgsBase args, s
 
         DateTimeOffset adapterLoadStart = _clock.UtcNow;
 
+        ProxyOutputDevice outputDevice = ServiceProvider.GetRequiredService<ProxyOutputDevice>();
+        await outputDevice.InitializeAsync(this);
+
         // Build the per request adapter
-        ITestFramework perRequestTestFramework = await _buildTestFrameworkAsync(new(
+        ITestFramework perRequestTestFramework = await _buildTestFrameworkAsync(new TestFrameworkBuilderData(
             perRequestServiceProvider,
             requestFactory,
             invoker,
             filterFactory,
-            new ServerModePerCallOutputDevice(),
+            outputDevice.OriginalOutputDevice,
             [testNodeUpdateProcessor],
             _testFrameworkManager,
             _testSessionManager,
@@ -475,7 +505,7 @@ private async Task<ResponseArgsBase> ExecuteRequestAsync(RequestArgsBase args, s
 
             // Execute the request
             await ExecuteRequestAsync(
-                perRequestServiceProvider.GetPlatformOutputDevice(),
+                outputDevice,
                 perRequestServiceProvider.GetTestSessionContext(),
                 perRequestServiceProvider,
                 perRequestServiceProvider.GetBaseMessageBus(),
@@ -632,6 +662,11 @@ public void Dispose()
     {
         // Note: The lifetime of the _reader/_writer should be currently handled by the RunAsync()
         // We could consider creating a stateful engine that has the lifetime == server connection UP.
+        if (!ServiceProvider.GetUnhandledExceptionsPolicy().FastFailOnFailure)
+        {
+            AppDomain.CurrentDomain.UnhandledException -= OnCurrentDomainUnhandledException;
+            TaskScheduler.UnobservedTaskException -= OnTaskSchedulerUnobservedTaskException;
+        }
     }
 
     internal async Task SendTestUpdateCompleteAsync(Guid runId)
@@ -700,6 +735,8 @@ await SendMessageAsync(
         }
     }
 
+    public Task<bool> IsEnabledAsync() => throw new NotImplementedException();
+
     private sealed class RpcInvocationState : IDisposable
     {
         private readonly Lock _cancellationTokenSourceLock = new();