Handle invalid provider config exception

mdh1418 · mdh1418 · commit 25d555941678 · 2025-10-17T20:17:23.000Z
diff --git a/src/Tools/dotnet-trace/CommandLine/Commands/CollectCommand.cs b/src/Tools/dotnet-trace/CommandLine/Commands/CollectCommand.cs
@@ -474,6 +474,12 @@ internal async Task<int> Collect(CancellationToken ct, CommandLineConfiguration
                     }
                 }
             }
+            catch (ArgumentException e)
+            {
+                Console.Error.WriteLine($"[ERROR] {e.Message}");
+                collectionStopped = true;
+                ret = (int)ReturnCode.ArgumentError;
+            }
             catch (CommandLineErrorException e)
             {
                 Console.Error.WriteLine($"[ERROR] {e.Message}");
diff --git a/src/Tools/dotnet-trace/CommandLine/Commands/CollectLinuxCommand.cs b/src/Tools/dotnet-trace/CommandLine/Commands/CollectLinuxCommand.cs
@@ -72,6 +72,16 @@ internal int CollectLinux(CollectLinuxArgs args)
                 stopwatch.Start();
                 ret = RecordTraceInvoker(command, (UIntPtr)command.Length, OutputHandler);
             }
+            catch (ArgumentException e)
+            {
+                Console.Error.WriteLine($"[ERROR] {e.Message}");
+                ret = (int)ReturnCode.ArgumentError;
+            }
+            catch (CommandLineErrorException e)
+            {
+                Console.Error.WriteLine($"[ERROR] {e.Message}");
+                ret = (int)ReturnCode.TracingError;
+            }
             catch (Exception ex)
             {
                 Console.Error.WriteLine($"[ERROR] {ex}");
diff --git a/src/tests/Common/MockConsole.cs b/src/tests/Common/MockConsole.cs
@@ -158,7 +158,7 @@ public void AssertLinesEqual(int startLine, params string[] expectedLines)
             }
         }
 
-        public void AssertSanitizedLinesEqual(Func<string[], string[]> sanitizer, bool ignorePastExpected = false, params string[] expectedLines)
+        public void AssertSanitizedLinesEqual(Func<string[], string[]> sanitizer, params string[] expectedLines)
         {
             string[] actualLines = Lines;
             if (sanitizer is not null)
@@ -178,12 +178,9 @@ public void AssertSanitizedLinesEqual(Func<string[], string[]> sanitizer, bool i
                         $"Line {i,2} Actual  : {actualLines[i]}");
                 }
             }
-            if (!ignorePastExpected)
+            for (int i = expectedLines.Length; i < actualLines.Length; 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]}");
-                }
+                Assert.True(string.IsNullOrEmpty(actualLines[i]), $"Actual line #{i} beyond expected lines is not empty: {actualLines[i]}");
             }
         }
     }
diff --git a/src/tests/dotnet-trace/CollectCommandFunctionalTests.cs b/src/tests/dotnet-trace/CollectCommandFunctionalTests.cs
@@ -54,7 +54,7 @@ public async Task CollectCommandProviderConfigurationConsolidation(CollectArgs a
             MockConsole console = new(200, 30);
             int exitCode = await RunAsync(args, console).ConfigureAwait(true);
             Assert.Equal((int)ReturnCode.Ok, exitCode);
-            console.AssertSanitizedLinesEqual(CollectSanitizer, expectedLines: expectedSubset);
+            console.AssertSanitizedLinesEqual(CollectSanitizer, expectedSubset);
 
             byte[] expected = Encoding.UTF8.GetBytes(ExpectedPayload);
             Assert.Equal(expected, args.EventStream.ToArray());
@@ -66,8 +66,8 @@ public async Task CollectCommandInvalidProviderConfiguration_Throws(CollectArgs
         {
             MockConsole console = new(200, 30);
             int exitCode = await RunAsync(args, console).ConfigureAwait(true);
-            Assert.Equal((int)ReturnCode.TracingError, exitCode);
-            console.AssertSanitizedLinesEqual(CollectSanitizer, true, expectedException);
+            Assert.Equal((int)ReturnCode.ArgumentError, exitCode);
+            console.AssertSanitizedLinesEqual(CollectSanitizer, expectedException);
         }
 
         private static async Task<int> RunAsync(CollectArgs config, MockConsole console)
@@ -225,31 +225,31 @@ 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") }
+                new [] { FormatException("The specified profile 'cpu-sampling' does not apply to `dotnet-trace collect`.") }
             };
 
             yield return new object[]
             {
                 new CollectArgs(profile: new[] { "unknown" }),
-                new [] { FormatException("Invalid profile name: unknown", "System.ArgumentException") }
+                new [] { FormatException("Invalid profile name: unknown") }
             };
 
             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") }
+                new [] { FormatException($"Provider \"Foo\" is declared multiple times with filter arguments.") }
             };
 
             yield return new object[]
             {
                 new CollectArgs(clrevents: "unknown"),
-                new [] { FormatException("unknown is not a valid CLR event keyword", "System.ArgumentException") }
+                new [] { FormatException("unknown is not a valid CLR event keyword") }
             };
 
             yield return new object[]
             {
                 new CollectArgs(clrevents: "gc", clreventlevel: "unknown"),
-                new [] { FormatException("Unknown EventLevel: unknown", "System.ArgumentException") }
+                new [] { FormatException("Unknown EventLevel: unknown") }
             };
         }
 
