fix(telemetry): strip only a hidden-class suffix from Java type names

javaTypeName cut every type name at the first '/', and wrapperName passed
callback and invoke error types through it, so an external type such as
payments/v1.PaymentError was named 'payments' instead of PaymentError.

Only a trailing /0x<hex> hidden-class suffix of Class.getName() (live or
as the core checkpointed it) is removed now, and callback and invoke
error types, which come from outside the JVM, are reduced as a whole by
the Table A rule.

Author: ParidelPooya

telemetry-exporter/README.md

@@ -285,9 +285,10 @@ How the Java exporter applies it:
   `pkg.Foo` (binary name `pkg.Foo$1LocalError`) gives `1LocalError`; an anonymous class gives its
   last segment, for example `1`. A string that ends with a separator (`trailing.`, `Outer$`) is
   kept as it is. U+00A0, U+FEFF, U+001C and U+2003 are not blank, so a type made of them is kept.
-- A hidden class's name ends in `/0x…`, a suffix that changes on every JVM start. The name is cut
-  at the first `/` before rule 6, live and from the checkpoint, so `pkg.Gen$HiddenErr/0x…` gives
-  `HiddenErr`.
+- A hidden class's name ends in `/0x…`, a suffix that changes on every JVM start. Only a trailing
+  suffix matching `/0x[0-9a-fA-F]+$` is removed before rule 6, live and from the checkpoint, so
+  `pkg.Gen$HiddenErr/0x…` gives `HiddenErr`. Callback and invoke error types come from outside the
+  JVM and are never cut: `payments/v1.PaymentError` gives `PaymentError`.
 - The SDK wrappers are an explicit list, matched on the exact runtime class:
   `DurableOperationException`, `UnrecoverableDurableExecutionException`, `StepException`,
   `CallbackException`, `InvokeException`, `StepFailedException`, `CallbackFailedException`,

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

@@ -6,6 +6,7 @@
 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 org.slf4j.Logger;
@@ -302,7 +303,8 @@ private static String wrapperName(Throwable wrapper) {
         ErrorObject error = extractErrorObject(wrapper);
         String type = error == null ? null : error.errorType();
         if (!isBlankType(type)) {
-            return javaTypeName(type);
+            // A callback or invoke error type is supplied from outside the JVM and is never a Java class name.
+            return hasExternalErrorType(wrapper) ? simpleTypeName(type) : javaTypeName(type);
         }
         if (wrapper instanceof DurableOperationException doe && doe.getOperation() != null) {
             var op = doe.getOperation();
@@ -317,6 +319,15 @@ private static String wrapperName(Throwable wrapper) {
         return DEFAULT_ERROR_NAME;
     }
 
+    /** {@code true} when the wrapper's checkpointed error type was written by a callback or invoke caller. */
+    private static boolean hasExternalErrorType(Throwable wrapper) {
+        if (!(wrapper instanceof DurableOperationException doe) || doe.getOperation() == null) {
+            return false;
+        }
+        var type = doe.getOperation().type();
+        return type == OperationType.CALLBACK || type == OperationType.CHAINED_INVOKE;
+    }
+
     /**
      * The SDK error (not a wrapper) the core throws for a wrapper's operation, whatever its checkpoint says: a
      * timed-out callback, or a timed-out or stopped invoke. {@code null} for any other operation.
@@ -387,17 +398,20 @@ private static Class<?> contextFailure(String subType) {
         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]+$");
+
     /**
-     * {@link #simpleTypeName} for a Java class name, live or checkpointed. The name of a hidden class has a
-     * {@code /0x…} suffix that changes on every JVM start, so the name is cut at the first {@code '/'} first and the
-     * same failure keeps the same name across cold starts.
+     * {@link #simpleTypeName} for a Java class name ({@link Class#getName()}), live or as the core checkpointed it.
+     * Only a hidden-class suffix matching {@code /0x[0-9a-fA-F]+$} is removed first, so the same failure keeps the same
+     * name across cold starts. No other {@code '/'} is touched, and type strings from outside the JVM (callback and
+     * invoke error types) never come here.
      */
     static String javaTypeName(String className) {
         if (className == null) {
             return DEFAULT_ERROR_NAME;
         }
-        int slash = className.indexOf('/');
-        return simpleTypeName(slash < 0 ? className : className.substring(0, slash));
+        return simpleTypeName(HIDDEN_CLASS_SUFFIX.matcher(className).replaceFirst(""));
     }
 
     /**

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

@@ -785,4 +785,32 @@ void invokeTimeoutAndStopAreSdkErrors(Mode mode) {
             }
         }
     }
+
+    /**
+     * 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).
+     */
+    @ParameterizedTest
+    @EnumSource(Mode.class)
+    void externalTypeWithSlashIsReducedAsAWhole(Mode mode) {
+        String external = "payments/v1.PaymentError";
+        var viaCallback = run(
+                (in, ctx) -> failure(
+                        mode, ctx, c -> c.createCallback("cb", String.class).get()),
+                failCallback(external));
+        var cb = observe(viaCallback, List.of("cb"), mode);
+        assertEquals("PaymentError", cb.execution().name(), "callback execution");
+        assertEquals("PaymentError", cb.operations().get("cb").name(), "callback operation");
+
+        var viaInvoke = run((in, ctx) -> failure(mode, ctx, c -> c.invoke("callee", "fn", "x", String.class)), r -> {
+            r.run("in");
+            r.failChainedInvoke(
+                    "callee",
+                    ErrorObject.builder().errorType(external).errorMessage(MSG).build());
+            r.runUntilComplete("in");
+        });
+        var inv = observe(viaInvoke, List.of("callee"), mode);
+        assertEquals("PaymentError", inv.execution().name(), "invoke execution");
+        assertEquals("PaymentError", inv.operations().get("callee").name(), "invoke operation");
+    }
 }

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

@@ -486,6 +486,11 @@ void hiddenClassNameDropsTheAddressSuffix() throws Throwable {
                         .name());
         assertEquals("Lambda", DurableExecutionTelemetry.javaTypeName("pkg.Foo$$Lambda/0x1"));
         assertEquals("Error", DurableExecutionTelemetry.javaTypeName("/0x1"));
+        assertEquals("Lambda", DurableExecutionTelemetry.javaTypeName("pkg.Foo$$Lambda/0x00007f3aBcD"));
+        // Only a trailing /0x<hex> is a hidden-class suffix; any other '/' is part of the name.
+        assertEquals("PaymentError", DurableExecutionTelemetry.javaTypeName("payments/v1.PaymentError"));
+        assertEquals("Foo/0xZZ", DurableExecutionTelemetry.javaTypeName("pkg.Foo/0xZZ"));
+        assertEquals("b/0x1", DurableExecutionTelemetry.javaTypeName("a.b/0x1/0x2"));
     }
 
     /** Rule 6 blank: only the six ASCII whitespace characters; the Table A vectors cover each single character. */