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

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

@@ -118,13 +118,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();
@@ -456,7 +449,7 @@ private async Task<ResponseArgsBase> ExecuteRequestAsync(RequestArgsBase args, s
             requestFactory,
             invoker,
             filterFactory,
-            new ServerModePerCallOutputDevice(),
+            new ServerModePerCallOutputDevice(this, _messageMonitor),
             [testNodeUpdateProcessor],
             _testFrameworkManager,
             _testSessionManager,

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

@@ -219,16 +219,6 @@ public async Task<ITestHost> BuildAsync(
         // Get the command line options
         ICommandLineOptions commandLineOptions = serviceProvider.GetCommandLineOptions();
 
-        // Register the server mode log forwarder if needed. We follow the console --diagnostic behavior.
-        bool hasServerFlag = commandLineHandler.TryGetOptionArgumentList(PlatformCommandLineProvider.ServerOptionKey, out string[]? protocolName);
-        bool isJsonRpcProtocol = protocolName is null || protocolName.Length == 0 || protocolName[0].Equals(PlatformCommandLineProvider.JsonRpcProtocolName, StringComparison.OrdinalIgnoreCase);
-        if (hasServerFlag && isJsonRpcProtocol)
-        {
-            ServerLoggerForwarderProvider serverLoggerProxy = new(loggingState.LogLevel, serviceProvider);
-            serviceProvider.AddService(serverLoggerProxy);
-            Logging.AddProvider((logLevel, services) => serverLoggerProxy);
-        }
-
         // Build the logger factory.
         ILoggerFactory loggerFactory = await ((LoggingManager)Logging).BuildAsync(serviceProvider, loggingState.LogLevel, systemMonitor);
 
@@ -393,6 +383,9 @@ await LogTestHostCreatedAsync(
             return new TestHostOrchestratorHost(testHostOrchestratorConfiguration, serviceProvider);
         }
 
+        bool hasServerFlag = commandLineHandler.TryGetOptionArgumentList(PlatformCommandLineProvider.ServerOptionKey, out string[]? protocolName);
+        bool isJsonRpcProtocol = protocolName is null || protocolName.Length == 0 || protocolName[0].Equals(PlatformCommandLineProvider.JsonRpcProtocolName, StringComparison.OrdinalIgnoreCase);
+
         // ======= TEST HOST CONTROLLER MODE ======== //
         // Check if we're in the test host or we should check test controllers extensions
         // Environment variable check should not be needed but in case we will rollback to use only env var we will need it.

src/Platform/Microsoft.Testing.Platform/ServerMode/JsonRpc/ServerModePerCallOutputDevice.cs

@@ -1,14 +1,29 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System.Text;
+
 using Microsoft.Testing.Platform.Extensions.OutputDevice;
 using Microsoft.Testing.Platform.Helpers;
+using Microsoft.Testing.Platform.Hosts;
+using Microsoft.Testing.Platform.Logging;
 using Microsoft.Testing.Platform.OutputDevice;
 
 namespace Microsoft.Testing.Platform.ServerMode;
 
 internal class ServerModePerCallOutputDevice : IPlatformOutputDevice
 {
+    private readonly IServerTestHost _serverTestHost;
+    private readonly IAsyncMonitor _asyncMonitor;
+
+    private static readonly string[] NewLineStrings = { "\r\n", "\n" };
+
+    public ServerModePerCallOutputDevice(IServerTestHost serverTestHost, IAsyncMonitor asyncMonitor)
+    {
+        _serverTestHost = serverTestHost;
+        _asyncMonitor = asyncMonitor;
+    }
+
     public string Uid => nameof(ServerModePerCallOutputDevice);
 
     public string Version => AppVersion.DefaultSemVer;
@@ -19,11 +34,72 @@ internal class ServerModePerCallOutputDevice : IPlatformOutputDevice
 
     public Task DisplayAfterSessionEndRunAsync() => Task.CompletedTask;
 
-    public Task DisplayAsync(IOutputDeviceDataProducer producer, IOutputDeviceData data) => Task.CompletedTask;
+    public async Task DisplayAsync(IOutputDeviceDataProducer producer, IOutputDeviceData data)
+    {
+        using (await _asyncMonitor.LockAsync(TimeoutHelper.DefaultHangTimeSpanTimeout))
+        {
+            switch (data)
+            {
+                case FormattedTextOutputDeviceData formattedTextOutputDeviceData:
+                    LogLevel logLevel = formattedTextOutputDeviceData.ForegroundColor is SystemConsoleColor color
+                        ? color.ConsoleColor switch
+                        {
+                            ConsoleColor.Red => LogLevel.Error,
+                            ConsoleColor.Yellow => LogLevel.Warning,
+                            _ => LogLevel.Information,
+                        }
+                        : LogLevel.Information;
+
+                    await LogAsync(logLevel, formattedTextOutputDeviceData.Text, formattedTextOutputDeviceData.Padding);
+                    break;
+
+                case TextOutputDeviceData textOutputDeviceData:
+                    await LogAsync(LogLevel.Information, textOutputDeviceData.Text, padding: null);
+                    break;
+
+                case ExceptionOutputDeviceData exceptionOutputDeviceData:
+                    await LogAsync(LogLevel.Error, exceptionOutputDeviceData.Exception.ToString(), padding: null);
+                    break;
+            }
+        }
+    }
 
     public Task DisplayBannerAsync(string? bannerMessage) => Task.CompletedTask;
 
     public Task DisplayBeforeSessionStartAsync() => Task.CompletedTask;
 
-    public Task<bool> IsEnabledAsync() => Task.FromResult(false);
+    public Task<bool> IsEnabledAsync() => Task.FromResult(true);
+
+    private async Task LogAsync(LogLevel logLevel, string message, int? padding)
+    {
+        message = GetIndentedMessage(message, padding);
+        ServerLogMessage logMessage = new(logLevel, message);
+        await _serverTestHost.PushDataAsync(logMessage);
+    }
+
+    private static string GetIndentedMessage(string message, int? padding)
+    {
+        int paddingValue = padding.GetValueOrDefault();
+        if (paddingValue == 0)
+        {
+            return message;
+        }
+
+        string indent = new(' ', paddingValue);
+
+        if (!message.Contains('\n'))
+        {
+            return indent + message;
+        }
+
+        string[] lines = message.Split(NewLineStrings, StringSplitOptions.None);
+        StringBuilder builder = new();
+        foreach (string line in lines)
+        {
+            builder.Append(indent);
+            builder.AppendLine(line);
+        }
+
+        return builder.ToString();
+    }
 }

test/IntegrationTests/MSTest.Acceptance.IntegrationTests/ServerModeTests.cs

@@ -40,7 +40,7 @@ public async Task DiscoverAndRun(string tfm)
         await Task.WhenAll(discoveryListener.WaitCompletion(), runListener.WaitCompletion());
         Assert.AreEqual(1, discoveryCollector.TestNodeUpdates.Count(x => x.Node.NodeType == "action"), $"Wrong number of discovery");
         Assert.AreEqual(2, runCollector.TestNodeUpdates.Count, $"Wrong number of updates");
-        Assert.IsFalse(logs.IsEmpty, $"Logs are empty");
+        Assert.IsTrue(logs.IsEmpty, $"Logs are not empty");
         Assert.IsFalse(telemetry.IsEmpty, $"telemetry is empty");
         await jsonClient.Exit();
         Assert.AreEqual(0, await jsonClient.WaitServerProcessExit());