fix: update Azure Functions sample to FanOutFanIn pattern

Updated TracingChain.java to use the same Fan-Out/Fan-In pattern as the
DTS sample (TracingPattern.java): 1s timer → 5× GetWeather → CreateSummary.
This ensures both samples are consistent and demonstrate the same tracing
capabilities.

Updated samples/README.md with Azure Functions section explaining that
Durable Functions tracing exports to Application Insights, not Jaeger.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: torosent

samples-azure-functions/src/main/java/com/functions/TracingChain.java

@@ -8,92 +8,80 @@
 import com.microsoft.azure.functions.annotation.FunctionName;
 import com.microsoft.azure.functions.annotation.HttpTrigger;
 import com.microsoft.durabletask.DurableTaskClient;
+import com.microsoft.durabletask.Task;
 import com.microsoft.durabletask.TaskOrchestrationContext;
 import com.microsoft.durabletask.azurefunctions.DurableActivityTrigger;
 import com.microsoft.durabletask.azurefunctions.DurableClientContext;
 import com.microsoft.durabletask.azurefunctions.DurableClientInput;
 import com.microsoft.durabletask.azurefunctions.DurableOrchestrationTrigger;
 
+import java.time.Duration;
+import java.util.Arrays;
+import java.util.List;
 import java.util.Optional;
