Add OpenTelemetry tracing support for Python SDK samples

Author: torosent

samples/durable-task-sdks/java/opentelemetry-tracing/README.md

@@ -27,33 +27,33 @@ This launches:
 ### 2. Run the sample
 
 ```bash
-./gradlew runOpenTelemetryTracingPattern
+./gradlew run
 ```
 
 This starts the worker, schedules an `OrderProcessingOrchestration`, and waits for it to complete.
 
 ## Viewing Traces
 
 1. Open the Jaeger UI at **http://localhost:16686**
-2. Select the **durable-worker** service from the dropdown
+2. Select the **DistributedTracingSample** service from the dropdown
 3. Click **Find Traces**
-4. Click on a trace to see the span tree — you'll see spans for each activity (`ValidateOrder`, `ProcessPayment`, `ShipOrder`, `SendNotification`)
+4. Click on the trace with **5 Spans** — you'll see the parent `create_orchestration:OrderProcessingOrchestration` with child activity spans nested underneath
 
-![Jaeger search results showing activity traces](images/jaeger-search-results.png)
+![Jaeger search results showing orchestration trace with 5 spans](images/jaeger-search-results.png)
 
-Click on any trace to see the span details, including service name, duration, and OpenTelemetry tags:
+Click on the trace to see the full span tree with parent-child hierarchy and rich `durabletask.*` tags:
 
-![Jaeger trace detail view with span metadata](images/jaeger-trace-detail.png)
+![Jaeger trace detail showing nested activity spans with durable task metadata](images/jaeger-trace-detail.png)
 
 You can also view the orchestration status in the DTS Dashboard at **http://localhost:8082**.
 
 ## What You'll See
 
-The Jaeger UI shows traces for each activity in the orchestration, including timing and any errors. This helps you:
+The Jaeger UI shows a single trace for the entire orchestration with nested child spans for each activity. Each span includes `durabletask.task.name`, `durabletask.type`, and `durabletask.task.task_id` tags. This helps you:
 
-- Identify slow activities
+- Identify slow activities within an orchestration
 - See the sequential flow of function chaining
-- Correlate traces across distributed services
+- Correlate the full orchestration lifecycle in one trace
 - Debug failures with full context
 
 ## How It Works
@@ -68,7 +68,7 @@ OtlpGrpcSpanExporter spanExporter = OtlpGrpcSpanExporter.builder()
         .build();
 
 SdkTracerProvider tracerProvider = SdkTracerProvider.builder()
-        .setResource(Resource.builder().put("service.name", "durable-worker").build())
+        .setResource(Resource.builder().put("service.name", "DistributedTracingSample").build())
         .addSpanProcessor(BatchSpanProcessor.builder(spanExporter).build())
         .build();
 

samples/durable-task-sdks/java/opentelemetry-tracing/build.gradle

@@ -14,6 +14,10 @@ def grpcVersion = '1.78.0'
 def openTelemetryVersion = '1.58.0'
 base { archivesName = 'durabletask-samples' }
 
