add some basic tests to assert on activity presence and shapes

Author: baronfel

src/System.CommandLine.Tests/ObservabilityTests.cs

@@ -0,0 +1,117 @@
+using System.CommandLine.Parsing;
+using FluentAssertions;
+using System.Linq;
+using Xunit;
+using System.Diagnostics;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace System.CommandLine.Tests
+{
+    public class ObservabilityTests
+    {
+
+        [Fact]
+        public void It_creates_activity_spans_for_parsing()
+        {
+            List<Activity> activities = SetupListener();
+
+            var command = new Command("the-command")
+            {
+                new Option<string>("--option")
+            };
+
+            var args = new[] { "--option", "the-argument" };
+
+            var result = command.Parse(args);
+
+            activities
+                    .Should()
+                    .ContainSingle(
+                        a => a.OperationName == "System.CommandLine.Parse"
+                             && a.Status == ActivityStatusCode.Ok
+                             && a.Tags.Any(t => t.Key == "command" && t.Value == "the-command"));
+        }
+
+        [Fact]
+        public void It_creates_activity_spans_for_parsing_errors()
+        {
+            List<Activity> activities = SetupListener();
+
+            var command = new Command("the-command")
+            {
+                new Option<string>("--option")
+            };
+
+            var args = new[] { "--opt", "the-argument" };
+            var result = command.Parse(args);
+
+            activities
+                    .Should()
+                    .ContainSingle(
+                        a => a.OperationName == "System.CommandLine.Parse"
+                             && a.Status == ActivityStatusCode.Error
+                             && a.Tags.Any(t => t.Key == "command" && t.Value == "the-command")
+                             && a.Baggage.Any(t => t.Key == "errors"));
+        }
+
+        [Fact]
+        public async Task It_creates_activity_spans_for_invocations()
+        {
+            List<Activity> activities = SetupListener();
+
+            var command = new Command("the-command");
+            command.SetAction(async (pr, ctok) => await Task.FromResult(0));
+
+            var result = await command.Parse(Array.Empty<string>()).InvokeAsync();
+
+            activities
+                    .Should()
+                    .ContainSingle(
+                        a => a.OperationName == "System.CommandLine.Invoke"
+                             && a.DisplayName == "the-command"
+                             && a.Status == ActivityStatusCode.Ok
+                             && a.Tags.Any(t => t.Key == "command" && t.Value == "the-command")
+                             && a.Tags.Any(t => t.Key == "invoke.type" && t.Value == "async")
+                             && a.TagObjects.Any(t => t.Key == "exitcode" && (int)t.Value == 0));
+        }
+
+        [Fact]
+        public async Task It_creates_activity_spans_for_invocation_errors()
+        {
+            List<Activity> activities = SetupListener();
+
+            var command = new Command("the-command");
+#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
+            command.SetAction(async (pr, ctok) =>
+            {
+                throw new Exception("Something went wrong");
+            });
+#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
+
+            var result = await command.Parse(Array.Empty<string>()).InvokeAsync();
+
+            activities
+                    .Should()
+                    .ContainSingle(
+                        a => a.OperationName == "System.CommandLine.Invoke"
+                             && a.DisplayName == "the-command"
+                             && a.Status == ActivityStatusCode.Error
+                             && a.Tags.Any(t => t.Key == "command" && t.Value == "the-command")
+                             && a.Tags.Any(t => t.Key == "invoke.type" && t.Value == "async")
+                             && a.TagObjects.Any(t => t.Key == "exitcode" && (int)t.Value == 1)
+                             && a.Baggage.Any(t => t.Key == "exception"));
+        }
+
+        private static List<Activity> SetupListener()
+        {
+            List<Activity> activities = new();
+            var listener = new ActivityListener();
+            listener.ShouldListenTo = s => true;
+            listener.Sample = (ref ActivityCreationOptions<ActivityContext> options) => ActivitySamplingResult.AllData;
+            listener.ActivityStopped = a => activities.Add(a);
+            ActivitySource.AddActivityListener(listener);
+            return activities;
+        }
+    }
+}

src/System.CommandLine/Activities.cs

@@ -7,12 +7,13 @@ 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 const string InvokeType = "invoke.type";
+    internal const string Async = "async";
+    internal const string Sync = "sync";
+    internal const string ExitCode = "exitcode";
+    internal const string Exception = "exception";
+    internal const string Errors = "errors";
+    internal const string Command = "command";
 }
 
 internal static class Activities

src/System.CommandLine/Parsing/CommandLineParser.cs

@@ -163,12 +163,15 @@ private static ParseResult Parse(
                 rawInput);
 
             var result = operation.Parse();
-            parseActivity?.AddBaggage(DiagnosticsStrings.Command, result.CommandResult?.Command.Name);
+            parseActivity?.SetTag(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)));
-
+                parseActivity?.AddBaggage(DiagnosticsStrings.Errors, string.Join("\n", result.Errors.Select(e => e.Message)));
+            }
+            else
+            {
+                parseActivity?.SetStatus(Diagnostics.ActivityStatusCode.Ok);
             }
             return result;
         }