[DotnetTrace][CollectLinux] Add ProgressStatus and output file to tests

Author: mdh1418

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

@@ -135,10 +135,6 @@ private byte[] BuildRecordTraceArgs(CollectLinuxArgs args, out string scriptPath
             scriptPath = null;
             List<string> recordTraceArgs = new();
 
-            string resolvedOutput = ResolveOutputPath(args.Output);
-            recordTraceArgs.Add($"--out");
-            recordTraceArgs.Add(resolvedOutput);
-
             string[] profiles = args.Profiles;
             if (args.Profiles.Length == 0 && args.Providers.Length == 0 && string.IsNullOrEmpty(args.ClrEvents) && args.PerfEvents.Length == 0)
             {
@@ -169,17 +165,18 @@ private byte[] BuildRecordTraceArgs(CollectLinuxArgs args, out string scriptPath
                 scriptBuilder.Append($"record_dotnet_provider(\"{providerName}\", 0x{keywords:X}, {eventLevel}, {providerNameSanitized}_flags);\n\n");
             }
 
-            Console.WriteLine($"{("Linux Events"),-80}Enabled By");
+            List<string> linuxEventLines = new();
             foreach (string profile in profiles)
             {
                 Profile traceProfile = ListProfilesCommandHandler.TraceProfiles
                     .FirstOrDefault(p => p.Name.Equals(profile, StringComparison.OrdinalIgnoreCase));
 
-                if (!string.IsNullOrEmpty(traceProfile.VerbExclusivity) &&
+                if (traceProfile != null &&
+                    !string.IsNullOrEmpty(traceProfile.VerbExclusivity) &&
                     traceProfile.VerbExclusivity.Equals("collect-linux", StringComparison.OrdinalIgnoreCase))
                 {
                     recordTraceArgs.Add(traceProfile.CollectLinuxArgs);
-                    Console.WriteLine($"{traceProfile.Name,-80}--profile");
+                    linuxEventLines.Add($"{traceProfile.Name,-80}--profile");
                 }
             }
 
@@ -193,14 +190,32 @@ private byte[] BuildRecordTraceArgs(CollectLinuxArgs args, out string scriptPath
 
                 string perfProvider = split[0];
                 string perfEventName = split[1];
-                Console.WriteLine($"{perfEvent,-80}--perf-events");
+                linuxEventLines.Add($"{perfEvent,-80}--perf-events");
                 scriptBuilder.Append($"let {perfEventName} = event_from_tracefs(\"{perfProvider}\", \"{perfEventName}\");\nrecord_event({perfEventName});\n\n");
             }
+
+            if (linuxEventLines.Count > 0)
+            {
+                Console.WriteLine($"{("Linux Perf Events"),-80}Enabled By");
+                foreach (string line in linuxEventLines)
+                {
+                    Console.WriteLine(line);
+                }
+            }
+            else
+            {
+                Console.WriteLine("No Linux Perf Events enabled.");
+            }
+            Console.WriteLine();
+
+            FileInfo resolvedOutput = ResolveOutputPath(args.Output);
+            recordTraceArgs.Add($"--out");
+            recordTraceArgs.Add(resolvedOutput.FullName);
+            Console.WriteLine($"Output File    : {resolvedOutput.FullName}");
             Console.WriteLine();
 
             string scriptText = scriptBuilder.ToString();
-            string scriptFileName = $"{Path.GetFileNameWithoutExtension(resolvedOutput)}.script";
-            scriptPath = Path.Combine(Environment.CurrentDirectory, scriptFileName);
+            scriptPath = Path.ChangeExtension(resolvedOutput.FullName, ".script");
             File.WriteAllText(scriptPath, scriptText);
 
             recordTraceArgs.Add("--script-file");
@@ -210,15 +225,15 @@ private byte[] BuildRecordTraceArgs(CollectLinuxArgs args, out string scriptPath
             return Encoding.UTF8.GetBytes(options);
         }
 
-        private static string ResolveOutputPath(FileInfo output)
+        private static FileInfo ResolveOutputPath(FileInfo output)
         {
             if (!string.Equals(output.Name, CommonOptions.DefaultTraceName, StringComparison.OrdinalIgnoreCase))
             {
-                return output.Name;
+                return output;
             }
 
             DateTime now = DateTime.Now;
-            return $"trace_{now:yyyyMMdd}_{now:HHmmss}.nettrace";
+            return new FileInfo($"trace_{now:yyyyMMdd}_{now:HHmmss}.nettrace");
         }
 
         private int OutputHandler(uint type, IntPtr data, UIntPtr dataLen)

src/tests/dotnet-trace/CollectLinuxCommandFunctionalTests.cs

@@ -34,7 +34,7 @@ private static CollectLinuxCommandHandler.CollectLinuxArgs TestArgs(
                                                                    clrEvents,
                                                                    perfEvents ?? Array.Empty<string>(),
                                                                    profile ?? Array.Empty<string>(),
-                                                                   output ?? new FileInfo(CommonOptions.DefaultTraceName),
+                                                                   output ?? new FileInfo("trace.nettrace"),
                                                                    duration);
         }
 
@@ -47,7 +47,7 @@ public void CollectLinuxCommandProviderConfigurationConsolidation(object testArg
             if (OperatingSystem.IsLinux())
             {
                 Assert.Equal((int)ReturnCode.Ok, exitCode);
-                console.AssertSanitizedLinesEqual(null, expectedLines: expectedLines);
+                console.AssertSanitizedLinesEqual(CollectLinuxSanitizer, expectedLines: expectedLines);
             }
             else
             {
@@ -81,138 +81,114 @@ public void CollectLinuxCommandProviderConfigurationConsolidation_Throws(object
         private static int Run(object args, MockConsole console)
         {
             var handler = new CollectLinuxCommandHandler(console);
-            handler.RecordTraceInvoker = (cmd, len, cb) => 0;
+            handler.RecordTraceInvoker = (cmd, len, cb) => {
+                cb(3, IntPtr.Zero, UIntPtr.Zero);
+                return 0;
+            };
             return handler.CollectLinux((CollectLinuxCommandHandler.CollectLinuxArgs)args);
         }
 
+        private static string[] CollectLinuxSanitizer(string[] lines)
+        {
+            List<string> result = new();
+            foreach (string line in lines)
+            {
+                if (line.Contains("Recording trace.", StringComparison.OrdinalIgnoreCase))
+                {
+                    result.Add("[dd:hh:mm:ss]\tRecording trace.");
+                }
+                else
+                {
+                    result.Add(line);
+                }
+            }
+            return result.ToArray();
+        }
 
         public static IEnumerable<object[]> BasicCases()
         {
             yield return new object[] {
                 TestArgs(),
-                new string[] {
-                    "No providers, profiles, ClrEvents, or PerfEvents were specified, defaulting to trace profiles 'dotnet-common' + 'cpu-sampling'.",
-                    "",
-                    ProviderHeader,
-                    FormatProvider("Microsoft-Windows-DotNETRuntime","000000100003801D","Informational",4,"--profile"),
-                    "",
-                    LinuxHeader,
-                    LinuxProfile("cpu-sampling"),
-                    ""
-                }
+                ExpectProvidersAndLinuxWithMessages(
+                    new[]{"No providers, profiles, ClrEvents, or PerfEvents were specified, defaulting to trace profiles 'dotnet-common' + 'cpu-sampling'."},
+                    new[]{FormatProvider("Microsoft-Windows-DotNETRuntime","000000100003801D","Informational",4,"--profile")},
+                    new[]{LinuxProfile("cpu-sampling")})
             };
+
             yield return new object[] {
                 TestArgs(providers: new[]{"Foo:0x1:4"}),
-                new string[] {
-                    "",
-                    ProviderHeader,
-                    FormatProvider("Foo","0000000000000001","Informational",4,"--providers"),
-                    "",
-                    LinuxHeader,
-                    ""
-                }
+                ExpectProvidersAndLinux(
+                    new[]{FormatProvider("Foo","0000000000000001","Informational",4,"--providers")},
+                    Array.Empty<string>())
             };
+
             yield return new object[] {
                 TestArgs(providers: new[]{"Foo:0x1:4","Bar:0x2:4"}),
-                new string[] {
-                    "",
-                    ProviderHeader,
-                    FormatProvider("Foo","0000000000000001","Informational",4,"--providers"),
-                    FormatProvider("Bar","0000000000000002","Informational",4,"--providers"),
-                    "",
-                    LinuxHeader,
-                    ""
-                }
+                ExpectProvidersAndLinux(
+                    new[]{
+                        FormatProvider("Foo","0000000000000001","Informational",4,"--providers"),
+                        FormatProvider("Bar","0000000000000002","Informational",4,"--providers")
+                    },
+                    Array.Empty<string>())
             };
+
             yield return new object[] {
                 TestArgs(profile: new[]{"cpu-sampling"}),
-                new string[] {
-                    "No .NET providers were configured.",
-                    "",
-                    LinuxHeader,
-                    LinuxProfile("cpu-sampling"),
-                    ""
-                }
+                ExpectProvidersAndLinuxWithMessages(
+                    new[]{"No .NET providers were configured."},
+                    Array.Empty<string>(),
+                    new[]{LinuxProfile("cpu-sampling")})
             };
+
             yield return new object[] {
                 TestArgs(providers: new[]{"Foo:0x1:4"}, profile: new[]{"cpu-sampling"}),
-                new string[] {
-                    "",
-                    ProviderHeader,
-                    FormatProvider("Foo","0000000000000001","Informational",4,"--providers"),
-                    "",
-                    LinuxHeader,
-                    LinuxProfile("cpu-sampling"),
-                    ""
-                }
+                ExpectProvidersAndLinux(
+                    new[]{FormatProvider("Foo","0000000000000001","Informational",4,"--providers")},
+                    new[]{LinuxProfile("cpu-sampling")})
             };
+
             yield return new object[] {
                 TestArgs(clrEvents: "gc", profile: new[]{"cpu-sampling"}),
-                new string[] {
-                    "",
-                    ProviderHeader,
-                    FormatProvider("Microsoft-Windows-DotNETRuntime","0000000000000001","Informational",4,"--clrevents"),
-                    "",
-                    LinuxHeader,
-                    LinuxProfile("cpu-sampling"),
-                    ""
-                }
+                ExpectProvidersAndLinux(
+                    new[]{FormatProvider("Microsoft-Windows-DotNETRuntime","0000000000000001","Informational",4,"--clrevents")},
+                    new[]{LinuxProfile("cpu-sampling")})
             };
+
             yield return new object[] {
                 TestArgs(providers: new[]{"Microsoft-Windows-DotNETRuntime:0x1:4"}, profile: new[]{"cpu-sampling"}),
-                new string[] {
-                    "",
-                    ProviderHeader,
-                    FormatProvider("Microsoft-Windows-DotNETRuntime","0000000000000001","Informational",4,"--providers"),
-                    "",
-                    LinuxHeader,
-                    LinuxProfile("cpu-sampling"),
-                    ""
-                }
+                ExpectProvidersAndLinux(
+                    new[]{FormatProvider("Microsoft-Windows-DotNETRuntime","0000000000000001","Informational",4,"--providers")},
+                    new[]{LinuxProfile("cpu-sampling")})
             };
+
             yield return new object[] {
                 TestArgs(providers: new[]{"Microsoft-Windows-DotNETRuntime:0x1:4"}, clrEvents: "gc"),
-                new string[] {
-                    "Warning: The CLR provider was already specified through --providers or --profile. Ignoring --clrevents.",
-                    "",
-                    ProviderHeader,
-                    FormatProvider("Microsoft-Windows-DotNETRuntime","0000000000000001","Informational",4,"--providers"),
-                    "",
-                    LinuxHeader,
-                    ""
-                }
+                ExpectProvidersAndLinuxWithMessages(
+                    new[]{"Warning: The CLR provider was already specified through --providers or --profile. Ignoring --clrevents."},
+                    new[]{FormatProvider("Microsoft-Windows-DotNETRuntime","0000000000000001","Informational",4,"--providers")},
+                    Array.Empty<string>())
             };
+
             yield return new object[] {
                 TestArgs(clrEvents: "gc+jit"),
-                new string[] {
-                    "",
-                    ProviderHeader,
-                    FormatProvider("Microsoft-Windows-DotNETRuntime","0000000000000011","Informational",4,"--clrevents"),
-                    "",
-                    LinuxHeader,
-                    ""
-                }
+                ExpectProvidersAndLinux(
+                    new[]{FormatProvider("Microsoft-Windows-DotNETRuntime","0000000000000011","Informational",4,"--clrevents")},
+                    Array.Empty<string>())
             };
+
             yield return new object[] {
                 TestArgs(clrEvents: "gc+jit", clrEventLevel: "5"),
-                new string[] {
-                    "",
-                    ProviderHeader,
-                    FormatProvider("Microsoft-Windows-DotNETRuntime","0000000000000011","Verbose",5,"--clrevents"),
-                    "",
-                    LinuxHeader,
-                    ""
-                }
+                ExpectProvidersAndLinux(
+                    new[]{FormatProvider("Microsoft-Windows-DotNETRuntime","0000000000000011","Verbose",5,"--clrevents")},
+                    Array.Empty<string>())
             };
+
             yield return new object[] {
                 TestArgs(perfEvents: new[]{"sched:sched_switch"}),
-                new string[] {
-                    "No .NET providers were configured.",
-                    "",
-                    LinuxHeader,
-                    LinuxPerfEvent("sched:sched_switch"),
-                    ""
-                }
+                ExpectProvidersAndLinuxWithMessages(
+                    new[]{"No .NET providers were configured."},
+                    Array.Empty<string>(),
+                    new[]{LinuxPerfEvent("sched:sched_switch")})
             };
         }
 
@@ -250,7 +226,7 @@ public static IEnumerable<object[]> InvalidProviders()
         }
 
         private const string ProviderHeader = "Provider Name                           Keywords            Level               Enabled By";
-        private static string LinuxHeader => $"{"Linux Events",-80}Enabled By";
+        private static string LinuxHeader => $"{"Linux Perf Events",-80}Enabled By";
         private static string LinuxProfile(string name) => $"{name,-80}--profile";
         private static string LinuxPerfEvent(string spec) => $"{spec,-80}--perf-events";
         private static string FormatProvider(string name, string keywordsHex, string levelName, int levelValue, string enabledBy)
@@ -261,5 +237,48 @@ 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 DefaultOutputFile => $"Output File    : {Directory.GetCurrentDirectory() + Path.DirectorySeparatorChar}trace.nettrace";
+        private static readonly string[] CommonTail = [
+            DefaultOutputFile,
+            "",
+            "[dd:hh:mm:ss]\tRecording trace.",
+            "Press <Enter> or <Ctrl-C> to exit...",
+        ];
+
+        private static string[] ExpectProvidersAndLinux(string[] dotnetProviders, string[] linuxPerfEvents)
+            => ExpectProvidersAndLinuxWithMessages(Array.Empty<string>(), dotnetProviders, linuxPerfEvents);
+
+        private static string[] ExpectProvidersAndLinuxWithMessages(string[] messages, string[] dotnetProviders, string[] linuxPerfEvents)
+        {
+            List<string> result = new();
+
+            if (messages.Length > 0)
+            {
+                result.AddRange(messages);
+            }
+            result.Add("");
+
+            if (dotnetProviders.Length > 0)
+            {
+                result.Add(ProviderHeader);
+                result.AddRange(dotnetProviders);
+                result.Add("");
+            }
+
+            if (linuxPerfEvents.Length > 0)
+            {
+                result.Add(LinuxHeader);
+                result.AddRange(linuxPerfEvents);
+            }
+            else
+            {
+                result.Add("No Linux Perf Events enabled.");
+            }
+            result.Add("");
+
+            result.AddRange(CommonTail);
+
+            return result.ToArray();
+        }
     }
 }