Add OpenTelemetry tracing example and logging configuration

- Implemented OpenTelemetry tracing in a new Java sample demonstrating Durable Task SDK usage.
- Created orchestration and activities with tracing spans for order processing workflow.
- Added logback configuration for logging output to the console.

Author: torosent

.github/workflows/build-samples.yml

@@ -132,6 +132,9 @@ jobs:
       - name: Build DTS - async-http-api
         run: cd samples/durable-task-sdks/java/async-http-api && chmod +x gradlew && ./gradlew build
 
+      - name: Build DTS - opentelemetry-tracing
+        run: cd samples/durable-task-sdks/java/opentelemetry-tracing && chmod +x gradlew && ./gradlew build
+
       # Durable Functions samples (Maven)
       - name: Build DF - HelloCities
         run: cd samples/durable-functions/java/HelloCities && mvn compile --batch-mode

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

@@ -0,0 +1,90 @@
+# OpenTelemetry Distributed Tracing
+
+| | |
+|-|-|
+| **Language** | Java 21 |
+| **SDK** | Durable Task SDK |
+
+This sample shows how to wire up [OpenTelemetry](https://opentelemetry.io/) with the Durable Task SDK for Java to visualize orchestration flows in [Jaeger](https://www.jaegertracing.io/). It demonstrates trace correlation across an orchestrator and activities so you can see the full distributed trace of an order-processing workflow.
+
+## Prerequisites
+
+- [Java 21](https://learn.microsoft.com/java/openjdk/download)
+- [Docker](https://www.docker.com/products/docker-desktop)
+
+## Quick Run
+
+### 1. Start the infrastructure (DTS emulator + Jaeger)
+
+```bash
+docker compose up -d
+```
+
+This launches:
+- **DTS Emulator** on `localhost:8080` (gRPC) and `localhost:8082` (Dashboard)
+- **Jaeger** on `localhost:16686` (UI), `localhost:4317` (OTLP gRPC), and `localhost:4318` (OTLP HTTP)
+
+### 2. Run the sample
+
+```bash
+./gradlew runOpenTelemetryTracingPattern
+```
+
+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
+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`)
+
+![Jaeger search results showing activity traces](images/jaeger-search-results.png)
+
+Click on any trace to see the span details, including service name, duration, and OpenTelemetry tags:
+
+![Jaeger trace detail view with span 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:
+
+- Identify slow activities
+- See the sequential flow of function chaining
+- Correlate traces across distributed services
+- Debug failures with full context
+
+## How It Works
+
+The sample configures an OpenTelemetry `TracerProvider` with an OTLP/gRPC exporter that sends spans to Jaeger. Each activity creates a manual span using the tracer. The Durable Task SDK automatically propagates W3C trace context (`traceparent`/`tracestate`) when scheduling orchestrations, enabling end-to-end trace correlation.
+
+Key configuration:
+
+```java
+OtlpGrpcSpanExporter spanExporter = OtlpGrpcSpanExporter.builder()
+        .setEndpoint(otlpEndpoint)
+        .build();
+
+SdkTracerProvider tracerProvider = SdkTracerProvider.builder()
+        .setResource(Resource.builder().put("service.name", "durable-worker").build())
+        .addSpanProcessor(BatchSpanProcessor.builder(spanExporter).build())
+        .build();
+
+OpenTelemetrySdk.builder()
+        .setTracerProvider(tracerProvider)
+        .buildAndRegisterGlobal();
+```
+
+## Clean Up
+
+```bash
+docker compose down
+```
+
+## Learn More
+
+- [Observability Guide](../../../../docs/observability.md)
+- [OpenTelemetry Java docs](https://opentelemetry.io/docs/languages/java/)
+- [Durable Task Scheduler Dashboard](https://learn.microsoft.com/azure/azure-functions/durable/durable-task-scheduler/durable-task-scheduler-dashboard)

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

@@ -0,0 +1,46 @@
+plugins {
+    id 'java'
+    id 'application'
+}
+
+group 'io.durabletask'
+version = '0.1.0'
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_21
+    targetCompatibility = JavaVersion.VERSION_21
+}
+def grpcVersion = '1.78.0'
+def openTelemetryVersion = '1.58.0'
+base { archivesName = 'durabletask-samples' }
+
+repositories {
+    mavenLocal()
+    mavenCentral()
+}
+
+task runOpenTelemetryTracingPattern(type: JavaExec) {
+    classpath = sourceSets.main.runtimeClasspath
+    mainClass = 'io.durabletask.samples.OpenTelemetryTracingPattern'
+    systemProperty 'logback.configurationFile', 'src/main/resources/logback-spring.xml'
+}
+
+dependencies {
+    implementation("com.microsoft:durabletask-client:1.7.0")
+    implementation("com.microsoft:durabletask-azuremanaged:1.7.0")
+
+    // Logging dependencies
+    implementation 'ch.qos.logback:logback-classic:1.5.32'
+    implementation 'org.slf4j:slf4j-api:2.0.17'
+
+    // gRPC
+    implementation "io.grpc:grpc-protobuf:${grpcVersion}"
+    implementation "io.grpc:grpc-stub:${grpcVersion}"
+    runtimeOnly "io.grpc:grpc-netty-shaded:${grpcVersion}"
+    implementation 'com.azure:azure-identity:1.18.2'
+
+    // OpenTelemetry
+    implementation "io.opentelemetry:opentelemetry-api:${openTelemetryVersion}"
+    implementation "io.opentelemetry:opentelemetry-sdk:${openTelemetryVersion}"
+    implementation "io.opentelemetry:opentelemetry-exporter-otlp:${openTelemetryVersion}"
+}

samples/durable-task-sdks/java/opentelemetry-tracing/docker-compose.yml

@@ -0,0 +1,15 @@
+services:
+  dts-emulator:
+    image: mcr.microsoft.com/dts/dts-emulator:latest
+    ports:
+      - "8080:8080"
+      - "8082:8082"
+
+  jaeger:
+    image: jaegertracing/all-in-one:latest
+    ports:
+      - "16686:16686"
+      - "4317:4317"
+      - "4318:4318"
+    environment:
+      - COLLECTOR_OTLP_ENABLED=true

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

@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.3.1-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists