Add TestingPlatformTrace and MSBuild --verbosity option to dotnet test (#46909)

mariam-abdulla · web-flow · commit fb527ca53046 · 2025-02-18T13:13:24.000Z
diff --git a/src/Cli/dotnet/commands/dotnet-test/CliConstants.cs b/src/Cli/dotnet/commands/dotnet-test/CliConstants.cs
@@ -46,6 +46,8 @@ internal static class CliConstants
         public const string DLLExtension = ".dll";
 
         public const string MTPTarget = "_MTPBuild";
+
+        public const string TestTraceLoggingEnvVar = "DOTNET_CLI_TEST_TRACEFILE";
     }
 
     internal static class TestStates
diff --git a/src/Cli/dotnet/commands/dotnet-test/Logger.cs b/src/Cli/dotnet/commands/dotnet-test/Logger.cs
@@ -0,0 +1,43 @@
+﻿// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.DotNet.Cli;
+
+namespace Microsoft.DotNet.Tools.Test
+{
+    internal static class Logger
+    {
+        public static bool TraceEnabled { get; private set; }
+        private static readonly string _traceFilePath;
+        private static readonly object _lock = new();
+
+        static Logger()
+        {
+            _traceFilePath = Environment.GetEnvironmentVariable(CliConstants.TestTraceLoggingEnvVar);
+            TraceEnabled = !string.IsNullOrEmpty(_traceFilePath);
+        }
+
+        public static void LogTrace(Func<string> messageLog)
+        {
+            if (!TraceEnabled)
+            {
+                return;
+            }
+
+            try
+            {
+                string message = $"[dotnet test - {DateTimeOffset.UtcNow:MM/dd/yyyy HH:mm:ss.fff}]{messageLog()}";
+
+                lock (_lock)
+                {
+                    using StreamWriter logFile = File.AppendText(_traceFilePath);
+                    logFile.WriteLine(message);
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"[dotnet test - {DateTimeOffset.UtcNow:MM/dd/yyyy HH:mm:ss.fff}]{ex}");
+            }
+        }
+    }
+}
diff --git a/src/Cli/dotnet/commands/dotnet-test/MSBuildHandler.cs b/src/Cli/dotnet/commands/dotnet-test/MSBuildHandler.cs
@@ -135,23 +135,19 @@ public bool EnqueueTestApplications()
 
         private void LogProjectProperties(IEnumerable<Module> modules)
         {
-            if (!VSTestTrace.TraceEnabled)
+            if (!Logger.TraceEnabled)
             {
                 return;
             }
 
             foreach (var module in modules)
             {
-                Console.WriteLine();
-
-                VSTestTrace.SafeWriteTrace(() => $"{ProjectProperties.ProjectFullPath}: {module.ProjectFullPath}");
-                VSTestTrace.SafeWriteTrace(() => $"{ProjectProperties.IsTestProject}: {module.IsTestProject}");
-                VSTestTrace.SafeWriteTrace(() => $"{ProjectProperties.IsTestingPlatformApplication}: {module.IsTestingPlatformApplication}");
-                VSTestTrace.SafeWriteTrace(() => $"{ProjectProperties.TargetFramework}: {module.TargetFramework}");
-                VSTestTrace.SafeWriteTrace(() => $"{ProjectProperties.TargetPath}: {module.TargetPath}");
-                VSTestTrace.SafeWriteTrace(() => $"{ProjectProperties.RunSettingsFilePath}: {module.RunSettingsFilePath}");
-
-                Console.WriteLine();
+                Logger.LogTrace(() => $"{ProjectProperties.ProjectFullPath}: {module.ProjectFullPath}");
+                Logger.LogTrace(() => $"{ProjectProperties.IsTestProject}: {module.IsTestProject}");
+                Logger.LogTrace(() => $"{ProjectProperties.IsTestingPlatformApplication}: {module.IsTestingPlatformApplication}");
+                Logger.LogTrace(() => $"{ProjectProperties.TargetFramework}: {module.TargetFramework}");
+                Logger.LogTrace(() => $"{ProjectProperties.TargetPath}: {module.TargetPath}");
+                Logger.LogTrace(() => $"{ProjectProperties.RunSettingsFilePath}: {module.RunSettingsFilePath}");
             }
         }
 
diff --git a/src/Cli/dotnet/commands/dotnet-test/MSBuildUtility.cs b/src/Cli/dotnet/commands/dotnet-test/MSBuildUtility.cs
@@ -69,6 +69,7 @@ public static BuildOptions GetBuildOptions(ParseResult parseResult, int degreeOf
                 buildProperties,
                 parseResult.GetValue(CommonOptions.NoRestoreOption),
                 parseResult.GetValue(TestingPlatformOptions.NoBuildOption),
+                parseResult.HasOption(CommonOptions.VerbosityOption) ? parseResult.GetValue(CommonOptions.VerbosityOption) : null,
                 degreeOfParallelism,
                 unmatchedTokens,
                 msbuildArgs);
@@ -110,6 +111,11 @@ private static bool BuildOrRestoreProjectOrSolution(string filePath, BuildOption
         {
             List<string> msbuildArgs = [.. buildOptions.MSBuildArgs];
 
+            if (buildOptions.Verbosity is null)
+            {
+                msbuildArgs.Add($"-verbosity:quiet");
+            }
+
             msbuildArgs.Add(filePath);
             msbuildArgs.Add($"-target:{CliConstants.MTPTarget}");
 
diff --git a/src/Cli/dotnet/commands/dotnet-test/Options.cs b/src/Cli/dotnet/commands/dotnet-test/Options.cs
@@ -9,5 +9,5 @@ internal record PathOptions(string ProjectPath, string SolutionPath, string Dire
 
     internal record BuildProperties(string Configuration, string RuntimeIdentifier, string TargetFramework);
 
-    internal record BuildOptions(PathOptions PathOptions, BuildProperties BuildProperties, bool HasNoRestore, bool HasNoBuild, int DegreeOfParallelism, List<string> UnmatchedTokens, IEnumerable<string> MSBuildArgs);
+    internal record BuildOptions(PathOptions PathOptions, BuildProperties BuildProperties, bool HasNoRestore, bool HasNoBuild, VerbosityOptions? Verbosity, int DegreeOfParallelism, List<string> UnmatchedTokens, IEnumerable<string> MSBuildArgs);
 }
diff --git a/src/Cli/dotnet/commands/dotnet-test/TestApplicationEventHandlers.cs b/src/Cli/dotnet/commands/dotnet-test/TestApplicationEventHandlers.cs
@@ -31,11 +31,11 @@ public void OnHandshakeReceived(object sender, HandshakeArgs args)
             _executions[testApplication] = appInfo;
             _output.AssemblyRunStarted(appInfo.ModulePath, appInfo.TargetFramework, appInfo.Architecture, appInfo.ExecutionId);
 
-            if (!VSTestTrace.TraceEnabled) return;
+            if (!Logger.TraceEnabled) return;
 
             foreach (var property in args.Handshake.Properties)
             {
-                VSTestTrace.SafeWriteTrace(() => $"{GetHandshakePropertyName(property.Key)}: {property.Value}");
+                Logger.LogTrace(() => $"{GetHandshakePropertyName(property.Key)}: {property.Value}");
             }
         }
 
@@ -65,12 +65,12 @@ public void OnDiscoveredTestsReceived(object sender, DiscoveredTestEventArgs arg
                         test.Uid);
             }
 
-            if (!VSTestTrace.TraceEnabled) return;
+            if (!Logger.TraceEnabled) return;
 
