Update sample to FanOutFanIn pattern with fresh screenshots

- Replaced chaining sample with Fan-Out/Fan-In pattern (5× GetWeather + CreateSummary)
- Updated README.md to reflect FanOutFanIn span hierarchy
- Captured updated Jaeger screenshots showing parallel activity spans

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

Author: torosent

samples/README.md

@@ -39,39 +39,37 @@ docker run -d --name jaeger \
 
 ## What the Sample Does
 
-The `TracingPattern` sample:
+The `TracingPattern` sample demonstrates the **Fan-Out/Fan-In** pattern with distributed tracing:
 
 1. Configures OpenTelemetry with an OTLP exporter pointing to Jaeger
 2. Connects a worker and client to the DTS emulator using a connection string
-3. Creates a parent span (`create_orchestration:TracingOrchestration`) and schedules an orchestration
-4. The orchestration chains three activities (`Reverse`, `Capitalize`, `AddSuffix`) and a sub-orchestration (`ChildOrchestration`)
+3. Creates a parent span (`create_orchestration:FanOutFanIn`) and schedules an orchestration
+4. The orchestration fans out 5 parallel `GetWeather` activities (Seattle, Tokyo, London, Paris, Sydney), fans in the results, then calls `CreateSummary` to aggregate
 5. The SDK automatically propagates trace context through the full execution chain
 
 ## Screenshots
 
 ### Jaeger — Trace Search Results
 
-Shows the trace from `durabletask-java-tracing-sample` service with 10 spans covering the full orchestration lifecycle.
+Shows the trace from `durabletask-java-tracing-sample` service with spans covering the full fan-out/fan-in orchestration lifecycle.
 
 ![Jaeger trace search results](images/jaeger-trace-list-full.png)
 
 ### Jaeger — Trace Detail
 
-Full span hierarchy showing parent-child relationships:
-- `create_orchestration:TracingOrchestration` (parent)
-  - `orchestration:TracingOrchestration` (orchestration replays)
-    - `activity:Reverse`
-    - `activity:Capitalize`
-  - `orchestration:ChildOrchestration` (sub-orchestration)
-    - `activity:AddSuffix`
+Full span hierarchy showing the fan-out/fan-in pattern:
+- `create_orchestration:FanOutFanIn` (parent)
+  - `orchestration:FanOutFanIn` (orchestration execution)
+    - `activity:GetWeather` ×5 (parallel fan-out)
+    - `activity:CreateSummary` (fan-in aggregation)
 
 ![Jaeger trace detail](images/jaeger-full-trace-detail.png)
 
 ### Jaeger — Span Attributes
 
 Activity span showing attributes aligned with the .NET SDK schema:
 - `durabletask.type=activity`
-- `durabletask.task.name=Reverse`
+- `durabletask.task.name=GetWeather`
 - `durabletask.task.instance_id=<orchestrationId>`
 - `durabletask.task.task_id=0`
 - `otel.scope.name=Microsoft.DurableTask`
@@ -81,7 +79,7 @@ Activity span showing attributes aligned with the .NET SDK schema:
 
 ### DTS Dashboard — Completed Orchestrations
 
-Both `TracingOrchestration` and `ChildOrchestration` completed successfully.
+The `FanOutFanIn` orchestration completed successfully with all activities.
 
 ![DTS Dashboard](images/dts-dashboard-completed.png)
 

samples/images/jaeger-full-trace-detail.png

@@ -20,6 +20,7 @@
 
 import java.io.IOException;
 import java.time.Duration;
+import java.util.List;
 import java.util.concurrent.TimeoutException;
 import java.util.logging.Logger;
 
