Create spans for parsing and invocation of S.CL commands

Author: baronfel

Directory.Packages.props

@@ -24,7 +24,8 @@
     <PackageVersion Include="Microsoft.CSharp" Version="4.7.0" />
     <PackageVersion Include="Microsoft.DotNet.PlatformAbstractions" Version="3.1.6" />
     <PackageVersion Include="Newtonsoft.Json" Version="13.0.2" />
-    <PackageVersion Include="System.Memory" Version="4.5.4" />
+    <PackageVersion Include="System.Memory" Version="4.5.5" />
+    <PackageVersion Include="System.Diagnostics.DiagnosticSource" Version="8.0.1" />
     <PackageVersion Include="system.reactive.core" Version="5.0.0" />
   </ItemGroup>
 

src/System.CommandLine/Activities.cs

@@ -0,0 +1,45 @@
+using System.Diagnostics;
+
+namespace System.CommandLine;
+
+internal static class DiagnosticsStrings
+{
+    internal const string LibraryNamespace = "System.CommandLine";
+    internal const string ParseMethod = LibraryNamespace + ".Parse";
+    internal const string InvokeMethod = LibraryNamespace + ".Invoke";
+    internal const string InvokeType = nameof(InvokeType);
+    internal const string Async = nameof(Async);
+    internal const string Sync = nameof(Sync);
+    internal const string ExitCode = nameof(ExitCode);
+    internal const string Exception = nameof(Exception);
+    internal const string Command = nameof(Command);
+}
+
+internal static class Activities
+{
+    internal static readonly ActivitySource ActivitySource = new ActivitySource(DiagnosticsStrings.LibraryNamespace);
+}
+
+internal static class ActivityExtensions
+{
+
+    /// <summary>
+    /// Walks up the command tree to get the build the command name by prepending the parent command names to the 'leaf' command name.
+    /// </summary>
+    /// <param name="commandResult"></param>
+    /// <returns>The full command name, like 'dotnet package add'.</returns>
+    internal static string FullCommandName(this Parsing.CommandResult commandResult)
+    {
+        var command = commandResult.Command;
+        var path = command.Name;
+
+        while (commandResult.Parent is Parsing.CommandResult parent)
+        {
+            command = parent.Command;
+            path = $"{command.Name} {path}";
+            commandResult = parent;
+        }
+
+        return path;
+    }
+}

src/System.CommandLine/Invocation/InvocationPipeline.cs

@@ -1,6 +1,7 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -10,8 +11,17 @@ internal static class InvocationPipeline
     {
         internal static async Task<int> InvokeAsync(ParseResult parseResult, CancellationToken cancellationToken)
         {
+            using var invokeActivity = Activities.ActivitySource.StartActivity(DiagnosticsStrings.InvokeMethod);
+            if (invokeActivity is not null)
+            {
+                invokeActivity.DisplayName = parseResult.CommandResult.FullCommandName();
+                invokeActivity.AddTag(DiagnosticsStrings.Command, parseResult.CommandResult.Command.Name);
+                invokeActivity.AddTag(DiagnosticsStrings.InvokeType, DiagnosticsStrings.Async);
+            }
+
             if (parseResult.Action is null)
             {
+                invokeActivity?.SetStatus(Diagnostics.ActivityStatusCode.Error);
                 return ReturnCodeForMissingAction(parseResult);
             }
 
@@ -41,7 +51,9 @@ internal static async Task<int> InvokeAsync(ParseResult parseResult, Cancellatio
                 switch (parseResult.Action)
                 {
                     case SynchronousCommandLineAction syncAction:
-                        return syncAction.Invoke(parseResult);
+                        var syncResult = syncAction.Invoke(parseResult);
+                        invokeActivity?.SetExitCode(syncResult);
+                        return syncResult;
 
                     case AsynchronousCommandLineAction asyncAction:
                         var startedInvocation = asyncAction.InvokeAsync(parseResult, cts.Token);
@@ -52,23 +64,30 @@ internal static async Task<int> InvokeAsync(ParseResult parseResult, Cancellatio
 
                         if (terminationHandler is null)
                         {
-                            return await startedInvocation;
+                            var asyncResult = await startedInvocation;
+                            invokeActivity?.SetExitCode(asyncResult);
+                            return asyncResult;
                         }
                         else
                         {
                             // Handlers may not implement cancellation.
                             // In such cases, when CancelOnProcessTermination is configured and user presses Ctrl+C,
                             // ProcessTerminationCompletionSource completes first, with the result equal to native exit code for given signal.
                             Task<int> firstCompletedTask = await Task.WhenAny(startedInvocation, terminationHandler.ProcessTerminationCompletionSource.Task);
-                            return await firstCompletedTask; // return the result or propagate the exception
+                            var asyncResult = await firstCompletedTask;  // return the result or propagate the exception
+                            invokeActivity?.SetExitCode(asyncResult);
+                            return asyncResult;
                         }
 
                     default:
-                        throw new ArgumentOutOfRangeException(nameof(parseResult.Action));
+                        var error = new ArgumentOutOfRangeException(nameof(parseResult.Action));
+                        invokeActivity?.Error(error);
+                        throw error;
                 }
             }
             catch (Exception ex) when (parseResult.Configuration.EnableDefaultExceptionHandler)
             {
+                invokeActivity?.Error(ex);
                 return DefaultExceptionHandler(ex, parseResult.Configuration);
             }
             finally
@@ -79,9 +98,18 @@ internal static async Task<int> InvokeAsync(ParseResult parseResult, Cancellatio
 
         internal static int Invoke(ParseResult parseResult)
         {
+            using var invokeActivity = Activities.ActivitySource.StartActivity(DiagnosticsStrings.InvokeMethod);
+            if (invokeActivity is not null)
+            {
+                invokeActivity.DisplayName = parseResult.CommandResult.FullCommandName();
+                invokeActivity.AddTag(DiagnosticsStrings.Command, parseResult.CommandResult.Command.Name);
+                invokeActivity.AddTag(DiagnosticsStrings.InvokeType, DiagnosticsStrings.Sync);
+            }
+
             switch (parseResult.Action)
             {
                 case null:
+                    invokeActivity?.Error();
                     return ReturnCodeForMissingAction(parseResult);
 
                 case SynchronousCommandLineAction syncAction:
@@ -112,15 +140,20 @@ internal static int Invoke(ParseResult parseResult)
                             }
                         }
 
-                        return syncAction.Invoke(parseResult);
+                        var result = syncAction.Invoke(parseResult);
+                        invokeActivity?.SetExitCode(result);
+                        return result;
                     }
                     catch (Exception ex) when (parseResult.Configuration.EnableDefaultExceptionHandler)
                     {
+                        invokeActivity?.Error(ex);
                         return DefaultExceptionHandler(ex, parseResult.Configuration);
                     }
 
                 default:
-                    throw new InvalidOperationException($"{nameof(AsynchronousCommandLineAction)} called within non-async invocation.");
+                    var error = new InvalidOperationException($"{nameof(AsynchronousCommandLineAction)} called within non-async invocation.");
+                    invokeActivity?.Error(error);
+                    throw error;
             }
         }
 
@@ -150,5 +183,38 @@ private static int ReturnCodeForMissingAction(ParseResult parseResult)
                 return 0;
             }
         }