-            VSTestTrace.SafeWriteTrace(() => $"DiscoveredTests Execution Id: {args.ExecutionId}");
+            Logger.LogTrace(() => $"DiscoveredTests Execution Id: {args.ExecutionId}");
             foreach (var discoveredTestMessage in args.DiscoveredTests)
             {
-                VSTestTrace.SafeWriteTrace(() => $"DiscoveredTest: {discoveredTestMessage.Uid}, {discoveredTestMessage.DisplayName}");
+                Logger.LogTrace(() => $"DiscoveredTest: {discoveredTestMessage.Uid}, {discoveredTestMessage.DisplayName}");
             }
         }
 
@@ -108,20 +108,20 @@ public void OnTestResultsReceived(object sender, TestResultEventArgs args)
                     errorOutput: null);
             }
 
-            if (!VSTestTrace.TraceEnabled) return;
+            if (!Logger.TraceEnabled) return;
 
-            VSTestTrace.SafeWriteTrace(() => $"TestResults Execution Id: {args.ExecutionId}");
+            Logger.LogTrace(() => $"TestResults Execution Id: {args.ExecutionId}");
 
             foreach (SuccessfulTestResult successfulTestResult in args.SuccessfulTestResults)
             {
-                VSTestTrace.SafeWriteTrace(() => $"SuccessfulTestResult: {successfulTestResult.Uid}, {successfulTestResult.DisplayName}, " +
+                Logger.LogTrace(() => $"SuccessfulTestResult: {successfulTestResult.Uid}, {successfulTestResult.DisplayName}, " +
                 $"{successfulTestResult.State}, {successfulTestResult.Duration}, {successfulTestResult.Reason}, {successfulTestResult.StandardOutput}," +
                 $"{successfulTestResult.ErrorOutput}, {successfulTestResult.SessionUid}");
             }
 
             foreach (FailedTestResult failedTestResult in args.FailedTestResults)
             {
-                VSTestTrace.SafeWriteTrace(() => $"FailedTestResult: {failedTestResult.Uid}, {failedTestResult.DisplayName}, " +
+                Logger.LogTrace(() => $"FailedTestResult: {failedTestResult.Uid}, {failedTestResult.DisplayName}, " +
                 $"{failedTestResult.State}, {failedTestResult.Duration}, {failedTestResult.Reason}, {string.Join(", ", failedTestResult.Exceptions?.Select(e => $"{e.ErrorMessage}, {e.ErrorType}, {e.StackTrace}"))}" +
                 $"{failedTestResult.StandardOutput}, {failedTestResult.ErrorOutput}, {failedTestResult.SessionUid}");
             }
@@ -140,31 +140,31 @@ public void OnFileArtifactsReceived(object sender, FileArtifactEventArgs args)
                     artifact.TestDisplayName, artifact.FullPath);
             }
 
-            if (!VSTestTrace.TraceEnabled) return;
+            if (!Logger.TraceEnabled) return;
 
-            VSTestTrace.SafeWriteTrace(() => $"FileArtifactMessages Execution Id: {args.ExecutionId}");
+            Logger.LogTrace(() => $"FileArtifactMessages Execution Id: {args.ExecutionId}");
 
             foreach (FileArtifact fileArtifactMessage in args.FileArtifacts)
             {
-                VSTestTrace.SafeWriteTrace(() => $"FileArtifact: {fileArtifactMessage.FullPath}, {fileArtifactMessage.DisplayName}, " +
+                Logger.LogTrace(() => $"FileArtifact: {fileArtifactMessage.FullPath}, {fileArtifactMessage.DisplayName}, " +
                 $"{fileArtifactMessage.Description}, {fileArtifactMessage.TestUid}, {fileArtifactMessage.TestDisplayName}, " +
                 $"{fileArtifactMessage.SessionUid}");
             }
         }
 
         public void OnSessionEventReceived(object sender, SessionEventArgs args)
         {
-            if (!VSTestTrace.TraceEnabled) return;
+            if (!Logger.TraceEnabled) return;
 
             var sessionEvent = args.SessionEvent;
-            VSTestTrace.SafeWriteTrace(() => $"TestSessionEvent: {sessionEvent.SessionType}, {sessionEvent.SessionUid}, {sessionEvent.ExecutionId}");
+            Logger.LogTrace(() => $"TestSessionEvent: {sessionEvent.SessionType}, {sessionEvent.SessionUid}, {sessionEvent.ExecutionId}");
         }
 
         public void OnErrorReceived(object sender, ErrorEventArgs args)
         {
-            if (!VSTestTrace.TraceEnabled) return;
+            if (!Logger.TraceEnabled) return;
 
-            VSTestTrace.SafeWriteTrace(() => args.ErrorMessage);
+            Logger.LogTrace(() => args.ErrorMessage);
         }
 
         public void OnTestProcessExited(object sender, TestProcessExitEventArgs args)