+application {
+    mainClass = 'io.durabletask.samples.OpenTelemetryTracingPattern'
+}
+
 repositories {
     mavenLocal()
     mavenCentral()

samples/durable-task-sdks/java/opentelemetry-tracing/gradle/wrapper/gradle-wrapper.jar

@@ -8,6 +8,7 @@
 import io.opentelemetry.api.trace.Span;
 import io.opentelemetry.api.trace.StatusCode;
 import io.opentelemetry.api.trace.Tracer;
+import io.opentelemetry.context.Context;
 import io.opentelemetry.context.Scope;
 import io.opentelemetry.exporter.otlp.trace.OtlpGrpcSpanExporter;
 import io.opentelemetry.sdk.OpenTelemetrySdk;
@@ -24,10 +25,30 @@
 /**
  * Demonstrates OpenTelemetry distributed tracing with the Durable Task SDK.
  * Traces are exported to Jaeger via OTLP/gRPC for visualization.
+ *
+ * <p>The Java SDK's client automatically propagates W3C trace context
+ * (traceparent/tracestate) when scheduling orchestrations. This sample
+ * additionally shares the parent span context with activities running in
+ * the same process so that all spans appear under a single trace in Jaeger.
  */
 final class OpenTelemetryTracingPattern {
     private static final Logger logger = LoggerFactory.getLogger(OpenTelemetryTracingPattern.class);
 
+    // Shared parent context so activity spans become children of the orchestration span.
+    // In a distributed setup the SDK would propagate this via W3C trace context headers.
+    private static volatile Context orchestrationContext;
+
+    /** Create an activity span as a child of the orchestration span. */
+    private static Span startActivitySpan(Tracer tracer, String activityName, int taskId) {
+        Context parent = orchestrationContext != null ? orchestrationContext : Context.current();
+        return tracer.spanBuilder("activity:" + activityName)
+                .setParent(parent)
+                .setAttribute("durabletask.task.name", activityName)
+                .setAttribute("durabletask.type", "activity")
+                .setAttribute("durabletask.task.task_id", taskId)
+                .startSpan();
+    }
+
     public static void main(String[] args) throws IOException, InterruptedException, TimeoutException {
         // Configure OpenTelemetry
         String otlpEndpoint = System.getenv("OTEL_EXPORTER_OTLP_ENDPOINT");
@@ -40,7 +61,7 @@ public static void main(String[] args) throws IOException, InterruptedException,
                 .build();
 
         Resource resource = Resource.builder()
-                .put("service.name", "durable-worker")
+                .put("service.name", "DistributedTracingSample")
                 .build();
 
         SdkTracerProvider tracerProvider = SdkTracerProvider.builder()
@@ -52,7 +73,7 @@ public static void main(String[] args) throws IOException, InterruptedException,
                 .setTracerProvider(tracerProvider)
                 .buildAndRegisterGlobal();
 
-        Tracer tracer = openTelemetry.getTracer("durable-worker");
+        Tracer tracer = openTelemetry.getTracer("Microsoft.DurableTask");
         logger.info("OpenTelemetry configured with OTLP exporter at {}", otlpEndpoint);
 
         // Build connection string
@@ -81,36 +102,20 @@ public static void main(String[] args) throws IOException, InterruptedException,
                     public TaskOrchestration create() {
                         return ctx -> {
                             String orderId = ctx.getInput(String.class);
-
-                            // Step 1: Validate the order
-                            String validated = ctx.callActivity(
-                                    "ValidateOrder", orderId, String.class).await();
-
-                            // Step 2: Process payment
-                            String paid = ctx.callActivity(
-                                    "ProcessPayment", validated, String.class).await();
-
-                            // Step 3: Ship order
-                            String shipped = ctx.callActivity(
-                                    "ShipOrder", paid, String.class).await();
-
-                            // Step 4: Send notification
-                            String result = ctx.callActivity(
-                                    "SendNotification", shipped, String.class).await();
-
+                            String validated = ctx.callActivity("ValidateOrder", orderId, String.class).await();
+                            String paid = ctx.callActivity("ProcessPayment", validated, String.class).await();
+                            String shipped = ctx.callActivity("ShipOrder", paid, String.class).await();
+                            String result = ctx.callActivity("SendNotification", shipped, String.class).await();
                             ctx.complete(result);
                         };
                     }
                 })
                 .addActivity(new TaskActivityFactory() {
-                    @Override
-                    public String getName() { return "ValidateOrder"; }
-
-                    @Override
-                    public TaskActivity create() {
+                    @Override public String getName() { return "ValidateOrder"; }
+                    @Override public TaskActivity create() {
                         return ctx -> {
                             String orderId = ctx.getInput(String.class);
-                            Span span = tracer.spanBuilder("ValidateOrder").startSpan();
+                            Span span = startActivitySpan(tracer, "ValidateOrder", 1);
                             try (Scope scope = span.makeCurrent()) {
                                 logger.info("[ValidateOrder] Validating order: {}", orderId);
                                 Thread.sleep(100);
@@ -126,14 +131,11 @@ public TaskActivity create() {
                     }
                 })
                 .addActivity(new TaskActivityFactory() {
-                    @Override
-                    public String getName() { return "ProcessPayment"; }
-
-                    @Override
-                    public TaskActivity create() {
+                    @Override public String getName() { return "ProcessPayment"; }
+                    @Override public TaskActivity create() {
                         return ctx -> {
                             String input = ctx.getInput(String.class);
-                            Span span = tracer.spanBuilder("ProcessPayment").startSpan();
+                            Span span = startActivitySpan(tracer, "ProcessPayment", 2);
                             try (Scope scope = span.makeCurrent()) {
                                 logger.info("[ProcessPayment] Processing payment for: {}", input);
                                 Thread.sleep(200);
@@ -149,14 +151,11 @@ public TaskActivity create() {
                     }
                 })
                 .addActivity(new TaskActivityFactory() {
-                    @Override
-                    public String getName() { return "ShipOrder"; }
-
-                    @Override
-                    public TaskActivity create() {
+                    @Override public String getName() { return "ShipOrder"; }
+                    @Override public TaskActivity create() {
                         return ctx -> {
                             String input = ctx.getInput(String.class);
-                            Span span = tracer.spanBuilder("ShipOrder").startSpan();
+                            Span span = startActivitySpan(tracer, "ShipOrder", 3);
                             try (Scope scope = span.makeCurrent()) {
                                 logger.info("[ShipOrder] Shipping: {}", input);
                                 Thread.sleep(150);
@@ -172,14 +171,11 @@ public TaskActivity create() {
                     }
                 })
                 .addActivity(new TaskActivityFactory() {
-                    @Override
-                    public String getName() { return "SendNotification"; }
-
-                    @Override
-                    public TaskActivity create() {
+                    @Override public String getName() { return "SendNotification"; }
+                    @Override public TaskActivity create() {
                         return ctx -> {
                             String input = ctx.getInput(String.class);
-                            Span span = tracer.spanBuilder("SendNotification").startSpan();
+                            Span span = startActivitySpan(tracer, "SendNotification", 4);
                             try (Scope scope = span.makeCurrent()) {
                                 logger.info("[SendNotification] Notifying customer: {}", input);
                                 Thread.sleep(50);
@@ -205,15 +201,24 @@ public TaskActivity create() {
         DurableTaskClient client = DurableTaskSchedulerClientExtensions
                 .createClientBuilder(connectionString).build();
 
-        // Create a parent span for the orchestration - the SDK automatically propagates
-        // W3C trace context (traceparent/tracestate) when scheduling orchestrations
-        Span orchestrationSpan = tracer.spanBuilder("OrderProcessingOrchestration").startSpan();
+        // Create a parent span for the orchestration. The SDK automatically propagates
+        // W3C trace context (traceparent/tracestate) when scheduling orchestrations.
+        Span orchestrationSpan = tracer.spanBuilder("create_orchestration:OrderProcessingOrchestration")
+                .setAttribute("durabletask.task.name", "OrderProcessingOrchestration")
+                .setAttribute("durabletask.type", "orchestration")
+                .startSpan();
+
+        // Share the orchestration context with the worker thread so activity spans
+        // become children of this orchestration span in the trace.
+        orchestrationContext = Context.current().with(orchestrationSpan);
+
         String instanceId;
         try (Scope scope = orchestrationSpan.makeCurrent()) {
             logger.info("Scheduling order processing orchestration...");
             instanceId = client.scheduleNewOrchestrationInstance(
                     "OrderProcessingOrchestration",
                     new NewOrchestrationInstanceOptions().setInput("Order-12345"));
+            orchestrationSpan.setAttribute("durabletask.task.instance_id", instanceId);
             logger.info("Started orchestration: {}", instanceId);
         }
 
@@ -225,11 +230,20 @@ public TaskActivity create() {
 
         logger.info("Status: {}", result.getRuntimeStatus());
         logger.info("Result: {}", result.readOutputAs(String.class));
+        if (result.getFailureDetails() != null
+                && result.getFailureDetails().getErrorMessage() != null
+                && !result.getFailureDetails().getErrorMessage().isEmpty()) {
+            logger.error("Failure: {} - {}", result.getFailureDetails().getErrorType(),
+                    result.getFailureDetails().getErrorMessage());
+        }
         logger.info("");
         logger.info("View traces in Jaeger UI: http://localhost:16686");
+        logger.info("  Search for service: DistributedTracingSample");
         logger.info("View orchestration in DTS Dashboard: http://localhost:8082");
 
-        // Shutdown
+        // Flush traces and shut down
+        tracerProvider.forceFlush();
+        Thread.sleep(2000);
         tracerProvider.shutdown();
         worker.stop();
         System.exit(0);

samples/durable-task-sdks/java/opentelemetry-tracing/images/jaeger-search-results.png

@@ -36,9 +36,19 @@ This sample demonstrates how to add OpenTelemetry distributed tracing to a Durab
    - **Jaeger UI:** http://localhost:16686 (search for service `durable-worker`)
    - **DTS Dashboard:** http://localhost:8082
 
+## Viewing Traces
+
+Open the [Jaeger UI](http://localhost:16686), select the `durable-worker` service, and click **Find Traces**. You'll see one trace per activity — `validate_order`, `process_payment`, `ship_order`, and `send_notification`:
+
+![Jaeger search results showing 4 activity traces](images/jaeger-search-results.png)
+
+Click on any trace to see span details including tags, duration, and OpenTelemetry metadata:
+
+![Jaeger trace detail showing span tags and process info](images/jaeger-trace-detail.png)
+
 ## What You'll See
 
-The Jaeger UI shows the complete trace for each orchestration — the parent orchestration span with child spans for each activity, including timing and any errors. This helps you:
+These traces help you:
 
 - Identify slow activities
 - See the sequential flow of function chaining

samples/durable-task-sdks/java/opentelemetry-tracing/images/jaeger-trace-detail.png

@@ -1,34 +1,67 @@
-"""Client to schedule and monitor orchestrations."""
+"""Client to schedule and monitor orchestrations with OpenTelemetry tracing."""
 import os
 import asyncio
-import durabletask.client as client
+
+from opentelemetry import trace
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor
+from opentelemetry.sdk.resources import Resource
+from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
+
+from durabletask.azuremanaged.client import DurableTaskSchedulerClient
+
+# Configure OpenTelemetry (same service name as worker for unified view)
+resource = Resource.create({"service.name": "DistributedTracingSample"})
+provider = TracerProvider(resource=resource)
+otlp_endpoint = os.environ.get("OTEL_EXPORTER_OTLP_ENDPOINT", "http://localhost:4317")
+exporter = OTLPSpanExporter(endpoint=otlp_endpoint, insecure=True)
+provider.add_span_processor(BatchSpanProcessor(exporter))
+trace.set_tracer_provider(provider)
+
+tracer = trace.get_tracer("Microsoft.DurableTask")
 
 
 async def main():
     endpoint = os.environ.get("ENDPOINT", "http://localhost:8080")
     taskhub = os.environ.get("TASKHUB", "default")
 
-    async with client.DurableTaskClient(
+    c = DurableTaskSchedulerClient(
         host_address=endpoint,
-        secure_channel=not endpoint.startswith("http://localhost"),
+        secure_channel=endpoint != "http://localhost:8080",
         taskhub=taskhub,
-    ) as c:
+        token_credential=None,
+    )
+
+    # Create a parent span for the orchestration, matching the .NET SDK pattern
+    with tracer.start_as_current_span(
+        "create_orchestration:OrderProcessingOrchestration",
+        attributes={
+            "durabletask.task.name": "OrderProcessingOrchestration",
+            "durabletask.type": "orchestration",
+        },
+    ) as span:
         print("Scheduling order processing orchestration...")
-        instance_id = await c.schedule_new_orchestration(
+        instance_id = c.schedule_new_orchestration(
             "order_processing_orchestration",
             input="Order-12345",
         )
+        span.set_attribute("durabletask.task.instance_id", instance_id)
         print(f"Started orchestration: {instance_id}")
         print("Waiting for completion...")
 
-        result = await c.wait_for_orchestration_completion(
+        result = c.wait_for_orchestration_completion(
             instance_id, timeout=60
         )
         print(f"Status: {result.runtime_status.name}")
         print(f"Result: {result.serialized_output}")
-        print()
-        print("View traces in Jaeger UI: http://localhost:16686")
-        print("View orchestration in DTS Dashboard: http://localhost:8082")
+
+    # Flush remaining spans
+    provider.force_flush()
+
+    print()
+    print("View traces in Jaeger UI: http://localhost:16686")
+    print("  Search for service: DistributedTracingSample")
+    print("View orchestration in DTS Dashboard: http://localhost:8082")
 
 
 if __name__ == "__main__":