Adds the grafana stack to the microservices worker

temporal-examples/microservice-worker/AutoFac/Modules/TemporalWorkerConfigurationModule.cs

@@ -2,7 +2,9 @@
 using Autofac.Extensions.DependencyInjection;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
+using Temporalio.Client;
 using Temporalio.Extensions.Hosting;
+using Temporalio.Extensions.OpenTelemetry;
 using Temporalio.Runtime;
 using Workflows;
 
@@ -29,6 +31,8 @@ protected override void Load(ContainerBuilder builder)
             // This is using a different queue to the other worker
             var taskQueue = temporalConfig["TaskQueue"] ?? "microservice-queue";
 
+            var assemblyName = typeof(TemporalClient).Assembly.GetName();
+
             services
                 .AddTemporalClient(clientHost, clientNamespace)
                 .Configure(options =>
@@ -45,6 +49,8 @@ protected override void Load(ContainerBuilder builder)
                             },
                         }
                     );
+
+                    options.Interceptors = [new TracingInterceptor()];
                 });
 
             var workerBuilder = services

temporal-examples/microservice-worker/Program.cs

@@ -2,7 +2,11 @@
 using Autofac.Extensions.DependencyInjection;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.Hosting;
+using OpenTelemetry;
+using OpenTelemetry.Resources;
+using OpenTelemetry.Trace;
 using Shared.AutoFac.Modules;
+using Temporalio.Extensions.OpenTelemetry;
 using TemporalWorker.AutoFac.Modules;
 
 namespace TemporalWorker;
@@ -24,6 +28,20 @@ private static async Task Main(string[] args)
             )
             .Build();
 
+        var resourceBuilder = ResourceBuilder
+            .CreateDefault()
+            .AddService("TemporalExamples.OpenTelemetry", serviceInstanceId: "microservice-worker");
+
+        using var tracerProvider = Sdk.CreateTracerProviderBuilder()
+            .SetResourceBuilder(resourceBuilder)
+            .AddSource(
+                TracingInterceptor.ClientSource.Name,
+                TracingInterceptor.WorkflowsSource.Name,
+                TracingInterceptor.ActivitiesSource.Name
+            )
+            .AddOtlpExporter(o => o.Endpoint = new Uri("http://host.docker.internal:4317"))
+            .Build();
+
         await host.RunAsync();
     }
 }

temporal-examples/workflows/Microservice.workflow.cs

@@ -30,7 +30,7 @@ await Workflow.ExecuteActivityAsync(
         );
 
         bool result = await Workflow.ExecuteActivityAsync(
-            () => MicroserviceActivities.ValidateTransition("Transition to validate"),
+            (MicroserviceActivities a) => a.ValidateTransition("Transition to validate"),
             new ActivityOptions
             {
                 StartToCloseTimeout = TimeSpan.FromMinutes(5),
@@ -40,7 +40,7 @@ await Workflow.ExecuteActivityAsync(
         );
 
         await Workflow.ExecuteActivityAsync(
-            () => MicroserviceActivities.CreateSecondaryCosts(),
+            (MicroserviceActivities a) => a.CreateSecondaryCosts(),
             new ActivityOptions
             {
                 StartToCloseTimeout = TimeSpan.FromMinutes(5),
@@ -50,7 +50,7 @@ await Workflow.ExecuteActivityAsync(
         );
 
         var updateUpstream = Workflow.ExecuteActivityAsync(
-            () => MicroserviceActivities.UpdateUpstream(),
+            (MicroserviceActivities a) => a.UpdateUpstream(),
             new ActivityOptions
             {
                 StartToCloseTimeout = TimeSpan.FromMinutes(5),
@@ -60,7 +60,7 @@ await Workflow.ExecuteActivityAsync(
         );
 
         var transitionToApproved = Workflow.ExecuteActivityAsync(
-            () => MicroserviceActivities.TransitionToApproved(),
+            (MicroserviceActivities a) => a.TransitionToApproved(),
             new ActivityOptions
             {
                 StartToCloseTimeout = TimeSpan.FromMinutes(5),

temporal-examples/workflows/MicroserviceActivities.cs

@@ -1,3 +1,4 @@
+using Microsoft.Extensions.Logging;
 using Temporalio.Activities;
 
 namespace Workflows;
@@ -7,30 +8,58 @@ namespace Workflows;
 // allow a separation.
 public class MicroserviceActivities
 {
+    private readonly ILogger<MicroserviceActivities> _logger;
+
+    public MicroserviceActivities(ILogger<MicroserviceActivities> logger)
+    {
+        _logger = logger;
+    }
+
     [Activity]
-    public static async Task<bool> ValidateTransition(string transitionLocation)
+    public async Task<bool> ValidateTransition(string transitionLocation)
     {
+        var duration = 2000;
+        _logger.LogInformation("Starting delay: {Duration}", duration);
         await Task.Delay(1000);
+        _logger.LogInformation("Finished delay");
         return true;
     }
 
     [Activity]
-    public static async Task TransitionToApproved()
+    public async Task TransitionToApproved()
     {
+        ActivityExecutionContext.Current.Logger.LogInformation(
+            "Executing TransitionToApproved activity for OpenTelemetry sample."
+        );
+        var duration = 1500;
+        _logger.LogInformation("Starting delay: {Duration}", duration);
         await Task.Delay(1500);
+        _logger.LogInformation("Finished delay");
     }
 
     [Activity]
-    public static async Task<Result<string>> CreateSecondaryCosts()
+    public async Task<Result<string>> CreateSecondaryCosts()
     {
-        await Task.Delay(3000);
+        ActivityExecutionContext.Current.Logger.LogInformation(
+            "Executing CreateSecondaryCosts activity for OpenTelemetry sample."
+        );
+        var duration = 3000;
+        _logger.LogInformation("Starting delay: {Duration}", duration);
+        await Task.Delay(duration);
+        _logger.LogInformation("Finished delay");
         return new Result<string> { Value = "Created" };
     }
 
     [Activity]
-    public static async Task<Result<string>> UpdateUpstream()
+    public async Task<Result<string>> UpdateUpstream()
     {
-        await Task.Delay(5000);
+        ActivityExecutionContext.Current.Logger.LogInformation(
+            "Executing UpdateUpstream activity for OpenTelemetry sample."
+        );
+        var duration = 5000;
+        _logger.LogInformation("Starting delay: {Duration}", duration);
+        await Task.Delay(duration);
+        _logger.LogInformation("Finished delay");
         return new Result<string> { Value = "updated" };
     }