@@ -180,21 +180,21 @@ public void OnTestProcessExited(object sender, TestProcessExitEventArgs args)
                 _output.AssemblyRunCompleted(testApplication.Module.TargetPath ?? testApplication.Module.ProjectFullPath, testApplication.Module.TargetFramework, architecture: null, null, args.ExitCode, string.Join(Environment.NewLine, args.OutputData), string.Join(Environment.NewLine, args.ErrorData));
             }
 
-            if (!VSTestTrace.TraceEnabled) return;
+            if (!Logger.TraceEnabled) return;
 
             if (args.ExitCode != ExitCode.Success)
             {
-                VSTestTrace.SafeWriteTrace(() => $"Test Process exited with non-zero exit code: {args.ExitCode}");
+                Logger.LogTrace(() => $"Test Process exited with non-zero exit code: {args.ExitCode}");
             }
 
             if (args.OutputData.Count > 0)
             {
-                VSTestTrace.SafeWriteTrace(() => $"Output Data: {string.Join("\n", args.OutputData)}");
+                Logger.LogTrace(() => $"Output Data: {string.Join("\n", args.OutputData)}");
             }
 
             if (args.ErrorData.Count > 0)
             {
-                VSTestTrace.SafeWriteTrace(() => $"Error Data: {string.Join("\n", args.ErrorData)}");
+                Logger.LogTrace(() => $"Error Data: {string.Join("\n", args.ErrorData)}");
             }
         }
 
diff --git a/src/Cli/dotnet/commands/dotnet-test/TestCommandParser.cs b/src/Cli/dotnet/commands/dotnet-test/TestCommandParser.cs
@@ -231,6 +231,7 @@ private static CliCommand GetTestingPlatformCliCommand()
             command.Options.Add(TestingPlatformOptions.FrameworkOption);
             command.Options.Add(CommonOptions.OperatingSystemOption);
             command.Options.Add(CommonOptions.RuntimeOption);
+            command.Options.Add(CommonOptions.VerbosityOption);
             command.Options.Add(CommonOptions.NoRestoreOption);
             command.Options.Add(TestingPlatformOptions.NoBuildOption);
             command.Options.Add(TestingPlatformOptions.NoAnsiOption);
diff --git a/src/Cli/dotnet/commands/dotnet-test/TestModulesFilterHandler.cs b/src/Cli/dotnet/commands/dotnet-test/TestModulesFilterHandler.cs
@@ -10,7 +10,6 @@ namespace Microsoft.DotNet.Cli
     internal sealed class TestModulesFilterHandler
     {
         private readonly List<string> _args;
-
         private readonly TestApplicationActionQueue _actionQueue;
 
         public TestModulesFilterHandler(List<string> args, TestApplicationActionQueue actionQueue)
@@ -44,7 +43,7 @@ public bool RunWithTestModulesFilter(ParseResult parseResult)
             // If no matches were found, we simply return
             if (!testModulePaths.Any())
             {
-                VSTestTrace.SafeWriteTrace(() => $"No test modules found for the given test module pattern: {testModules} with root directory: {rootDirectory}");
+                Logger.LogTrace(() => $"No test modules found for the given test module pattern: {testModules} with root directory: {rootDirectory}");
                 return false;
             }
 
diff --git a/test/dotnet-test.Tests/GivenDotnetTestBuildsAndRunsTestsWithDifferentOptions.cs b/test/dotnet-test.Tests/GivenDotnetTestBuildsAndRunsTestsWithDifferentOptions.cs
@@ -500,5 +500,24 @@ public void RunMultiTFMsProjectSolutionWithFrameworkOption_ShouldReturnExitCodeG
             result.ExitCode.Should().Be(ExitCode.GenericFailure);
         }
 