@@ -277,6 +277,6 @@ private static string FormatProvider(string name, string keywordsHex, string lev
             return string.Format("{0, -80}", display) + enabledBy;
         }
 
-        private static string FormatException(string message, string exceptionType) => $"[ERROR] {exceptionType}: {message}";
+        private static string FormatException(string message) => $"[ERROR] {message}";
     }
 }
diff --git a/src/tests/dotnet-trace/CollectLinuxCommandFunctionalTests.cs b/src/tests/dotnet-trace/CollectLinuxCommandFunctionalTests.cs
@@ -47,12 +47,12 @@ public void CollectLinuxCommandProviderConfigurationConsolidation(object testArg
             if (OperatingSystem.IsLinux())
             {
                 Assert.Equal((int)ReturnCode.Ok, exitCode);
-                console.AssertSanitizedLinesEqual(CollectLinuxSanitizer, expectedLines: expectedLines);
+                console.AssertSanitizedLinesEqual(CollectLinuxSanitizer, expectedLines);
             }
             else
             {
                 Assert.Equal((int)ReturnCode.PlatformNotSupportedError, exitCode);
-                console.AssertSanitizedLinesEqual(null, expectedLines: new string[] {
+                console.AssertSanitizedLinesEqual(null, new string[] {
                     "The collect-linux command is only supported on Linux.",
                 });
             }
@@ -66,13 +66,13 @@ public void CollectLinuxCommandProviderConfigurationConsolidation_Throws(object
             int exitCode = Run(testArgs, console);
             if (OperatingSystem.IsLinux())
             {
-                Assert.Equal((int)ReturnCode.TracingError, exitCode);
-                console.AssertSanitizedLinesEqual(null, true, expectedLines: expectedException);
+                Assert.Equal((int)ReturnCode.ArgumentError, exitCode);
+                console.AssertSanitizedLinesEqual(null, expectedException);
             }
             else
             {
                 Assert.Equal((int)ReturnCode.PlatformNotSupportedError, exitCode);
-                console.AssertSanitizedLinesEqual(null, expectedLines: new string[] {
+                console.AssertSanitizedLinesEqual(null, new string[] {
                     "The collect-linux command is only supported on Linux.",
                 });
             }
@@ -197,31 +197,31 @@ 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") }
+                new [] { FormatException("The specified profile 'dotnet-sampled-thread-time' does not apply to `dotnet-trace collect-linux`.") }
             };
 
             yield return new object[]
             {
                 TestArgs(profile: new[] { "unknown" }),
-                new [] { FormatException("Invalid profile name: unknown", "System.ArgumentException") }
+                new [] { FormatException("Invalid profile name: unknown") }
             };
 
             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") }
+                new [] { FormatException($"Provider \"Foo\" is declared multiple times with filter arguments.") }
             };
 
             yield return new object[]
             {
                 TestArgs(clrEvents: "unknown"),
-                new [] { FormatException("unknown is not a valid CLR event keyword", "System.ArgumentException") }
+                new [] { FormatException("unknown is not a valid CLR event keyword") }
             };
 
             yield return new object[]
             {
                 TestArgs(clrEvents: "gc", clrEventLevel: "unknown"),
-                new [] { FormatException("Unknown EventLevel: unknown", "System.ArgumentException") }
+                new [] { FormatException("Unknown EventLevel: unknown") }
             };
         }
 
@@ -236,7 +236,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}";
+        private static string FormatException(string message) => $"[ERROR] {message}";
         private static string DefaultOutputFile => $"Output File    : {Directory.GetCurrentDirectory() + Path.DirectorySeparatorChar}trace.nettrace";
         private static readonly string[] CommonTail = [
             DefaultOutputFile,

Original file line number	Diff line number	Diff line change
`@@ -474,6 +474,12 @@ internal async Task<int> Collect(CancellationToken ct, CommandLineConfiguration`
`474`	`474`	`}`
`475`	`475`	`}`
`476`	`476`	`}`
	`477`	`+ catch (ArgumentException e)`
	`478`	`+ {`
	`479`	`+ Console.Error.WriteLine($"[ERROR] {e.Message}");`
	`480`	`+ collectionStopped = true;`
	`481`	`+ ret = (int)ReturnCode.ArgumentError;`
	`482`	`+ }`
`477`	`483`	`catch (CommandLineErrorException e)`
`478`	`484`	`{`
`479`	`485`	`Console.Error.WriteLine($"[ERROR] {e.Message}");`
Original file line number	Diff line number	Diff line change
`@@ -158,7 +158,7 @@ public void AssertLinesEqual(int startLine, params string[] expectedLines)`
`158`	`158`	`}`
`159`	`159`	`}`
`160`	`160`
`161`		`- public void AssertSanitizedLinesEqual(Func<string[], string[]> sanitizer, bool ignorePastExpected = false, params string[] expectedLines)`
	`161`	`+ public void AssertSanitizedLinesEqual(Func<string[], string[]> sanitizer, params string[] expectedLines)`
`162`	`162`	`{`
`163`	`163`	`string[] actualLines = Lines;`
`164`	`164`	`if (sanitizer is not null)`
`@@ -178,12 +178,9 @@ public void AssertSanitizedLinesEqual(Func<string[], string[]> sanitizer, bool i`
`178`	`178`	`$"Line {i,2} Actual : {actualLines[i]}");`
`179`	`179`	`}`
`180`	`180`	`}`
`181`		`- if (!ignorePastExpected)`
	`181`	`+ for (int i = expectedLines.Length; i < actualLines.Length; i++)`
`182`	`182`	`{`
`183`		`- for (int i = expectedLines.Length; i < actualLines.Length; i++)`
`184`		`- {`
`185`		`- Assert.True(string.IsNullOrEmpty(actualLines[i]), $"Actual line #{i} beyond expected lines is not empty: {actualLines[i]}");`
`186`		`- }`
	`183`	`+ Assert.True(string.IsNullOrEmpty(actualLines[i]), $"Actual line #{i} beyond expected lines is not empty: {actualLines[i]}");`
`187`	`184`	`}`
`188`	`185`	`}`
`189`	`186`	`}`
Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ public async Task CollectCommandProviderConfigurationConsolidation(CollectArgs a`
`54`	`54`	`MockConsole console = new(200, 30);`
`55`	`55`	`int exitCode = await RunAsync(args, console).ConfigureAwait(true);`
`56`	`56`	`Assert.Equal((int)ReturnCode.Ok, exitCode);`
`57`		`- console.AssertSanitizedLinesEqual(CollectSanitizer, expectedLines: expectedSubset);`
	`57`	`+ console.AssertSanitizedLinesEqual(CollectSanitizer, expectedSubset);`
`58`	`58`
`59`	`59`	`byte[] expected = Encoding.UTF8.GetBytes(ExpectedPayload);`
`60`	`60`	`Assert.Equal(expected, args.EventStream.ToArray());`
`@@ -66,8 +66,8 @@ public async Task CollectCommandInvalidProviderConfiguration_Throws(CollectArgs`
`66`	`66`	`{`
`67`	`67`	`MockConsole console = new(200, 30);`
`68`	`68`	`int exitCode = await RunAsync(args, console).ConfigureAwait(true);`
`69`		`- Assert.Equal((int)ReturnCode.TracingError, exitCode);`
`70`		`- console.AssertSanitizedLinesEqual(CollectSanitizer, true, expectedException);`
	`69`	`+ Assert.Equal((int)ReturnCode.ArgumentError, exitCode);`
	`70`	`+ console.AssertSanitizedLinesEqual(CollectSanitizer, expectedException);`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`private static async Task<int> RunAsync(CollectArgs config, MockConsole console)`
`@@ -225,31 +225,31 @@ public static IEnumerable<object[]> InvalidProviders()`
`225`	`225`	`yield return new object[]`
`226`	`226`	`{`
`227`	`227`	`new CollectArgs(profile: new[] { "cpu-sampling" }),`
`228`		- new [] { FormatException("The specified profile 'cpu-sampling' does not apply to `dotnet-trace collect`.", "System.ArgumentException") }
	`228`	+ new [] { FormatException("The specified profile 'cpu-sampling' does not apply to `dotnet-trace collect`.") }
`229`	`229`	`};`
`230`	`230`
`231`	`231`	`yield return new object[]`
`232`	`232`	`{`
`233`	`233`	`new CollectArgs(profile: new[] { "unknown" }),`
`234`		`- new [] { FormatException("Invalid profile name: unknown", "System.ArgumentException") }`
	`234`	`+ new [] { FormatException("Invalid profile name: unknown") }`
`235`	`235`	`};`
`236`	`236`
`237`	`237`	`yield return new object[]`
`238`	`238`	`{`
`239`	`239`	`new CollectArgs(providers: new[] { "Foo:::Bar=0", "Foo:::Bar=1" }),`
`240`		`- new [] { FormatException($"Provider \"Foo\" is declared multiple times with filter arguments.", "System.ArgumentException") }`
	`240`	`+ new [] { FormatException($"Provider \"Foo\" is declared multiple times with filter arguments.") }`
`241`	`241`	`};`
`242`	`242`
`243`	`243`	`yield return new object[]`
`244`	`244`	`{`
`245`	`245`	`new CollectArgs(clrevents: "unknown"),`
`246`		`- new [] { FormatException("unknown is not a valid CLR event keyword", "System.ArgumentException") }`
	`246`	`+ new [] { FormatException("unknown is not a valid CLR event keyword") }`
`247`	`247`	`};`
`248`	`248`
`249`	`249`	`yield return new object[]`
`250`	`250`	`{`
`251`	`251`	`new CollectArgs(clrevents: "gc", clreventlevel: "unknown"),`
`252`		`- new [] { FormatException("Unknown EventLevel: unknown", "System.ArgumentException") }`
	`252`	`+ new [] { FormatException("Unknown EventLevel: unknown") }`
`253`	`253`	`};`
`254`	`254`	`}`
`255`	`255`
`@@ -277,6 +277,6 @@ private static string FormatProvider(string name, string keywordsHex, string lev`
`277`	`277`	`return string.Format("{0, -80}", display) + enabledBy;`
`278`	`278`	`}`
`279`	`279`
`280`		`- private static string FormatException(string message, string exceptionType) => $"[ERROR] {exceptionType}: {message}";`
	`280`	`+ private static string FormatException(string message) => $"[ERROR] {message}";`
`281`	`281`	`}`
`282`	`282`	`}`
Original file line number	Diff line number	Diff line change
`@@ -47,12 +47,12 @@ public void CollectLinuxCommandProviderConfigurationConsolidation(object testArg`
`47`	`47`	`if (OperatingSystem.IsLinux())`
`48`	`48`	`{`
`49`	`49`	`Assert.Equal((int)ReturnCode.Ok, exitCode);`
`50`		`- console.AssertSanitizedLinesEqual(CollectLinuxSanitizer, expectedLines: expectedLines);`
	`50`	`+ console.AssertSanitizedLinesEqual(CollectLinuxSanitizer, expectedLines);`
`51`	`51`	`}`
`52`	`52`	`else`
`53`	`53`	`{`
`54`	`54`	`Assert.Equal((int)ReturnCode.PlatformNotSupportedError, exitCode);`
`55`		`- console.AssertSanitizedLinesEqual(null, expectedLines: new string[] {`
	`55`	`+ console.AssertSanitizedLinesEqual(null, new string[] {`
`56`	`56`	`"The collect-linux command is only supported on Linux.",`
`57`	`57`	`});`
`58`	`58`	`}`
`@@ -66,13 +66,13 @@ public void CollectLinuxCommandProviderConfigurationConsolidation_Throws(object`
`66`	`66`	`int exitCode = Run(testArgs, console);`
`67`	`67`	`if (OperatingSystem.IsLinux())`
`68`	`68`	`{`
`69`		`- Assert.Equal((int)ReturnCode.TracingError, exitCode);`
`70`		`- console.AssertSanitizedLinesEqual(null, true, expectedLines: expectedException);`
	`69`	`+ Assert.Equal((int)ReturnCode.ArgumentError, exitCode);`
	`70`	`+ console.AssertSanitizedLinesEqual(null, expectedException);`
`71`	`71`	`}`
`72`	`72`	`else`
`73`	`73`	`{`
`74`	`74`	`Assert.Equal((int)ReturnCode.PlatformNotSupportedError, exitCode);`
`75`		`- console.AssertSanitizedLinesEqual(null, expectedLines: new string[] {`
	`75`	`+ console.AssertSanitizedLinesEqual(null, new string[] {`
`76`	`76`	`"The collect-linux command is only supported on Linux.",`
`77`	`77`	`});`
`78`	`78`	`}`
`@@ -197,31 +197,31 @@ public static IEnumerable<object[]> InvalidProviders()`
`197`	`197`	`yield return new object[]`
`198`	`198`	`{`
`199`	`199`	`TestArgs(profile: new[] { "dotnet-sampled-thread-time" }),`
`200`		- new [] { FormatException("The specified profile 'dotnet-sampled-thread-time' does not apply to `dotnet-trace collect-linux`.", "System.ArgumentException") }
	`200`	+ new [] { FormatException("The specified profile 'dotnet-sampled-thread-time' does not apply to `dotnet-trace collect-linux`.") }
`201`	`201`	`};`
`202`	`202`
`203`	`203`	`yield return new object[]`
`204`	`204`	`{`
`205`	`205`	`TestArgs(profile: new[] { "unknown" }),`
`206`		`- new [] { FormatException("Invalid profile name: unknown", "System.ArgumentException") }`
	`206`	`+ new [] { FormatException("Invalid profile name: unknown") }`
`207`	`207`	`};`
`208`	`208`
`209`	`209`	`yield return new object[]`
`210`	`210`	`{`
`211`	`211`	`TestArgs(providers: new[] { "Foo:::Bar=0", "Foo:::Bar=1" }),`
`212`		`- new [] { FormatException($"Provider \"Foo\" is declared multiple times with filter arguments.", "System.ArgumentException") }`
	`212`	`+ new [] { FormatException($"Provider \"Foo\" is declared multiple times with filter arguments.") }`
`213`	`213`	`};`
`214`	`214`
`215`	`215`	`yield return new object[]`
`216`	`216`	`{`
`217`	`217`	`TestArgs(clrEvents: "unknown"),`
`218`		`- new [] { FormatException("unknown is not a valid CLR event keyword", "System.ArgumentException") }`
	`218`	`+ new [] { FormatException("unknown is not a valid CLR event keyword") }`
`219`	`219`	`};`
`220`	`220`
`221`	`221`	`yield return new object[]`
`222`	`222`	`{`
`223`	`223`	`TestArgs(clrEvents: "gc", clrEventLevel: "unknown"),`
`224`		`- new [] { FormatException("Unknown EventLevel: unknown", "System.ArgumentException") }`
	`224`	`+ new [] { FormatException("Unknown EventLevel: unknown") }`
`225`	`225`	`};`
`226`	`226`	`}`
`227`	`227`
`@@ -236,7 +236,7 @@ private static string FormatProvider(string name, string keywordsHex, string lev`
`236`	`236`	`string.Format("{0, -8}", $"{levelName}({levelValue})");`
`237`	`237`	`return string.Format("{0, -80}", display) + enabledBy;`
`238`	`238`	`}`
`239`		`- private static string FormatException(string message, string exceptionType) => $"[ERROR] {exceptionType}: {message}";`
	`239`	`+ private static string FormatException(string message) => $"[ERROR] {message}";`
`240`	`240`	`private static string DefaultOutputFile => $"Output File : {Directory.GetCurrentDirectory() + Path.DirectorySeparatorChar}trace.nettrace";`
`241`	`241`	`private static readonly string[] CommonTail = [`
`242`	`242`	`DefaultOutputFile,`