+
+        private static void Succeed(this Diagnostics.Activity activity)
+        {
+            activity.SetStatus(Diagnostics.ActivityStatusCode.Ok);
+            activity.AddTag(DiagnosticsStrings.ExitCode, 0);
+        }
+        private static void Error(this Diagnostics.Activity activity, int statusCode)
+        {
+            activity.SetStatus(Diagnostics.ActivityStatusCode.Error);
+            activity.AddTag(DiagnosticsStrings.ExitCode, statusCode);
+        }
+
+        private static void Error(this Diagnostics.Activity activity, Exception? exception = null)
+        {
+            activity.SetStatus(Diagnostics.ActivityStatusCode.Error);
+            activity.AddTag(DiagnosticsStrings.ExitCode, 1);
+            if (exception is not null)
+            {
+                activity.AddBaggage(DiagnosticsStrings.Exception, exception.ToString());
+            }
+        }
+
+        private static void SetExitCode(this Diagnostics.Activity activity, int exitCode)
+        {
+            if (exitCode == 0)
+            {
+                activity.Succeed();
+            }
+            else
+            {
+                activity.Error(exitCode);
+            }
+        }
     }
 }

src/System.CommandLine/ParseResult.cs

@@ -236,6 +236,7 @@ public Task<int> InvokeAsync(CancellationToken cancellationToken = default)
         /// <returns>A value that can be used as a process exit code.</returns>
         public int Invoke()
         {
+
             var useAsync = false;
 
             if (Action is AsynchronousCommandLineAction)

src/System.CommandLine/Parsing/CommandLineParser.cs

@@ -146,6 +146,8 @@ private static ParseResult Parse(
                 throw new ArgumentNullException(nameof(arguments));
             }
 
+            using var parseActivity = Activities.ActivitySource.StartActivity(DiagnosticsStrings.ParseMethod);
+
             configuration ??= new CommandLineConfiguration(command);
 
             arguments.Tokenize(
@@ -160,7 +162,15 @@ private static ParseResult Parse(
                 tokenizationErrors,
                 rawInput);
 
-            return operation.Parse();
+            var result = operation.Parse();
+            parseActivity?.AddBaggage(DiagnosticsStrings.Command, result.CommandResult?.Command.Name);
+            if (result.Errors.Count == 0)
+            {
+                parseActivity?.SetStatus(Diagnostics.ActivityStatusCode.Error);
+                parseActivity?.AddBaggage("Errors", string.Join("\n", result.Errors.Select(e => e.Message)));
+
+            }
+            return result;
         }
 
         private enum Boundary

src/System.CommandLine/System.CommandLine.csproj

@@ -27,6 +27,7 @@
 
   <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
     <PackageReference Include="System.Memory" />
+    <PackageReference Include="System.Diagnostics.DiagnosticSource" />
   </ItemGroup>
 
   <ItemGroup>