+import java.util.stream.Collectors;
 
 /**
  * Sample demonstrating distributed tracing with Durable Functions.
  * <p>
+ * Uses a Fan-Out/Fan-In pattern with a timer, matching the DTS sample (TracingPattern.java).
  * Trace context is automatically propagated from the HTTP trigger through the
- * orchestration to each activity and sub-orchestration. When Application Insights
- * or an OpenTelemetry exporter is configured, you will see correlated traces
- * across the entire workflow.
+ * orchestration to each activity. When Application Insights is configured,
+ * you will see correlated traces across the entire workflow.
  */
 public class TracingChain {
 
-    @FunctionName("StartTracingChain")
-    public HttpResponseMessage startTracingChain(
+    @FunctionName("StartFanOutFanIn")
+    public HttpResponseMessage startFanOutFanIn(
             @HttpTrigger(name = "req", methods = {HttpMethod.GET, HttpMethod.POST},
                     authLevel = AuthorizationLevel.ANONYMOUS)
             HttpRequestMessage<Optional<String>> request,
             @DurableClientInput(name = "durableContext") DurableClientContext durableContext,
             final ExecutionContext context) {
-        context.getLogger().info("Starting TracingChain orchestration");
+        context.getLogger().info("Starting FanOutFanIn orchestration");
 
         DurableTaskClient client = durableContext.getClient();
-        String instanceId = client.scheduleNewOrchestrationInstance("TracingChain");
+        String instanceId = client.scheduleNewOrchestrationInstance("FanOutFanIn");
         context.getLogger().info("Created orchestration with instance ID = " + instanceId);
         return durableContext.createCheckStatusResponse(request, instanceId);
     }
 
     /**
-     * Orchestration that chains activities and a sub-orchestration.
-     * Trace context flows from the client through each step.
+     * Fan-Out/Fan-In orchestration: waits 1s, then runs 5 GetWeather activities
+     * in parallel, and finally calls CreateSummary to aggregate the results.
      */
-    @FunctionName("TracingChain")
-    public String tracingChain(
+    @FunctionName("FanOutFanIn")
+    public String fanOutFanIn(
             @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
-        String input = ctx.getInput(String.class);
-        if (input == null) {
-            input = "Hello";
-        }
 
-        // Each activity execution creates a child span under the orchestration span
-        String step1 = ctx.callActivity("TracingReverse", input, String.class).await();
-        String step2 = ctx.callActivity("TracingCapitalize", step1, String.class).await();
+        // Wait 1 second (creates a timer span)
+        ctx.createTimer(Duration.ofSeconds(1)).await();
 
-        // Sub-orchestration also propagates trace context
-        String result = ctx.callSubOrchestrator("TracingChildOrch", step2, String.class).await();
+        // Fan-out: schedule 5 GetWeather activities in parallel
+        List<String> cities = Arrays.asList("Seattle", "Tokyo", "London", "Paris", "Sydney");
+        List<Task<String>> tasks = cities.stream()
+                .map(city -> ctx.callActivity("GetWeather", city, String.class))
+                .collect(Collectors.toList());
+        List<String> results = ctx.allOf(tasks).await();
 
-        return result;
+        // Fan-in: aggregate results
+        String combined = String.join(", ", results);
+        return ctx.callActivity("CreateSummary", combined, String.class).await();
     }
 
-    /**
-     * Sub-orchestration that receives propagated trace context.
-     */
-    @FunctionName("TracingChildOrch")
-    public String tracingChildOrch(
-            @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
-        String input = ctx.getInput(String.class);
-        return ctx.callActivity("TracingAddSuffix", input, String.class).await();
-    }
-
-    @FunctionName("TracingReverse")
-    public String tracingReverse(
-            @DurableActivityTrigger(name = "input") String input,
-            final ExecutionContext context) {
-        context.getLogger().info("TracingReverse: " + input);
-        return new StringBuilder(input).reverse().toString();
-    }
-
-    @FunctionName("TracingCapitalize")
-    public String tracingCapitalize(
-            @DurableActivityTrigger(name = "input") String input,
+    @FunctionName("GetWeather")
+    public String getWeather(
+            @DurableActivityTrigger(name = "city") String city,
             final ExecutionContext context) {
-        context.getLogger().info("TracingCapitalize: " + input);
-        return input.toUpperCase();
+        context.getLogger().info("[GetWeather] Getting weather for: " + city);
+        return city + "=72F";
     }
 
-    @FunctionName("TracingAddSuffix")
-    public String tracingAddSuffix(
+    @FunctionName("CreateSummary")
+    public String createSummary(
             @DurableActivityTrigger(name = "input") String input,
             final ExecutionContext context) {
-        context.getLogger().info("TracingAddSuffix: " + input);
-        return input + "-traced";
+        context.getLogger().info("[CreateSummary] Creating summary for: " + input);
+        return "Weather Report: " + input;
     }
 }

samples/README.md

@@ -57,14 +57,16 @@ Shows the trace from `durabletask-java-tracing-sample` service with spans coveri
 
 ### Jaeger — Trace Detail
 
-Full span hierarchy showing the fan-out/fan-in pattern with paired Client+Server spans (matching .NET SDK):
+Full span hierarchy showing the fan-out/fan-in pattern with proper span durations:
 - `create_orchestration:FanOutFanIn` (root, internal)
-  - `orchestration:FanOutFanIn` (server — orchestration execution)
-    - `orchestration:FanOutFanIn:timer` (internal — durable timer wait)
-    - `activity:GetWeather` ×5 (client — scheduling) → `activity:GetWeather` ×5 (server — execution)
-    - `activity:CreateSummary` (client) → `activity:CreateSummary` (server)
+  - `orchestration:FanOutFanIn` (server — full lifecycle, ~1.2s)
+  - `orchestration:FanOutFanIn:timer` (internal — creation-to-fired, ~965ms)
+  - `activity:GetWeather` ×5 (client — scheduling-to-completion, ~184ms) + ×5 (server — execution, ~25ms)
+  - `activity:CreateSummary` (client, ~8ms) + (server, ~0.7ms)
 
-15 spans total, Depth 3 — aligned with the .NET SDK trace structure.
+15 spans total, Depth 2.
+
+> **Note:** Java OTel doesn't support `SetSpanId()` like .NET, so child spans appear as siblings under `create_orchestration` rather than nested under the orchestration span. All spans have meaningful durations.
 
 ![Jaeger trace detail](images/jaeger-full-trace-detail.png)
 
@@ -91,3 +93,20 @@ The `FanOutFanIn` orchestration completed successfully with all activities.
 ```bash
 docker stop jaeger dts-emulator && docker rm jaeger dts-emulator
 ```
+
+## Azure Functions Sample
+
+The `samples-azure-functions` module contains a matching **Fan-Out/Fan-In** sample (`TracingChain.java`) for use with Azure Durable Functions. It uses the same pattern (1s timer → 5× `GetWeather` → `CreateSummary`) but runs as an HTTP-triggered Azure Function.
+
+### Running
+
+```bash
+cd samples-azure-functions
+../gradlew azureFunctionsPackage -PskipSigning -x downloadProtoFiles
+cd build/azure-functions/<app-name>
+func start
+```
+
+Then trigger with: `curl http://localhost:7071/api/StartFanOutFanIn`
+
+Distributed tracing in Durable Functions exports to **Application Insights** (not Jaeger/OTLP). Configure your `APPLICATIONINSIGHTS_CONNECTION_STRING` in `local.settings.json` to see traces.