feat(otel): add otel tracing for standalone activities.

Author: cconstable

src/Temporalio.Extensions.OpenTelemetry/TracingInterceptor.cs

@@ -232,6 +232,21 @@ protected virtual IDictionary<string, string> HeadersFromContext(
             return ret;
         }
 
+        /// <summary>
+        /// Create tag collection for the given standalone activity ID.
+        /// </summary>
+        /// <param name="activityId">Standalone activity ID.</param>
+        /// <returns>Tags.</returns>
+        protected virtual IEnumerable<KeyValuePair<string, object?>> CreateStandaloneActivityTags(
+            string activityId)
+        {
+            if (Options.TagNameActivityId is string name)
+            {
+                return new KeyValuePair<string, object?>[] { new(name, activityId) };
+            }
+            return Enumerable.Empty<KeyValuePair<string, object?>>();
+        }
+
         private static void RecordExceptionWithStatus(Activity? activity, Exception exception)
         {
             // If the exception is a benign exception, we do not consider the status an error. Note,
@@ -395,6 +410,112 @@ public override async Task<WorkflowUpdateHandle<TResult>> StartWorkflowUpdateAsy
                 }
             }
 
+            public override async Task<ActivityHandle<TResult>> StartActivityAsync<TResult>(
+                StartActivityInput input)
+            {
+                using (var activity = ClientSource.StartActivity(
+                    $"StartActivity:{input.Activity}",
+                    kind: ActivityKind.Client,
+                    parentContext: default,
+                    tags: input.Options.Id is string id ? root.CreateStandaloneActivityTags(id) : null))
+                {
+                    if (HeadersFromContext(input.Headers) is Dictionary<string, Payload> headers)
+                    {
+                        input = input with { Headers = headers };
+                    }
+                    try
+                    {
+                        return await base.StartActivityAsync<TResult>(input).ConfigureAwait(false);
+                    }
+                    catch (Exception e)
+                    {
+                        RecordExceptionWithStatus(activity, e);
+                        throw;
+                    }
+                }
+            }
+
+            public override async Task<ActivityExecutionDescription> DescribeActivityAsync(
+                DescribeActivityInput input)
+            {
+                using (var activity = ClientSource.StartActivity(
+                    $"DescribeActivity:{input.Id}",
+                    kind: ActivityKind.Client,
+                    parentContext: default,
+                    tags: root.CreateStandaloneActivityTags(input.Id)))
+                {
+                    try
+                    {
+                        return await base.DescribeActivityAsync(input).ConfigureAwait(false);
+                    }
+                    catch (Exception e)
+                    {
+                        RecordExceptionWithStatus(activity, e);
+                        throw;
+                    }
+                }
+            }
+
+            public override async Task CancelActivityAsync(CancelActivityInput input)
+            {
+                using (var activity = ClientSource.StartActivity(
+                    $"CancelActivity:{input.Id}",
+                    kind: ActivityKind.Client,
+                    parentContext: default,
+                    tags: root.CreateStandaloneActivityTags(input.Id)))
+                {
+                    try
+                    {
+                        await base.CancelActivityAsync(input).ConfigureAwait(false);
+                    }
+                    catch (Exception e)
+                    {
+                        RecordExceptionWithStatus(activity, e);
+                        throw;
+                    }
+                }
+            }
+
+            public override async Task TerminateActivityAsync(TerminateActivityInput input)
+            {
+                using (var activity = ClientSource.StartActivity(
+                    $"TerminateActivity:{input.Id}",
+                    kind: ActivityKind.Client,
+                    parentContext: default,
+                    tags: root.CreateStandaloneActivityTags(input.Id)))
+                {
+                    try
+                    {
+                        await base.TerminateActivityAsync(input).ConfigureAwait(false);
+                    }
+                    catch (Exception e)
+                    {
+                        RecordExceptionWithStatus(activity, e);
+                        throw;
+                    }
+                }
+            }
+
+            public override async Task<ActivityExecutionCount> CountActivitiesAsync(
+                CountActivitiesInput input)
+            {
+                using (var activity = ClientSource.StartActivity(
+                    "CountActivities",
+                    kind: ActivityKind.Client,
+                    parentContext: default))
+                {
+                    try
+                    {
+                        return await base.CountActivitiesAsync(input).ConfigureAwait(false);
+                    }
+                    catch (Exception e)
+                    {
+                        RecordExceptionWithStatus(activity, e);
+                        throw;
+                    }
+                }
+            }
+
             /// <summary>
             /// Serialize current context to headers if one exists.
             /// </summary>

tests/Temporalio.Tests/Extensions/OpenTelemetry/TracingInterceptorTests.cs

@@ -797,6 +797,36 @@ public async Task TracingInterceptor_Nexus_HasTracing()
                 "RunWorkflow:TracingWorkflow"));
     }
 
+    [Fact]
+    public async Task TracingInterceptor_StandaloneActivity_HasProperSpans()
+    {
+        var activityId = $"act-{Guid.NewGuid()}";
+        var spans = await WithTracingWorkerAsync(async (client, _) =>
+        {
+            var taskQueue = $"standalone-tq-{Guid.NewGuid()}";
+            var handle = await client.StartActivityAsync(
+                "StandaloneActivity",
+                Array.Empty<object?>(),
+                new(activityId, taskQueue)
+                {
+                    ScheduleToCloseTimeout = TimeSpan.FromMinutes(5),
+                });
+            await handle.DescribeAsync();
+            await handle.CancelAsync();
+            await handle.TerminateAsync();
+            await client.CountActivitiesAsync($"ActivityId = '{activityId}'");
+        });
+
+        var activityTags = new[] { ActivityAssertion.TagEqual("temporalActivityID", activityId) };
+        AssertActivities(
+            spans,
+            new("StartActivity:StandaloneActivity", Parent: null, Tags: activityTags),
+            new("DescribeActivity:" + activityId, Parent: null, Tags: activityTags),
+            new("CancelActivity:" + activityId, Parent: null, Tags: activityTags),
+            new("TerminateActivity:" + activityId, Parent: null, Tags: activityTags),
+            new(Name: "CountActivities", Parent: null, IgnoreTags: true));
+    }
+
     private static void AssertActivities(
         IReadOnlyCollection<Activity> activities, params ActivityAssertion[] assertions)
     {