@@ -89,62 +90,48 @@ public static void main(String[] args) throws IOException, InterruptedException,
                 .createWorkerBuilder(connectionString)
                 .addOrchestration(new TaskOrchestrationFactory() {
                     @Override
-                    public String getName() { return "TracingOrchestration"; }
+                    public String getName() { return "FanOutFanIn"; }
 
                     @Override
                     public TaskOrchestration create() {
                         return ctx -> {
-                            String input = ctx.getInput(String.class);
-                            // Trace context is automatically propagated to activities via parentTraceContext
-                            String reversed = ctx.callActivity("Reverse", input, String.class).await();
-                            String upper = ctx.callActivity("Capitalize", reversed, String.class).await();
-                            // Sub-orchestration also receives the trace context
-                            String result = ctx.callSubOrchestrator(
-                                    "ChildOrchestration", upper, String.class).await();
-                            ctx.complete(result);
-                        };
-                    }
-                })
-                .addOrchestration(new TaskOrchestrationFactory() {
-                    @Override
-                    public String getName() { return "ChildOrchestration"; }
-
-                    @Override
-                    public TaskOrchestration create() {
-                        return ctx -> {
-                            String input = ctx.getInput(String.class);
-                            String result = ctx.callActivity("AddSuffix", input, String.class).await();
-                            ctx.complete(result);
+                            // Fan-out: schedule multiple parallel activities
+                            List<Task<String>> parallelTasks = new java.util.ArrayList<>();
+                            String[] cities = {"Seattle", "Tokyo", "London", "Paris", "Sydney"};
+                            for (String city : cities) {
+                                parallelTasks.add(
+                                    ctx.callActivity("GetWeather", city, String.class));
+                            }
+
+                            // Fan-in: wait for all activities to complete
+                            List<String> results = ctx.allOf(parallelTasks).await();
+
+                            // Aggregate results
+                            String summary = ctx.callActivity(
+                                    "CreateSummary", String.join(", ", results), String.class).await();
+
+                            ctx.complete(summary);
                         };
                     }
                 })
                 .addActivity(new TaskActivityFactory() {
-                    @Override public String getName() { return "Reverse"; }
+                    @Override public String getName() { return "GetWeather"; }
                     @Override public TaskActivity create() {
                         return ctx -> {
-                            String input = ctx.getInput(String.class);
-                            logger.info("[Reverse] Processing: " + input);
-                            return new StringBuilder(input).reverse().toString();
-                        };
-                    }
-                })
-                .addActivity(new TaskActivityFactory() {
-                    @Override public String getName() { return "Capitalize"; }
-                    @Override public TaskActivity create() {
-                        return ctx -> {
-                            String input = ctx.getInput(String.class);
-                            logger.info("[Capitalize] Processing: " + input);
-                            return input.toUpperCase();
+                            String city = ctx.getInput(String.class);
+                            logger.info("[GetWeather] Getting weather for: " + city);
+                            try { Thread.sleep(20); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
+                            return city + "=72F";
                         };
                     }
                 })
                 .addActivity(new TaskActivityFactory() {
-                    @Override public String getName() { return "AddSuffix"; }
+                    @Override public String getName() { return "CreateSummary"; }
                     @Override public TaskActivity create() {
                         return ctx -> {
                             String input = ctx.getInput(String.class);
-                            logger.info("[AddSuffix] Processing: " + input);
-                            return input + "-traced";
+                            logger.info("[CreateSummary] Creating summary for: " + input);
+                            return "Weather Report: " + input;
                         };
                     }
                 })
@@ -160,19 +147,19 @@ public TaskOrchestration create() {
                 .createClientBuilder(connectionString).build();
 
         // Create a parent span — the SDK automatically propagates W3C trace context
-        Span orchestrationSpan = tracer.spanBuilder("create_orchestration:TracingOrchestration")
-                .setAttribute("durabletask.task.name", "TracingOrchestration")
+        Span orchestrationSpan = tracer.spanBuilder("create_orchestration:FanOutFanIn")
+                .setAttribute("durabletask.task.name", "FanOutFanIn")
                 .setAttribute("durabletask.type", "orchestration")
                 .startSpan();
 
         orchestrationContext = Context.current().with(orchestrationSpan);
 
         String instanceId;
         try (Scope scope = orchestrationSpan.makeCurrent()) {
-            logger.info("Scheduling orchestration...");
+            logger.info("Scheduling FanOutFanIn orchestration...");
             instanceId = client.scheduleNewOrchestrationInstance(
-                    "TracingOrchestration",
-                    new NewOrchestrationInstanceOptions().setInput("Hello, tracing!"));
+                    "FanOutFanIn",
+                    new NewOrchestrationInstanceOptions().setInput("weather-request"));
             orchestrationSpan.setAttribute("durabletask.task.instance_id", instanceId);
             logger.info("Started orchestration: " + instanceId);
         }