Convert CollectCommandHandler to instanced

mdh1418 · mdh1418 · commit 532b7e6330be · 2025-10-02T18:43:13.000-04:00
diff --git a/src/Tools/Common/DefaultConsole.cs b/src/Tools/Common/DefaultConsole.cs
@@ -2,9 +2,10 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.IO;
 using Microsoft.Diagnostics.Tools.Common;
 
-namespace Microsoft.Diagnostics.Tools.Counters.Exporters
+namespace Microsoft.Diagnostics.Tools.Common
 {
     /// <summary>
     /// The default implementation of IConsole maps everything to System.Console. In the future
@@ -32,6 +33,18 @@ public DefaultConsole(bool useAnsi)
 
         public int BufferWidth => Console.BufferWidth;
 
+        public int BufferHeight => Console.BufferHeight;
+
+        public bool IsOutputRedirected => Console.IsOutputRedirected;
+
+        public bool IsInputRedirected => Console.IsInputRedirected;
+
+        public bool KeyAvailable => Console.KeyAvailable;
+
+        public TextWriter Out => Console.Out;
+
+        public TextWriter Error => Console.Error;
+
         public void Clear()
         {
             if (_useAnsi)
@@ -57,6 +70,8 @@ public void SetCursorPosition(int col, int row)
         }
         public void Write(string text) => Console.Write(text);
         public void WriteLine(string text) => Console.WriteLine(text);
-        public void WriteLine() => Console.WriteLine();
+        public static void WriteLine() => Console.WriteLine();
+        public ConsoleKeyInfo ReadKey() => Console.ReadKey();
+        public ConsoleKeyInfo ReadKey(bool intercept) => Console.ReadKey(intercept);
     }
 }
diff --git a/src/Tools/Common/IConsole.cs b/src/Tools/Common/IConsole.cs
@@ -1,6 +1,9 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System;
+using System.IO;
+
 namespace Microsoft.Diagnostics.Tools.Common
 {
     /// <summary>
@@ -14,11 +17,18 @@ internal interface IConsole
         bool CursorVisible { get; set; }
         int CursorTop { get; }
         int BufferWidth { get; }
+        int BufferHeight { get; }
+        bool IsOutputRedirected { get; }
+        bool IsInputRedirected { get; }
+        bool KeyAvailable { get; }
+        TextWriter Out { get; }
+        TextWriter Error { get; }
 
         void Clear();
         void SetCursorPosition(int col, int row);
         void Write(string text);
         void WriteLine(string text);
-        void WriteLine();
+        ConsoleKeyInfo ReadKey();
+        ConsoleKeyInfo ReadKey(bool intercept);
     }
 }
diff --git a/src/Tools/dotnet-counters/CounterMonitor.cs b/src/Tools/dotnet-counters/CounterMonitor.cs
@@ -14,6 +14,7 @@
 using Microsoft.Diagnostics.Monitoring;
 using Microsoft.Diagnostics.Monitoring.EventPipe;
 using Microsoft.Diagnostics.NETCore.Client;
+using Microsoft.Diagnostics.Tools.Common;
 using Microsoft.Diagnostics.Tools.Counters.Exporters;
 using Microsoft.Internal.Common.Utils;
 
diff --git a/src/Tools/dotnet-trace/CommandLine/Commands/CollectCommand.cs b/src/Tools/dotnet-trace/CommandLine/Commands/CollectCommand.cs
@@ -13,16 +13,26 @@
 using System.Threading.Tasks;
 using Microsoft.Diagnostics.Monitoring.EventPipe;
 using Microsoft.Diagnostics.NETCore.Client;
