refactor(telemetry): rely on the core's wrapped-error checkpoints (spec v3)

The core now checkpoints the wrapped error of a failed context
(fix/checkpoint-wrapped-error), so a failed step or context always has an
error type. Drop the exporter fallback that named a typeless step or
context after the SDK failure class the core would throw; keep it only
for callbacks and invokes, whose callers can leave the type out and
whose timeouts carry no error.

A stopped or timed-out invoke inside a child context now has one name for
the invoke, every enclosing context and the execution, live and replayed;
add nested stop/timeout scenarios. Table B v3: B21 asserts the execution
names the branch error that propagated; B5, B6 and B20 stay not
applicable because Java map does not throw. README states rule 9 and the
core requirement as in spec v3.

Author: ParidelPooya

telemetry-exporter/README.md

@@ -263,9 +263,17 @@ this rule. The rule applies to the execution-level `error`, every `operations[].
 7. A failure gets the same name whether the record is built live or from a replayed checkpoint.
 8. When the execution fails because an operation's error propagated, the execution `error.name`
    equals that operation's `error.name`.
-9. If the SDK cannot tell which of several failures caused a wrapper, it does not guess. It
-   reports the wrapper's name. Two map items or parallel branches that fail with the same message
-   but different types are an example.
+9. If a checkpoint holds only a wrapper type, which an older SDK can write, the name is that
+   wrapper's name. The exporter never guesses a cause from other operations.
+
+The core SDK checkpoints the wrapped error, not the wrapper. When a child context, map item or
+parallel branch fails because an SDK wrapper error escaped it, the Java SDK writes the original
+error's `ErrorType`, `ErrorMessage`, `ErrorData` and `StackTrace` into that context's checkpoint.
+An SDK error that names the failure itself (a timed-out callback, a timed-out or stopped invoke) is
+written under its own class name. A `waitForCallback` context keeps the callback's own error. So
+the exporter names an operation by reducing its own `ErrorType` (rule 6) and names the execution
+by unwrapping its error's cause chain (rules 2 to 5). It keeps no matching by message, timestamp or
+tree position.
 
 A callback that is failed externally with an explicit `ErrorType` is named after that type, after
 the reduction of rule 6. This includes the type `"Error"`, which reports `Error`. Only a missing or
@@ -304,22 +312,27 @@ How the Java exporter applies it:
   timeout. The operation and the execution report `CallbackTimeoutException`,
   `InvokeTimedOutException` or `InvokeStoppedException`, whatever error type the checkpoint
   carries. A stopped invoke is not named after its stop error: a stop with `errorType`
-  `States.Stopped` or `com.acme.PaymentError` reports `InvokeStoppedException`.
+  `States.Stopped` or `com.acme.PaymentError` reports `InvokeStoppedException`. Inside a child
+  context the core checkpoints that SDK error as the context's error, so the invoke, every
+  enclosing context and the execution report the same name, live and replayed.
 - After 16 unwraps, or at a cycle, the reported wrapper's name is its checkpointed `errorType`,
   reduced; with a blank type it is the SDK failure class below.
-- When an operation failed with no error type (for example a callback failed externally without an
-  `errorType`), the operation and the execution report the SDK exception the core throws for it,
-  such as `CallbackFailedException`.
+- When a callback or invoke failed with no error type (for example a callback failed externally
+  without an `errorType`), the operation and the execution report the SDK exception the core throws
+  for it, such as `CallbackFailedException`. A failed step or context always has a type in its
+  checkpoint. A context checkpoint written by an older SDK without one reports the wrapper's name
+  for the execution and no operation error (rule 9).
 - When the checkpoint has no error at all, the operation error has the SDK exception's name and a
   `null` message, because there is no original message to keep. This is the case for a timed-out
   callback and a timed-out invoke in the local test runner, and for a stopped invoke stopped
   without an error. Before this change such operations had no `error` object; a reader that tests
   `error != null` now sees one with `"message": null`. The execution error of a timed-out callback
   has the message `Callback timed out: <callbackId>`, built by `CallbackTimeoutException`; it is not
   checkpointed, and the JS and Python exporters report `Callback timed out` without the id.
-- Java `map` and `parallel` return item and branch failures as data and do not throw them, so the
-  SDK never has to choose between several failures (rule 9). The execution error is whatever the
-  handler throws.
+- Java `map` and `parallel` return item and branch failures as data and do not throw them. Each
+  item and branch is named after its own type. For `parallel` the execution error is the error of
+  the branch whose future the handler calls `get()` on (Table B, B21); `map` has no `throwIfError`,
+  so B5, B6 and B20 have no propagated execution error in Java.
 - Non-class type strings are reduced too: an external callback failure with `errorType`
   `States.Timeout` reports `Timeout`.
 

telemetry-exporter/src/main/java/software/amazon/lambda/durable/telemetry/DurableExecutionTelemetry.java

@@ -6,9 +6,9 @@
 import java.util.Collections;
 import java.util.IdentityHashMap;
 import java.util.Set;
-import java.util.regex.Pattern;
 import java.util.function.Function;
 import java.util.function.UnaryOperator;
+import java.util.regex.Pattern;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import software.amazon.awssdk.services.lambda.model.ErrorObject;
@@ -36,7 +36,6 @@
 import software.amazon.lambda.durable.exception.StepInterruptedException;
 import software.amazon.lambda.durable.exception.UnrecoverableDurableExecutionException;
 import software.amazon.lambda.durable.exception.WaitForConditionFailedException;
-import software.amazon.lambda.durable.model.OperationSubType;
 import software.amazon.lambda.durable.plugin.DurableExecutionPluginFactory;
 import software.amazon.lambda.durable.plugin.InvocationEndInfo;
 import software.amazon.lambda.durable.plugin.InvocationInfo;
@@ -350,21 +349,16 @@ private static String sdkErrorOfOperation(Throwable wrapper) {
     }
 
     /**
-     * Returns the simple name of the SDK exception the core throws when an operation of this type, sub-type and status
-     * fails with no reconstructable user error, or {@code null} when there is none. Used when the checkpoint carries no
-     * error type, so an operation record and the execution error it propagates to get the same name.
+     * Returns the simple name of the SDK exception the core throws for a callback or invoke that failed, timed out or
+     * was stopped with no error type: a callback or invoke caller can leave the type out, and a timeout carries no
+     * error. {@code null} for any other operation. A failed step or context always checkpoints a type, because the core
+     * checkpoints the wrapped error of a failed context; an older SDK's checkpoint without one reports no name.
      */
     static String sdkFailureName(String type, String subType, OperationStatus status) {
         if (type == null || status == null) {
             return null;
         }
         Class<?> failure = switch (type) {
-            case "STEP" ->
-                status != OperationStatus.FAILED
-                        ? null
-                        : OperationSubType.WAIT_FOR_CONDITION.getValue().equals(subType)
-                                ? WaitForConditionFailedException.class
-                                : StepFailedException.class;
             case "CALLBACK" ->
                 switch (status) {
                     case FAILED -> CallbackFailedException.class;
@@ -378,26 +372,11 @@ static String sdkFailureName(String type, String subType, OperationStatus status
                     case STOPPED -> InvokeStoppedException.class;
                     default -> null;
                 };
-            case "CONTEXT" -> status != OperationStatus.FAILED ? null : contextFailure(subType);
             default -> null;
         };
         return failure == null ? null : failure.getSimpleName();
     }
 
-    private static Class<?> contextFailure(String subType) {
-        if (OperationSubType.MAP_ITERATION.getValue().equals(subType)) {
-            return MapIterationFailedException.class;
-        }
-        if (OperationSubType.PARALLEL_BRANCH.getValue().equals(subType)) {
-            return ParallelBranchFailedException.class;
-        }
-        if (OperationSubType.RUN_IN_CHILD_CONTEXT.getValue().equals(subType)
-                || OperationSubType.WITH_RETRY.getValue().equals(subType)) {
-            return ChildContextFailedException.class;
-        }
-        return null;
-    }
-
     /** The address suffix of a hidden class's {@link Class#getName()}, which changes on every JVM start. */
     private static final Pattern HIDDEN_CLASS_SUFFIX = Pattern.compile("/0x[0-9a-fA-F]+$");
 

telemetry-exporter/src/test/java/software/amazon/lambda/durable/telemetry/ErrorNameScenarioTest.java

@@ -307,12 +307,8 @@ private static void check(
             "B6",
             "same as B5: Java map does not throw item failures",
             "B20",
-            "same as B5: Java map does not throw item failures, so the SDK never has to choose between the two items"
-                    + " (rule 9)",
-            "B21",
-            "Java parallel returns a ParallelResult of branch statuses and does not throw; only the branch future the"
-                    + " handler calls get() on throws, and it throws that branch's own error, so the SDK never has to"
-                    + " choose between branches (rule 9)");
+            "same as B5: Java map does not throw item failures and has no throwIfError, so no item's error propagates;"
+                    + " each item's own type is still asserted");
 
     enum Row {
         B1,
@@ -662,7 +658,7 @@ void tableB(Row row) {
                         MSG,
                         Map.of("fanout-iteration-0", "PaymentError", "fanout-iteration-1", "FraudError"),
                         MSG);
-            case B21 -> // Two parallel branches fail with the same message and different types.
+            case B21 -> // Two parallel branches fail like B20; the execution names the branch error that propagated.
                 check(
                         "B21",
                         m -> (in, ctx) -> failure(m, ctx, c -> {
@@ -678,7 +674,9 @@ void tableB(Row row) {
                             }
                         }),
                         null,
-                        null, // execution: not applicable in Java, see EXECUTION_NOT_APPLICABLE
+                        // Java parallel does not throw; the error that propagates is the one of the branch whose
+                        // future the handler calls get() on.
+                        "PaymentError",
                         MSG,
                         Map.of("pay", "PaymentError", "fraud", "FraudError"),
                         MSG);
@@ -786,6 +784,58 @@ void invokeTimeoutAndStopAreSdkErrors(Mode mode) {
         }
     }
 
+    /**
+     * An invoke that is stopped or times out inside a child context: the invoke, the enclosing context and the
+     * execution report the same SDK error name, live and replayed, whatever error type a stop carries. The core
+     * checkpoints the SDK error, not the stop error's type, as the context's error. Nested two contexts deep as well.
+     */
+    @ParameterizedTest
+    @EnumSource(Mode.class)
+    void stoppedOrTimedOutInvokeInsideAChildHasOneName(Mode mode) {
+        for (boolean nested : new boolean[] {false, true}) {
+            for (String outcome : List.of("timeout", "stop-states", "stop-user")) {
+                String row = (nested ? "nested " : "") + outcome + " " + mode;
+                Function<DurableContext, String> invokeInChild = c ->
+                        c.runInChildContext("child", String.class, cc -> cc.invoke("callee", "fn", "x", String.class));
+                var records = run(
+                        (in, ctx) -> failure(
+                                mode,
+                                ctx,
+                                nested
+                                        ? c -> c.runInChildContext("outer", String.class, invokeInChild::apply)
+                                        : invokeInChild),
+                        r -> {
+                            r.run("in");
+                            switch (outcome) {
+                                case "timeout" -> r.timeoutChainedInvoke("callee");
+                                case "stop-states" ->
+                                    r.stopChainedInvoke(
+                                            "callee",
+                                            ErrorObject.builder()
+                                                    .errorType("States.Stopped")
+                                                    .errorMessage(MSG)
+                                                    .build());
+                                default ->
+                                    r.stopChainedInvoke(
+                                            "callee",
+                                            ErrorObject.builder()
+                                                    .errorType("com.acme.PaymentError")
+                                                    .errorMessage(MSG)
+                                                    .build());
+                            }
+                            r.runUntilComplete("in");
+                        });
+                String expected = "timeout".equals(outcome) ? "InvokeTimedOutException" : "InvokeStoppedException";
+                var names = nested ? List.of("callee", "child", "outer") : List.of("callee", "child");
+                var obs = observe(records, names, mode);
+                assertEquals(expected, obs.execution().name(), row + " execution");
+                for (String name : names) {
+                    assertEquals(expected, obs.operations().get(name).name(), row + " " + name);
+                }
+            }
+        }
+    }
+
     /**
      * Callback and invoke error types come from outside the JVM: a {@code '/'} in them is not a hidden-class suffix and
      * the type is reduced as a whole (Table A).

telemetry-exporter/src/test/java/software/amazon/lambda/durable/telemetry/ErrorNameTest.java

@@ -464,8 +464,8 @@ void sdkErrorsThatAreNotWrappersReportTheirOwnName() {
     }
 
     /**
-     * R2 (Java only): a hidden class's name ends in {@code /0x…}, which changes on every JVM start. The name is cut at
-     * the first {@code '/'} before the reduction, live and from the checkpoint.
+     * R2 (Java only): a hidden class's name ends in {@code /0x…}, which changes on every JVM start. Only that trailing
+     * {@code /0x<hex>} is removed before the reduction, live and from the checkpoint.
      */
     @Test
     void hiddenClassNameDropsTheAddressSuffix() throws Throwable {
@@ -549,12 +549,6 @@ void blankCheckpointedTypeUsesTheSdkFailureClassOfTheOperation() {
 
     @Test
     void sdkFailureNamesMatchTheCoreExceptions() {
-        assertEquals(
-                "StepFailedException",
-                DurableExecutionTelemetry.sdkFailureName("STEP", "Step", OperationStatus.FAILED));
-        assertEquals(
-                "WaitForConditionFailedException",
-                DurableExecutionTelemetry.sdkFailureName("STEP", "WaitForCondition", OperationStatus.FAILED));
         assertEquals(
                 "CallbackFailedException",
                 DurableExecutionTelemetry.sdkFailureName("CALLBACK", "Callback", OperationStatus.FAILED));
@@ -570,17 +564,11 @@ void sdkFailureNamesMatchTheCoreExceptions() {
         assertEquals(
                 "InvokeStoppedException",
                 DurableExecutionTelemetry.sdkFailureName("CHAINED_INVOKE", "ChainedInvoke", OperationStatus.STOPPED));
-        assertEquals(
-                "MapIterationFailedException",
-                DurableExecutionTelemetry.sdkFailureName("CONTEXT", "MapIteration", OperationStatus.FAILED));
-        assertEquals(
-                "ParallelBranchFailedException",
-                DurableExecutionTelemetry.sdkFailureName("CONTEXT", "ParallelBranch", OperationStatus.FAILED));
-        assertEquals(
-                "ChildContextFailedException",
-                DurableExecutionTelemetry.sdkFailureName("CONTEXT", "RunInChildContext", OperationStatus.FAILED));
-        assertNull(DurableExecutionTelemetry.sdkFailureName("CONTEXT", "WaitForCallback", OperationStatus.FAILED));
-        assertNull(DurableExecutionTelemetry.sdkFailureName("STEP", "Step", OperationStatus.SUCCEEDED));
+        // A failed step or context always checkpoints its wrapped error's type, so there is no fallback for them.
+        assertNull(DurableExecutionTelemetry.sdkFailureName("STEP", "Step", OperationStatus.FAILED));
+        assertNull(DurableExecutionTelemetry.sdkFailureName("CONTEXT", "RunInChildContext", OperationStatus.FAILED));
+        assertNull(DurableExecutionTelemetry.sdkFailureName("CONTEXT", "MapIteration", OperationStatus.FAILED));
+        assertNull(DurableExecutionTelemetry.sdkFailureName("CALLBACK", "Callback", OperationStatus.SUCCEEDED));
         assertNull(DurableExecutionTelemetry.sdkFailureName("WAIT", "Wait", OperationStatus.FAILED));
         assertNull(DurableExecutionTelemetry.sdkFailureName(null, null, null));
     }