+        [InlineData(TestingConstants.Debug)]
+        [InlineData(TestingConstants.Release)]
+        [Theory]
+        public void RunWithTraceFileLogging_ShouldReturnExitCodeGenericFailure(string configuration)
+        {
+            TestAsset testInstance = _testAssetsManager.CopyTestAsset("MultiTestProjectSolutionWithTests", Guid.NewGuid().ToString()).WithSource();
+
+            string traceFile = "logs.txt";
+            CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
+                                    .WithWorkingDirectory(testInstance.Path)
+                                    .WithEnvironmentVariable(CliConstants.TestTraceLoggingEnvVar, traceFile)
+                                    .WithEnableTestingPlatform()
+                                    .Execute(TestingPlatformOptions.ConfigurationOption.Name, configuration);
+
+            Assert.True(File.Exists(Path.Combine(testInstance.Path, traceFile)), "Trace file should exist after test execution.");
+
+            result.ExitCode.Should().Be(ExitCode.GenericFailure);
+        }
+
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -46,6 +46,8 @@ internal static class CliConstants`
`46`	`46`	`public const string DLLExtension = ".dll";`
`47`	`47`
`48`	`48`	`public const string MTPTarget = "_MTPBuild";`
	`49`	`+`
	`50`	`+ public const string TestTraceLoggingEnvVar = "DOTNET_CLI_TEST_TRACEFILE";`
`49`	`51`	`}`
`50`	`52`
`51`	`53`	`internal static class TestStates`
Original file line number	Diff line number	Diff line change
`@@ -135,23 +135,19 @@ public bool EnqueueTestApplications()`
`135`	`135`
`136`	`136`	`private void LogProjectProperties(IEnumerable<Module> modules)`
`137`	`137`	`{`
`138`		`- if (!VSTestTrace.TraceEnabled)`
	`138`	`+ if (!Logger.TraceEnabled)`
`139`	`139`	`{`
`140`	`140`	`return;`
`141`	`141`	`}`
`142`	`142`
`143`	`143`	`foreach (var module in modules)`
`144`	`144`	`{`
`145`		`- Console.WriteLine();`
`146`		`-`
`147`		`- VSTestTrace.SafeWriteTrace(() => $"{ProjectProperties.ProjectFullPath}: {module.ProjectFullPath}");`
`148`		`- VSTestTrace.SafeWriteTrace(() => $"{ProjectProperties.IsTestProject}: {module.IsTestProject}");`
`149`		`- VSTestTrace.SafeWriteTrace(() => $"{ProjectProperties.IsTestingPlatformApplication}: {module.IsTestingPlatformApplication}");`
`150`		`- VSTestTrace.SafeWriteTrace(() => $"{ProjectProperties.TargetFramework}: {module.TargetFramework}");`
`151`		`- VSTestTrace.SafeWriteTrace(() => $"{ProjectProperties.TargetPath}: {module.TargetPath}");`
`152`		`- VSTestTrace.SafeWriteTrace(() => $"{ProjectProperties.RunSettingsFilePath}: {module.RunSettingsFilePath}");`
`153`		`-`
`154`		`- Console.WriteLine();`
	`145`	`+ Logger.LogTrace(() => $"{ProjectProperties.ProjectFullPath}: {module.ProjectFullPath}");`
	`146`	`+ Logger.LogTrace(() => $"{ProjectProperties.IsTestProject}: {module.IsTestProject}");`
	`147`	`+ Logger.LogTrace(() => $"{ProjectProperties.IsTestingPlatformApplication}: {module.IsTestingPlatformApplication}");`
	`148`	`+ Logger.LogTrace(() => $"{ProjectProperties.TargetFramework}: {module.TargetFramework}");`
	`149`	`+ Logger.LogTrace(() => $"{ProjectProperties.TargetPath}: {module.TargetPath}");`
	`150`	`+ Logger.LogTrace(() => $"{ProjectProperties.RunSettingsFilePath}: {module.RunSettingsFilePath}");`
`155`	`151`	`}`
`156`	`152`	`}`
`157`	`153`
Original file line number	Diff line number	Diff line change
`@@ -9,5 +9,5 @@ internal record PathOptions(string ProjectPath, string SolutionPath, string Dire`
`9`	`9`
`10`	`10`	`internal record BuildProperties(string Configuration, string RuntimeIdentifier, string TargetFramework);`
`11`	`11`
`12`		`- internal record BuildOptions(PathOptions PathOptions, BuildProperties BuildProperties, bool HasNoRestore, bool HasNoBuild, int DegreeOfParallelism, List<string> UnmatchedTokens, IEnumerable<string> MSBuildArgs);`
	`12`	`+ internal record BuildOptions(PathOptions PathOptions, BuildProperties BuildProperties, bool HasNoRestore, bool HasNoBuild, VerbosityOptions? Verbosity, int DegreeOfParallelism, List<string> UnmatchedTokens, IEnumerable<string> MSBuildArgs);`
`13`	`13`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,11 +31,11 @@ public void OnHandshakeReceived(object sender, HandshakeArgs args)`
`31`	`31`	`_executions[testApplication] = appInfo;`
`32`	`32`	`_output.AssemblyRunStarted(appInfo.ModulePath, appInfo.TargetFramework, appInfo.Architecture, appInfo.ExecutionId);`
`33`	`33`
`34`		`- if (!VSTestTrace.TraceEnabled) return;`
	`34`	`+ if (!Logger.TraceEnabled) return;`
`35`	`35`
`36`	`36`	`foreach (var property in args.Handshake.Properties)`
`37`	`37`	`{`
`38`		`- VSTestTrace.SafeWriteTrace(() => $"{GetHandshakePropertyName(property.Key)}: {property.Value}");`
	`38`	`+ Logger.LogTrace(() => $"{GetHandshakePropertyName(property.Key)}: {property.Value}");`
`39`	`39`	`}`
`40`	`40`	`}`
`41`	`41`
`@@ -65,12 +65,12 @@ public void OnDiscoveredTestsReceived(object sender, DiscoveredTestEventArgs arg`
`65`	`65`	`test.Uid);`
`66`	`66`	`}`
`67`	`67`
`68`		`- if (!VSTestTrace.TraceEnabled) return;`
	`68`	`+ if (!Logger.TraceEnabled) return;`
`69`	`69`
`70`		`- VSTestTrace.SafeWriteTrace(() => $"DiscoveredTests Execution Id: {args.ExecutionId}");`
	`70`	`+ Logger.LogTrace(() => $"DiscoveredTests Execution Id: {args.ExecutionId}");`
`71`	`71`	`foreach (var discoveredTestMessage in args.DiscoveredTests)`
`72`	`72`	`{`
`73`		`- VSTestTrace.SafeWriteTrace(() => $"DiscoveredTest: {discoveredTestMessage.Uid}, {discoveredTestMessage.DisplayName}");`
	`73`	`+ Logger.LogTrace(() => $"DiscoveredTest: {discoveredTestMessage.Uid}, {discoveredTestMessage.DisplayName}");`
`74`	`74`	`}`
`75`	`75`	`}`
`76`	`76`
`@@ -108,20 +108,20 @@ public void OnTestResultsReceived(object sender, TestResultEventArgs args)`
`108`	`108`	`errorOutput: null);`
`109`	`109`	`}`
`110`	`110`
`111`		`- if (!VSTestTrace.TraceEnabled) return;`
	`111`	`+ if (!Logger.TraceEnabled) return;`
`112`	`112`
`113`		`- VSTestTrace.SafeWriteTrace(() => $"TestResults Execution Id: {args.ExecutionId}");`
	`113`	`+ Logger.LogTrace(() => $"TestResults Execution Id: {args.ExecutionId}");`
`114`	`114`
`115`	`115`	`foreach (SuccessfulTestResult successfulTestResult in args.SuccessfulTestResults)`
`116`	`116`	`{`
`117`		`- VSTestTrace.SafeWriteTrace(() => $"SuccessfulTestResult: {successfulTestResult.Uid}, {successfulTestResult.DisplayName}, " +`
	`117`	`+ Logger.LogTrace(() => $"SuccessfulTestResult: {successfulTestResult.Uid}, {successfulTestResult.DisplayName}, " +`
`118`	`118`	`$"{successfulTestResult.State}, {successfulTestResult.Duration}, {successfulTestResult.Reason}, {successfulTestResult.StandardOutput}," +`
`119`	`119`	`$"{successfulTestResult.ErrorOutput}, {successfulTestResult.SessionUid}");`
`120`	`120`	`}`
`121`	`121`
`122`	`122`	`foreach (FailedTestResult failedTestResult in args.FailedTestResults)`
`123`	`123`	`{`
`124`		`- VSTestTrace.SafeWriteTrace(() => $"FailedTestResult: {failedTestResult.Uid}, {failedTestResult.DisplayName}, " +`
	`124`	`+ Logger.LogTrace(() => $"FailedTestResult: {failedTestResult.Uid}, {failedTestResult.DisplayName}, " +`
`125`	`125`	`$"{failedTestResult.State}, {failedTestResult.Duration}, {failedTestResult.Reason}, {string.Join(", ", failedTestResult.Exceptions?.Select(e => $"{e.ErrorMessage}, {e.ErrorType}, {e.StackTrace}"))}" +`
`126`	`126`	`$"{failedTestResult.StandardOutput}, {failedTestResult.ErrorOutput}, {failedTestResult.SessionUid}");`
`127`	`127`	`}`
`@@ -140,31 +140,31 @@ public void OnFileArtifactsReceived(object sender, FileArtifactEventArgs args)`
`140`	`140`	`artifact.TestDisplayName, artifact.FullPath);`
`141`	`141`	`}`
`142`	`142`
`143`		`- if (!VSTestTrace.TraceEnabled) return;`
	`143`	`+ if (!Logger.TraceEnabled) return;`
`144`	`144`
`145`		`- VSTestTrace.SafeWriteTrace(() => $"FileArtifactMessages Execution Id: {args.ExecutionId}");`
	`145`	`+ Logger.LogTrace(() => $"FileArtifactMessages Execution Id: {args.ExecutionId}");`
`146`	`146`
`147`	`147`	`foreach (FileArtifact fileArtifactMessage in args.FileArtifacts)`
`148`	`148`	`{`
`149`		`- VSTestTrace.SafeWriteTrace(() => $"FileArtifact: {fileArtifactMessage.FullPath}, {fileArtifactMessage.DisplayName}, " +`
	`149`	`+ Logger.LogTrace(() => $"FileArtifact: {fileArtifactMessage.FullPath}, {fileArtifactMessage.DisplayName}, " +`
`150`	`150`	`$"{fileArtifactMessage.Description}, {fileArtifactMessage.TestUid}, {fileArtifactMessage.TestDisplayName}, " +`
`151`	`151`	`$"{fileArtifactMessage.SessionUid}");`
`152`	`152`	`}`
`153`	`153`	`}`
`154`	`154`
`155`	`155`	`public void OnSessionEventReceived(object sender, SessionEventArgs args)`
`156`	`156`	`{`
`157`		`- if (!VSTestTrace.TraceEnabled) return;`
	`157`	`+ if (!Logger.TraceEnabled) return;`
`158`	`158`
`159`	`159`	`var sessionEvent = args.SessionEvent;`
`160`		`- VSTestTrace.SafeWriteTrace(() => $"TestSessionEvent: {sessionEvent.SessionType}, {sessionEvent.SessionUid}, {sessionEvent.ExecutionId}");`
	`160`	`+ Logger.LogTrace(() => $"TestSessionEvent: {sessionEvent.SessionType}, {sessionEvent.SessionUid}, {sessionEvent.ExecutionId}");`
`161`	`161`	`}`
`162`	`162`
`163`	`163`	`public void OnErrorReceived(object sender, ErrorEventArgs args)`
`164`	`164`	`{`
`165`		`- if (!VSTestTrace.TraceEnabled) return;`
	`165`	`+ if (!Logger.TraceEnabled) return;`
`166`	`166`
`167`		`- VSTestTrace.SafeWriteTrace(() => args.ErrorMessage);`
	`167`	`+ Logger.LogTrace(() => args.ErrorMessage);`
`168`	`168`	`}`
`169`	`169`
`170`	`170`	`public void OnTestProcessExited(object sender, TestProcessExitEventArgs args)`
`@@ -180,21 +180,21 @@ public void OnTestProcessExited(object sender, TestProcessExitEventArgs args)`
`180`	`180`	`_output.AssemblyRunCompleted(testApplication.Module.TargetPath ?? testApplication.Module.ProjectFullPath, testApplication.Module.TargetFramework, architecture: null, null, args.ExitCode, string.Join(Environment.NewLine, args.OutputData), string.Join(Environment.NewLine, args.ErrorData));`
`181`	`181`	`}`
`182`	`182`
`183`		`- if (!VSTestTrace.TraceEnabled) return;`
	`183`	`+ if (!Logger.TraceEnabled) return;`
`184`	`184`
`185`	`185`	`if (args.ExitCode != ExitCode.Success)`
`186`	`186`	`{`
`187`		`- VSTestTrace.SafeWriteTrace(() => $"Test Process exited with non-zero exit code: {args.ExitCode}");`
	`187`	`+ Logger.LogTrace(() => $"Test Process exited with non-zero exit code: {args.ExitCode}");`
`188`	`188`	`}`
`189`	`189`
`190`	`190`	`if (args.OutputData.Count > 0)`
`191`	`191`	`{`
`192`		`- VSTestTrace.SafeWriteTrace(() => $"Output Data: {string.Join("\n", args.OutputData)}");`
	`192`	`+ Logger.LogTrace(() => $"Output Data: {string.Join("\n", args.OutputData)}");`
`193`	`193`	`}`
`194`	`194`
`195`	`195`	`if (args.ErrorData.Count > 0)`
`196`	`196`	`{`
`197`		`- VSTestTrace.SafeWriteTrace(() => $"Error Data: {string.Join("\n", args.ErrorData)}");`
	`197`	`+ Logger.LogTrace(() => $"Error Data: {string.Join("\n", args.ErrorData)}");`
`198`	`198`	`}`
`199`	`199`	`}`
`200`	`200`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,6 @@ namespace Microsoft.DotNet.Cli`
`10`	`10`	`internal sealed class TestModulesFilterHandler`
`11`	`11`	`{`
`12`	`12`	`private readonly List<string> _args;`
`13`		`-`
`14`	`13`	`private readonly TestApplicationActionQueue _actionQueue;`
`15`	`14`
`16`	`15`	`public TestModulesFilterHandler(List<string> args, TestApplicationActionQueue actionQueue)`
`@@ -44,7 +43,7 @@ public bool RunWithTestModulesFilter(ParseResult parseResult)`
`44`	`43`	`// If no matches were found, we simply return`
`45`	`44`	`if (!testModulePaths.Any())`
`46`	`45`	`{`
`47`		`- VSTestTrace.SafeWriteTrace(() => $"No test modules found for the given test module pattern: {testModules} with root directory: {rootDirectory}");`
	`46`	`+ Logger.LogTrace(() => $"No test modules found for the given test module pattern: {testModules} with root directory: {rootDirectory}");`
`48`	`47`	`return false;`
`49`	`48`	`}`
`50`	`49`