+using Microsoft.Diagnostics.Tools.Common;
 using Microsoft.Internal.Common;
 using Microsoft.Internal.Common.Utils;
 
 namespace Microsoft.Diagnostics.Tools.Trace
 {
-    internal static class CollectCommandHandler
+    internal class CollectCommandHandler
     {
-        internal static bool IsQuiet { get; set; }
+        internal bool IsQuiet { get; set; }
 
-        private static void ConsoleWriteLine(string str)
+        public CollectCommandHandler()
+        {
+            Console = new DefaultConsole(false);
+            StartTraceSessionAsync = async (client, config, ct) => new CollectSession(await client.StartEventPipeSessionAsync(config, ct).ConfigureAwait(false));
+            ResumeRuntimeAsync = (client, ct) => client.ResumeRuntimeAsync(ct);
+            CollectSessionEventStream = name => new FileStream(name, FileMode.Create, FileAccess.Write);
+            IsOutputRedirected = Console.IsOutputRedirected;
+        }
+
+        private void ConsoleWriteLine(string str)
         {
             if (!IsQuiet)
             {
@@ -54,7 +64,7 @@ private static void ConsoleWriteLine(string str)
         /// <param name="stoppingEventPayloadFilter">A string, parsed as [payload_field_name]:[payload_field_value] pairs separated by commas, that will stop the trace upon hitting an event with a matching payload. Requires `--stopping-event-provider-name` and `--stopping-event-event-name` to be set.</param>
         /// <param name="rundown">Collect rundown events.</param>
         /// <returns></returns>
-        internal static async Task<int> Collect(CancellationToken ct, CommandLineConfiguration cliConfig, int processId, FileInfo output, uint buffersize, string providers, string profile, TraceFileFormat format, TimeSpan duration, string clrevents, string clreventlevel, string name, string diagnosticPort, bool showchildio, bool resumeRuntime, string stoppingEventProviderName, string stoppingEventEventName, string stoppingEventPayloadFilter, bool? rundown, string dsrouter)
+        internal async Task<int> Collect(CancellationToken ct, CommandLineConfiguration cliConfig, int processId, FileInfo output, uint buffersize, string providers, string profile, TraceFileFormat format, TimeSpan duration, string clrevents, string clreventlevel, string name, string diagnosticPort, bool showchildio, bool resumeRuntime, string stoppingEventProviderName, string stoppingEventEventName, string stoppingEventPayloadFilter, bool? rundown, string dsrouter)
         {
             bool collectionStopped = false;
             bool cancelOnEnter = true;
@@ -79,7 +89,7 @@ internal static async Task<int> Collect(CancellationToken ct, CommandLineConfigu
                 {
                     cancelOnCtrlC = true;
                     cancelOnEnter = !Console.IsInputRedirected;
-                    printStatusOverTime = !IsOutputRedirected();
+                    printStatusOverTime = !IsOutputRedirected;
                 }
 
                 if (!cancelOnCtrlC)
@@ -357,10 +367,10 @@ internal static async Task<int> Collect(CancellationToken ct, CommandLineConfigu
 
                         LineRewriter rewriter = null;
 
-                        using (FileStream fs = new(output.FullName, FileMode.Create, FileAccess.Write))
+                        using (Stream eventStream = CollectSessionEventStream(output.FullName))
                         {
                             ConsoleWriteLine($"Process        : {processMainModuleFileName}");
-                            ConsoleWriteLine($"Output File    : {fs.Name}");
+                            ConsoleWriteLine($"Output File    : {output.FullName}");
                             if (shouldStopAfterDuration)
                             {
                                 ConsoleWriteLine($"Trace Duration : {duration:dd\\:hh\\:mm\\:ss}");
@@ -383,14 +393,14 @@ internal static async Task<int> Collect(CancellationToken ct, CommandLineConfigu
                                     onPayloadFilterMismatch: (traceEvent) => {
                                         ConsoleWriteLine($"One or more field names specified in the payload filter for event '{traceEvent.ProviderName}/{traceEvent.EventName}' do not match any of the known field names: '{string.Join(' ', traceEvent.PayloadNames)}'. As a result the requested stopping event is unreachable; will continue to collect the trace for the remaining specified duration.");
                                     },
-                                    eventStream: new PassthroughStream(session.EventStream, fs, (int)buffersize, leaveDestinationStreamOpen: true),
+                                    eventStream: new PassthroughStream(session.EventStream, eventStream, (int)buffersize, leaveDestinationStreamOpen: true),
                                     callOnEventOnlyOnce: true);
 
                                 copyTask = eventMonitor.ProcessAsync(CancellationToken.None);
                             }
                             else
                             {
-                                copyTask = session.EventStream.CopyToAsync(fs);
+                                copyTask = session.EventStream.CopyToAsync(eventStream);
                             }
                             Task shouldExitTask = copyTask.ContinueWith(
                                 (task) => shouldExit.Set(),
@@ -400,7 +410,7 @@ internal static async Task<int> Collect(CancellationToken ct, CommandLineConfigu
 
                             if (printStatusOverTime)
                             {
-                                if (AreCursorOperationsSupported())
+                                if (CursorOperationsSupported)
                                 {
                                     rewriter = new LineRewriter { LineToClear = Console.CursorTop - 1 };
                                     Console.CursorVisible = false;
@@ -506,7 +516,7 @@ internal static async Task<int> Collect(CancellationToken ct, CommandLineConfigu
             }
             finally
             {
-                if (printStatusOverTime && AreCursorOperationsSupported())
+                if (printStatusOverTime && CursorOperationsSupported)
                 {
                     if (!Console.IsOutputRedirected)
                     {
@@ -527,7 +537,7 @@ internal static async Task<int> Collect(CancellationToken ct, CommandLineConfigu
             return ret;
         }
 
-        private static void PrintProviders(IReadOnlyList<EventPipeProvider> providers, Dictionary<string, string> enabledBy)
+        private void PrintProviders(IReadOnlyList<EventPipeProvider> providers, Dictionary<string, string> enabledBy)
         {
             ConsoleWriteLine("");
             ConsoleWriteLine(string.Format("{0, -40}", "Provider Name") + string.Format("{0, -20}", "Keywords") +
@@ -588,27 +598,30 @@ public static Command CollectCommand()
             collectCommand.TreatUnmatchedTokensAsErrors = false; // see the logic in Program.Main that handles UnmatchedTokens
             collectCommand.Description = "Collects a diagnostic trace from a currently running process or launch a child process and trace it. Append -- to the collect command to instruct the tool to run a command and trace it immediately. When tracing a child process, the exit code of dotnet-trace shall be that of the traced process unless the trace process encounters an error.";
 
-            collectCommand.SetAction((parseResult, ct) => Collect(
-                ct,
-                cliConfig: parseResult.Configuration,
-                processId: parseResult.GetValue(CommonOptions.ProcessIdOption),
-                output: parseResult.GetValue(OutputPathOption),
-                buffersize: parseResult.GetValue(CircularBufferOption),
-                providers: parseResult.GetValue(ProvidersOption) ?? string.Empty,
-                profile: parseResult.GetValue(ProfileOption) ?? string.Empty,
-                format: parseResult.GetValue(CommonOptions.FormatOption),
-                duration: parseResult.GetValue(DurationOption),
-                clrevents: parseResult.GetValue(CLREventsOption) ?? string.Empty,
-                clreventlevel: parseResult.GetValue(CLREventLevelOption) ?? string.Empty,
-                name: parseResult.GetValue(CommonOptions.NameOption),
-                diagnosticPort: parseResult.GetValue(DiagnosticPortOption) ?? string.Empty,
-                showchildio: parseResult.GetValue(ShowChildIOOption),
-                resumeRuntime: parseResult.GetValue(ResumeRuntimeOption),
-                stoppingEventProviderName: parseResult.GetValue(StoppingEventProviderNameOption),
-                stoppingEventEventName: parseResult.GetValue(StoppingEventEventNameOption),
-                stoppingEventPayloadFilter: parseResult.GetValue(StoppingEventPayloadFilterOption),
-                rundown: parseResult.GetValue(RundownOption),
-                dsrouter: parseResult.GetValue(DSRouterOption)));
+            collectCommand.SetAction((parseResult, ct) =>
+            {
+                CollectCommandHandler handler = new();
+                return handler.Collect(ct,
+                                       cliConfig: parseResult.Configuration,
+                                       processId: parseResult.GetValue(CommonOptions.ProcessIdOption),
+                                       output: parseResult.GetValue(OutputPathOption),
+                                       buffersize: parseResult.GetValue(CircularBufferOption),
+                                       providers: parseResult.GetValue(ProvidersOption) ?? string.Empty,
+                                       profile: parseResult.GetValue(ProfileOption) ?? string.Empty,
+                                       format: parseResult.GetValue(CommonOptions.FormatOption),
+                                       duration: parseResult.GetValue(DurationOption),
+                                       clrevents: parseResult.GetValue(CLREventsOption) ?? string.Empty,
+                                       clreventlevel: parseResult.GetValue(CLREventLevelOption) ?? string.Empty,
+                                       name: parseResult.GetValue(CommonOptions.NameOption),
+                                       diagnosticPort: parseResult.GetValue(DiagnosticPortOption) ?? string.Empty,
+                                       showchildio: parseResult.GetValue(ShowChildIOOption),
+                                       resumeRuntime: parseResult.GetValue(ResumeRuntimeOption),
+                                       stoppingEventProviderName: parseResult.GetValue(StoppingEventProviderNameOption),
+                                       stoppingEventEventName: parseResult.GetValue(StoppingEventEventNameOption),
+                                       stoppingEventPayloadFilter: parseResult.GetValue(StoppingEventPayloadFilterOption),
+                                       rundown: parseResult.GetValue(RundownOption),
+                                       dsrouter: parseResult.GetValue(DSRouterOption));
+            });
 
             return collectCommand;
         }
@@ -735,14 +748,12 @@ private sealed class CollectSession : ICollectSession
             public void Dispose() => _session.Dispose();
         }
 
-        internal static Func<DiagnosticsClient, EventPipeSessionConfiguration, CancellationToken, Task<ICollectSession>> StartTraceSessionAsync { get; set; }
-            = async (client, config, ct) => new CollectSession(await client.StartEventPipeSessionAsync(config, ct).ConfigureAwait(false));
-
-        internal static Func<DiagnosticsClient, CancellationToken, Task> ResumeRuntimeAsync { get; set; }
-            = (client, ct) => client.ResumeRuntimeAsync(ct);
-
-        internal static Func<bool> IsOutputRedirected { get; set; } = () => Console.IsOutputRedirected;
-        internal static Func<bool> AreCursorOperationsSupported { get; set; } = () => true;
+        internal Func<DiagnosticsClient, EventPipeSessionConfiguration, CancellationToken, Task<ICollectSession>> StartTraceSessionAsync { get; set; }
+        internal Func<DiagnosticsClient, CancellationToken, Task> ResumeRuntimeAsync { get; set; }
+        internal bool CursorOperationsSupported { get; set; } = true;
+        internal Func<string, Stream> CollectSessionEventStream { get; set; }
+        internal IConsole Console { get; set; }
+        internal bool IsOutputRedirected { get; set; }
 #endregion
     }
 }
diff --git a/src/tests/Common/MockConsole.cs b/src/tests/Common/MockConsole.cs
@@ -35,6 +35,18 @@ public MockConsole(int width, int height)
 
         public int BufferWidth { get; private set; }
 
+        public int BufferHeight { get; private set; }
+
+        public bool IsOutputRedirected { get; private set; }
+
+        public bool IsInputRedirected { get; private set; }
+
+        public bool KeyAvailable { get; private set; }
+
+        public TextWriter Out => this;
+
+        public TextWriter Error => this;
+
         public void Clear()
         {
             _chars = new char[WindowHeight][];
@@ -102,6 +114,10 @@ public override void WriteLine(string text)
 
         public string GetLineText(int row) => new string(_chars[row]).TrimEnd();
 
+        public ConsoleKeyInfo ReadKey() => Console.ReadKey();
+
+        public ConsoleKeyInfo ReadKey(bool intercept) => Console.ReadKey(intercept);
+
         public string[] Lines
         {
             get
@@ -143,30 +159,30 @@ public void AssertLinesEqual(int startLine, params string[] expectedLines)
         // Asserts that the sanitized version of the console lines exactly equals the expected lines.
         // The sanitizer receives the raw Lines array and should return a transformed array (e.g., with
         // blank lines removed, whitespace collapsed, dynamic values normalized). Equality is ordinal.
-        public void AssertSanitizedLinesEqual(Func<string[], string[]> sanitizer, params string[] expectedSanitizedLines)
+        public void AssertSanitizedLinesEqual(Func<string[], string[]> sanitizer, params string[] expectedLines)
         {
-            if (sanitizer is null)
-            {
-                throw new ArgumentNullException(nameof(sanitizer));
-            }
-            string[] actualSanitized = sanitizer(Lines);
-            if (actualSanitized.Length != expectedSanitizedLines.Length)
+            string[] actualLines = Lines;
+            if (sanitizer is not null)
             {
-                Assert.Fail("Sanitized console output length mismatch." + Environment.NewLine +
-                    $"Expected: {expectedSanitizedLines.Length}" + Environment.NewLine +
-                    $"Actual  : {actualSanitized.Length}");
+                actualLines = sanitizer(actualLines);
             }
-            for (int i = 0; i < expectedSanitizedLines.Length; i++)
+            Assert.True(actualLines.Length >= expectedLines.Length, "Sanitized console output had fewer lines than expected." + Environment.NewLine +
+                $"Expected line count: {expectedLines.Length}" + Environment.NewLine +
+                $"Actual line count: {actualLines.Length}");
+
+            for (int i = 0; i < expectedLines.Length; i++)
             {
-                string expected = expectedSanitizedLines[i];
-                string actual = actualSanitized[i];
-                if (!string.Equals(expected, actual, StringComparison.Ordinal))
+                if (!string.Equals(expectedLines[i], actualLines[i], StringComparison.Ordinal))
                 {
                     Assert.Fail("Sanitized console output mismatch." + Environment.NewLine +
-                        $"Line {i,2} Expected: {expected}" + Environment.NewLine +
-                        $"Line {i,2} Actual  : {actual}");
+                        $"Line {i,2} Expected: {expectedLines[i]}" + Environment.NewLine +
+                        $"Line {i,2} Actual  : {actualLines[i]}");
                 }
             }
+            for (int i = expectedLines.Length; i < actualLines.Length; i++)
+            {
+                Assert.True(string.IsNullOrWhiteSpace(actualLines[i]), "Actual line beyond expected lines is not empty: " + actualLines[i]);
+            }
         }
     }
 }
diff --git a/src/tests/dotnet-trace/CollectCommandFunctionalTests.cs b/src/tests/dotnet-trace/CollectCommandFunctionalTests.cs
