[dotnet-trace] Add collect-linux verb

src/Tools/dotnet-trace/CommandLine/Commands/CollectCommand.cs

@@ -347,8 +347,6 @@ internal async Task<int> Collect(CancellationToken ct, CommandLineConfiguration
                             {
                                 ConsoleWriteLine($"Trace Duration : {duration:dd\\:hh\\:mm\\:ss}");
                             }
-
-                            ConsoleWriteLine();
                             ConsoleWriteLine();
 
                             EventMonitor eventMonitor = null;
@@ -391,10 +389,19 @@ internal async Task<int> Collect(CancellationToken ct, CommandLineConfiguration
                             }
 
                             FileInfo fileInfo = new(output.FullName);
+                            bool wroteStatus = false;
                             Action printStatus = () => {
                                 if (printStatusOverTime && rewriter.IsRewriteConsoleLineSupported)
                                 {
-                                    rewriter?.RewriteConsoleLine();
+                                    if (wroteStatus)
+                                    {
+                                        rewriter?.RewriteConsoleLine();
+                                    }
+                                    else
+                                    {
+                                        // First time writing status, so don't rewrite console yet.
+                                        wroteStatus = true;
+                                    }
                                     fileInfo.Refresh();
                                     ConsoleWriteLine($"[{stopwatch.Elapsed:dd\\:hh\\:mm\\:ss}]\tRecording trace {GetSize(fileInfo.Length)}");
                                     ConsoleWriteLine("Press <Enter> or <Ctrl+C> to exit...");

src/Tools/dotnet-trace/CommandLine/Commands/CollectLinuxCommand.cs

@@ -18,10 +18,10 @@ namespace Microsoft.Diagnostics.Tools.Trace
 {
     internal partial class CollectLinuxCommandHandler
     {
-        private static bool s_stopTracing;
-        private static Stopwatch s_stopwatch = new();
-        private static LineRewriter s_rewriter;
-        private static bool s_printingStatus;
+        private bool s_stopTracing;
+        private Stopwatch s_stopwatch = new();
+        private LineRewriter s_rewriter;
+        private bool s_printingStatus;
 
         internal sealed record CollectLinuxArgs(
             CancellationToken Ct,
@@ -48,7 +48,7 @@ internal int CollectLinux(CollectLinuxArgs args)
             if (!OperatingSystem.IsLinux())
             {
                 Console.Error.WriteLine("The collect-linux command is only supported on Linux.");
-                return (int)ReturnCode.ArgumentError;
+                return (int)ReturnCode.PlatformNotSupportedError;
             }
 
             args.Ct.Register(() => s_stopTracing = true);
@@ -72,6 +72,11 @@ internal int CollectLinux(CollectLinuxArgs args)
                 s_stopwatch.Start();
                 ret = RecordTraceInvoker(command, (UIntPtr)command.Length, OutputHandler);
             }
+            catch (Exception ex)
+            {
+                Console.Error.WriteLine($"[ERROR] {ex}");
+                ret = (int)ReturnCode.TracingError;
+            }
             finally
             {
                 if (!string.IsNullOrEmpty(scriptPath))

src/tests/Common/MockConsole.cs

@@ -158,7 +158,7 @@ public void AssertLinesEqual(int startLine, params string[] expectedLines)
             }
         }
 
-        public void AssertSanitizedLinesEqual(Func<string[], string[]> sanitizer, params string[] expectedLines)
+        public void AssertSanitizedLinesEqual(Func<string[], string[]> sanitizer, bool ignorePastExpected = false, params string[] expectedLines)
         {
             string[] actualLines = Lines;
             if (sanitizer is not null)
@@ -178,9 +178,12 @@ public void AssertSanitizedLinesEqual(Func<string[], string[]> sanitizer, params
                         $"Line {i,2} Actual  : {actualLines[i]}");
                 }
             }
-            for (int i = expectedLines.Length; i < actualLines.Length; i++)
+            if (!ignorePastExpected)
             {
-                Assert.True(string.IsNullOrEmpty(actualLines[i]), $"Actual line #{i} beyond expected lines is not empty: {actualLines[i]}");
+                for (int i = expectedLines.Length; i < actualLines.Length; i++)
+                {
+                    Assert.True(string.IsNullOrEmpty(actualLines[i]), $"Actual line #{i} beyond expected lines is not empty: {actualLines[i]}");
+                }
             }
         }
     }

src/tests/dotnet-trace/CollectCommandFunctionalTests.cs

@@ -10,6 +10,7 @@
 using System.Threading.Tasks;
 using Microsoft.Diagnostics.Tests.Common;
 using Microsoft.Diagnostics.Tools.Trace;
+using Microsoft.Internal.Common.Utils;
 using Xunit;
 
 namespace Microsoft.Diagnostics.Tools.Trace
@@ -51,22 +52,33 @@ public sealed record CollectArgs(
         public async Task CollectCommandProviderConfigurationConsolidation(CollectArgs args, string[] expectedSubset)
         {
             MockConsole console = new(200, 30);
-            string[] rawLines = await RunAsync(args, console).ConfigureAwait(true);
-            console.AssertSanitizedLinesEqual(CollectSanitizer, expectedSubset);
+            int exitCode = await RunAsync(args, console).ConfigureAwait(true);
+            Assert.Equal((int)ReturnCode.Ok, exitCode);
+            console.AssertSanitizedLinesEqual(CollectSanitizer, expectedLines: expectedSubset);
 
             byte[] expected = Encoding.UTF8.GetBytes(ExpectedPayload);
             Assert.Equal(expected, args.EventStream.ToArray());
         }
 
-        private static async Task<string[]> RunAsync(CollectArgs config, MockConsole console)
+        [Theory]
+        [MemberData(nameof(InvalidProviders))]
+        public async Task CollectCommandInvalidProviderConfiguration_Throws(CollectArgs args, string[] expectedException)
+        {
+            MockConsole console = new(200, 30);
+            int exitCode = await RunAsync(args, console).ConfigureAwait(true);
+            Assert.Equal((int)ReturnCode.TracingError, exitCode);
+            console.AssertSanitizedLinesEqual(CollectSanitizer, true, expectedException);
+        }
+
+        private static async Task<int> RunAsync(CollectArgs config, MockConsole console)
         {
             var handler = new CollectCommandHandler();
             handler.StartTraceSessionAsync = (client, cfg, ct) => Task.FromResult<CollectCommandHandler.ICollectSession>(new TestCollectSession());
             handler.ResumeRuntimeAsync = (client, ct) => Task.CompletedTask;
             handler.CollectSessionEventStream = (name) => config.EventStream;
             handler.Console = console;
 
-            int exit = await handler.Collect(
+            return await handler.Collect(
                 config.ct,
                 config.cliConfig,
                 config.ProcessId,
@@ -87,12 +99,7 @@ private static async Task<string[]> RunAsync(CollectArgs config, MockConsole con
                 config.stoppingEventPayloadFilter,
                 config.rundown,
                 config.dsrouter
-            ).ConfigureAwait(true);
-            if (exit != 0)
-            {
-                throw new InvalidOperationException($"Collect exited with return code {exit}.");
-            }
-            return console.Lines;
+            ).ConfigureAwait(false);
         }
 
         private static string[] CollectSanitizer(string[] lines)
@@ -123,7 +130,6 @@ public void Stop() {}
 
         public static IEnumerable<object[]> BasicCases()
         {
-            FileInfo fi = new("trace.nettrace");
             yield return new object[]
             {
                 new CollectArgs(),
@@ -214,14 +220,46 @@ public static IEnumerable<object[]> BasicCases()
             };
         }
 
+        public static IEnumerable<object[]> InvalidProviders()
+        {
+            yield return new object[]
+            {
+                new CollectArgs(profile: new[] { "cpu-sampling" }),
+                new [] { FormatException("The specified profile 'cpu-sampling' does not apply to `dotnet-trace collect`.", "System.ArgumentException") }
+            };
+
+            yield return new object[]
+            {
+                new CollectArgs(profile: new[] { "unknown" }),
+                new [] { FormatException("Invalid profile name: unknown", "System.ArgumentException") }
+            };
+
+            yield return new object[]
+            {
+                new CollectArgs(providers: new[] { "Foo:::Bar=0", "Foo:::Bar=1" }),
+                new [] { FormatException($"Provider \"Foo\" is declared multiple times with filter arguments.", "System.ArgumentException") }
+            };
+
+            yield return new object[]
+            {
+                new CollectArgs(clrevents: "unknown"),
+                new [] { FormatException("unknown is not a valid CLR event keyword", "System.ArgumentException") }
+            };
+
+            yield return new object[]
+            {
+                new CollectArgs(clrevents: "gc", clreventlevel: "unknown"),
+                new [] { FormatException("Unknown EventLevel: unknown", "System.ArgumentException") }
+            };
+        }
+
         private static string outputFile = $"Output File    : {Directory.GetCurrentDirectory() + Path.DirectorySeparatorChar}trace.nettrace";
         private const string ProviderHeader = "Provider Name                           Keywords            Level               Enabled By";
         private static readonly string[] CommonTail = [
             "Process        : <PROCESS>",
             outputFile,
             "",
             "",
-            "",
             "Trace completed."
         ];
 
@@ -238,5 +276,7 @@ private static string FormatProvider(string name, string keywordsHex, string lev
                              string.Format("{0, -8}", $"{levelName}({levelValue})");
             return string.Format("{0, -80}", display) + enabledBy;
         }
+
+        private static string FormatException(string message, string exceptionType) => $"[ERROR] {exceptionType}: {message}";
     }
 }

src/tests/dotnet-trace/CollectLinuxCommandFunctionalTests.cs

@@ -11,6 +11,7 @@
 using System.Linq;
 using Microsoft.Diagnostics.Tests.Common;
 using Microsoft.Diagnostics.Tools.Trace;
+using Microsoft.Internal.Common.Utils;
 using Xunit;
 
 namespace Microsoft.Diagnostics.Tools.Trace
@@ -23,7 +24,7 @@ private static CollectLinuxCommandHandler.CollectLinuxArgs TestArgs(
             string clrEventLevel = "",
             string clrEvents = "",
             string[] perfEvents = null,
-            string[] profiles = null,
+            string[] profile = null,
             FileInfo output = null,
             TimeSpan duration = default)
         {
@@ -32,7 +33,7 @@ private static CollectLinuxCommandHandler.CollectLinuxArgs TestArgs(
                                                                    clrEventLevel,
                                                                    clrEvents,
                                                                    perfEvents ?? Array.Empty<string>(),
-                                                                   profiles ?? Array.Empty<string>(),
+                                                                   profile ?? Array.Empty<string>(),
                                                                    output ?? new FileInfo(CommonOptions.DefaultTraceName),
                                                                    duration);
         }
@@ -42,23 +43,49 @@ private static CollectLinuxCommandHandler.CollectLinuxArgs TestArgs(
         public void CollectLinuxCommandProviderConfigurationConsolidation(object testArgs, string[] expectedLines)
         {
             MockConsole console = new(200, 30);
-            var handler = new CollectLinuxCommandHandler(console);
-            handler.RecordTraceInvoker = (cmd, len, cb) => 0;
-            int exit = handler.CollectLinux((CollectLinuxCommandHandler.CollectLinuxArgs)testArgs);
+            int exitCode = Run(testArgs, console);
             if (OperatingSystem.IsLinux())
             {
-                Assert.Equal(0, exit);
-                console.AssertSanitizedLinesEqual(null, expectedLines);
+                Assert.Equal((int)ReturnCode.Ok, exitCode);
+                console.AssertSanitizedLinesEqual(null, expectedLines: expectedLines);
             }
             else
             {
-                Assert.Equal(3, exit);
-                console.AssertSanitizedLinesEqual(null, new string[] {
+                Assert.Equal((int)ReturnCode.PlatformNotSupportedError, exitCode);
+                console.AssertSanitizedLinesEqual(null, expectedLines: new string[] {
                     "The collect-linux command is only supported on Linux.",
                 });
             }
         }
 
+        [Theory]
+        [MemberData(nameof(InvalidProviders))]
+        public void CollectLinuxCommandProviderConfigurationConsolidation_Throws(object testArgs, string[] expectedException)
+        {
+            MockConsole console = new(200, 30);
+            int exitCode = Run(testArgs, console);
+            if (OperatingSystem.IsLinux())
+            {
+                Assert.Equal((int)ReturnCode.TracingError, exitCode);
+                console.AssertSanitizedLinesEqual(null, true, expectedLines: expectedException);
+            }
+            else
+            {
+                Assert.Equal((int)ReturnCode.PlatformNotSupportedError, exitCode);
+                console.AssertSanitizedLinesEqual(null, expectedLines: new string[] {
+                    "The collect-linux command is only supported on Linux.",
+                });
+            }
+        }
+
+        private static int Run(object args, MockConsole console)
+        {
+            var handler = new CollectLinuxCommandHandler(console);
+            handler.RecordTraceInvoker = (cmd, len, cb) => 0;
+            return handler.CollectLinux((CollectLinuxCommandHandler.CollectLinuxArgs)args);
+        }
+
+
         public static IEnumerable<object[]> BasicCases()
         {
             yield return new object[] {
@@ -98,7 +125,7 @@ public static IEnumerable<object[]> BasicCases()
                 }
             };
             yield return new object[] {
-                TestArgs(profiles: new[]{"cpu-sampling"}),
+                TestArgs(profile: new[]{"cpu-sampling"}),
                 new string[] {
                     "No .NET providers were configured.",
                     "",
@@ -108,7 +135,7 @@ public static IEnumerable<object[]> BasicCases()
                 }
             };
             yield return new object[] {
-                TestArgs(providers: new[]{"Foo:0x1:4"}, profiles: new[]{"cpu-sampling"}),
+                TestArgs(providers: new[]{"Foo:0x1:4"}, profile: new[]{"cpu-sampling"}),
                 new string[] {
                     "",
                     ProviderHeader,
@@ -120,7 +147,7 @@ public static IEnumerable<object[]> BasicCases()
                 }
             };
             yield return new object[] {
-                TestArgs(clrEvents: "gc", profiles: new[]{"cpu-sampling"}),
+                TestArgs(clrEvents: "gc", profile: new[]{"cpu-sampling"}),
                 new string[] {
                     "",
                     ProviderHeader,
@@ -132,7 +159,7 @@ public static IEnumerable<object[]> BasicCases()
                 }
             };
             yield return new object[] {
-                TestArgs(providers: new[]{"Microsoft-Windows-DotNETRuntime:0x1:4"}, profiles: new[]{"cpu-sampling"}),
+                TestArgs(providers: new[]{"Microsoft-Windows-DotNETRuntime:0x1:4"}, profile: new[]{"cpu-sampling"}),
                 new string[] {
                     "",
                     ProviderHeader,
@@ -189,6 +216,39 @@ public static IEnumerable<object[]> BasicCases()
             };
         }
 
+        public static IEnumerable<object[]> InvalidProviders()
+        {
+            yield return new object[]
+            {
+                TestArgs(profile: new[] { "dotnet-sampled-thread-time" }),
+                new [] { FormatException("The specified profile 'dotnet-sampled-thread-time' does not apply to `dotnet-trace collect-linux`.", "System.ArgumentException") }
+            };
+
+            yield return new object[]
+            {
+                TestArgs(profile: new[] { "unknown" }),
+                new [] { FormatException("Invalid profile name: unknown", "System.ArgumentException") }
+            };
+
+            yield return new object[]
+            {
+                TestArgs(providers: new[] { "Foo:::Bar=0", "Foo:::Bar=1" }),
+                new [] { FormatException($"Provider \"Foo\" is declared multiple times with filter arguments.", "System.ArgumentException") }
+            };
+
+            yield return new object[]
+            {
+                TestArgs(clrEvents: "unknown"),
+                new [] { FormatException("unknown is not a valid CLR event keyword", "System.ArgumentException") }
+            };
+
+            yield return new object[]
+            {
+                TestArgs(clrEvents: "gc", clrEventLevel: "unknown"),
+                new [] { FormatException("Unknown EventLevel: unknown", "System.ArgumentException") }
+            };
+        }
+
         private const string ProviderHeader = "Provider Name                           Keywords            Level               Enabled By";
         private static string LinuxHeader => $"{"Linux Events",-80}Enabled By";
         private static string LinuxProfile(string name) => $"{name,-80}--profile";
@@ -200,5 +260,6 @@ private static string FormatProvider(string name, string keywordsHex, string lev
                              string.Format("{0, -8}", $"{levelName}({levelValue})");
             return string.Format("{0, -80}", display) + enabledBy;
         }
+        private static string FormatException(string message, string exceptionType) => $"[ERROR] {exceptionType}: {message}";
     }
 }