Expose lastFailure and raw proto on ActivityExecutionDescription.

Author: GregoryTravis

temporal-sdk/src/main/java/io/temporal/client/ActivityExecutionDescription.java

@@ -66,6 +66,12 @@ private ActivityExecutionInfo info() {
     return info;
   }
 
+  /** The raw protobuf info returned by the server for this activity execution. */
+  @Nonnull
+  public ActivityExecutionInfo getRawInfo() {
+    return info;
+  }
+
   /** Current attempt number (starts at 1). */
   public int getAttempt() {
     return info().getAttempt();
@@ -129,6 +135,12 @@ public Instant getLastStartedTime() {
         : null;
   }
 
+  /** Failure details from the last failed attempt. {@code null} if no failure has occurred. */
+  @Nullable
+  public io.temporal.api.failure.v1.Failure getLastFailure() {
+    return info().hasLastFailure() ? info().getLastFailure() : null;
+  }
+
   /** Identity of the worker that last processed this activity. */
   @Nullable
   public String getLastWorkerIdentity() {

temporal-sdk/src/test/java/io/temporal/client/ActivityExecutionDescriptionTest.java

@@ -7,6 +7,7 @@
 import io.temporal.api.common.v1.ActivityType;
 import io.temporal.api.common.v1.Payloads;
 import io.temporal.api.enums.v1.ActivityExecutionStatus;
+import io.temporal.api.failure.v1.Failure;
 import io.temporal.common.Priority;
 import io.temporal.common.WorkerDeploymentVersion;
 import io.temporal.common.converter.DataConverter;
@@ -64,6 +65,7 @@ public void testNullableFieldsAbsentByDefault() {
     assertFalse(desc.hasHeartbeatDetails());
     assertNull(desc.getWorkerDeploymentVersion());
     assertNull(desc.getPriority());
+    assertNull(desc.getLastFailure());
   }
 
   @Test
@@ -130,6 +132,33 @@ public void testGetWorkerDeploymentVersionPresent() {
     assertEquals("build-42", version.getBuildId());
   }
 
+  @Test
+  public void testGetLastFailureAbsent() {
+    ActivityExecutionDescription desc =
+        new ActivityExecutionDescription(buildInfo("id", "run"), CONVERTER, "test-ns", null);
+    assertNull(desc.getLastFailure());
+  }
+
+  @Test
+  public void testGetLastFailurePresent() {
+    Failure failure = Failure.newBuilder().setMessage("boom").build();
+    ActivityExecutionInfo info = buildInfo("id", "run").toBuilder().setLastFailure(failure).build();
+    ActivityExecutionDescription desc =
+        new ActivityExecutionDescription(info, CONVERTER, "test-ns", null);
+
+    Failure result = desc.getLastFailure();
+    assertNotNull(result);
+    assertEquals("boom", result.getMessage());
+  }
+
+  @Test
+  public void testGetRawInfo() {
+    ActivityExecutionInfo info = buildInfo("id", "run");
+    ActivityExecutionDescription desc =
+        new ActivityExecutionDescription(info, CONVERTER, "test-ns", null);
+    assertSame(info, desc.getRawInfo());
+  }
+
   @Test
   public void testGetPriorityPresent() {
     io.temporal.api.common.v1.Priority protoPriority =

temporal-sdk/src/test/java/io/temporal/client/functional/StandaloneActivityTest.java

@@ -10,14 +10,18 @@
 import io.temporal.activity.ActivityInfo;
 import io.temporal.activity.ActivityInterface;
 import io.temporal.activity.ActivityMethod;
+import io.temporal.api.activity.v1.ActivityExecutionInfo;
 import io.temporal.api.enums.v1.ActivityExecutionStatus;
 import io.temporal.api.enums.v1.ActivityIdConflictPolicy;
 import io.temporal.api.enums.v1.ActivityIdReusePolicy;
+import io.temporal.api.failure.v1.Failure;
 import io.temporal.client.*;
+import io.temporal.common.RetryOptions;
 import io.temporal.common.interceptors.ActivityClientCallsInterceptor;
 import io.temporal.common.interceptors.ActivityClientCallsInterceptor.*;
 import io.temporal.common.interceptors.ActivityClientCallsInterceptorBase;
 import io.temporal.common.interceptors.ActivityClientInterceptorBase;
+import io.temporal.failure.ApplicationFailure;
 import io.temporal.failure.CanceledFailure;
 import io.temporal.testing.internal.SDKTestWorkflowRule;
 import java.time.Duration;
@@ -86,6 +90,12 @@ public interface ConcatActivity {
     String concat(String a, String b);
   }
 
+  @ActivityInterface
+  public interface AlwaysFailActivity {
+    @ActivityMethod(name = "AlwaysFail")
+    void alwaysFail();
+  }
+
   /** Snapshot of {@link ActivityInfo} fields captured inside an activity body. */
   public static class ActivityInfoSnapshot {
     public String activityId;
@@ -183,6 +193,13 @@ public String concat(String a, String b) {
     }
   }
 
+  public static class AlwaysFailActivityImpl implements AlwaysFailActivity {
+    @Override
+    public void alwaysFail() {
+      throw ApplicationFailure.newFailure("deliberate failure", "test-type");
+    }
+  }
+
   // ---------------------------------------------------------------------------
   // Test rule
   // ---------------------------------------------------------------------------
@@ -197,7 +214,8 @@ public String concat(String a, String b) {
               new AsyncCompletionActivityImpl(),
               new InspectInfoActivityImpl(),
               new EchoVoidActivityImpl(),
-              new ConcatActivityImpl())
+              new ConcatActivityImpl(),
+              new AlwaysFailActivityImpl())
           .build();
 
   // ---------------------------------------------------------------------------
@@ -812,6 +830,65 @@ public void testCompletionClientStandaloneCompleteWithRunId() throws Interrupted
     }
   }
 
+  @Test
+  public void testDescribeRawInfoMatchesTypedAccessors() {
+    assumeTrue(SDKTestWorkflowRule.useExternalService);
+    ActivityClient client = newActivityClient();
+    String activityId = uniqueId();
+
+    ActivityHandle<String> handle =
+        client.start(SimpleActivity.class, SimpleActivity::execute, simpleOpts(activityId), "raw");
+    handle.getResult();
+
+    ActivityExecutionDescription desc = handle.describe();
+    ActivityExecutionInfo rawInfo = desc.getRawInfo();
+
+    assertEquals(desc.getActivityId(), rawInfo.getActivityId());
+    assertEquals(desc.getActivityType(), rawInfo.getActivityType().getName());
+    assertEquals(desc.getTaskQueue(), rawInfo.getTaskQueue());
+    assertEquals(desc.getStatus(), rawInfo.getStatus());
+    assertEquals(desc.getAttempt(), rawInfo.getAttempt());
+  }
+
+  @Test
+  public void testDescribeLastFailureIsPopulatedDuringRetryBackoff() {
+    assumeTrue(SDKTestWorkflowRule.useExternalService);
+    ActivityClient client = newActivityClient();
+    StartActivityOptions opts =
+        StartActivityOptions.newBuilder()
+            .setId(uniqueId())
+            .setTaskQueue(testWorkflowRule.getTaskQueue())
+            .setScheduleToCloseTimeout(Duration.ofMinutes(5))
+            .setStartToCloseTimeout(Duration.ofSeconds(10))
+            .setRetryOptions(
+                RetryOptions.newBuilder()
+                    .setMaximumAttempts(10)
+                    .setInitialInterval(Duration.ofSeconds(15))
+                    .build())
+            .build();
+
+    ActivityHandle<Void> handle =
+        client.start(AlwaysFailActivity.class, AlwaysFailActivity::alwaysFail, opts);
+    try {
+      assertEventually(
+          Duration.ofSeconds(60),
+          () -> {
+            ActivityExecutionDescription desc = handle.describe();
+            Failure lastFailure = desc.getLastFailure();
+            assertNotNull("last_failure should be set after a failed attempt", lastFailure);
+            assertEquals("deliberate failure", lastFailure.getMessage());
+            // raw info must agree with the typed accessor
+            assertTrue(desc.getRawInfo().hasLastFailure());
+            assertEquals(lastFailure, desc.getRawInfo().getLastFailure());
+          });
+    } finally {
+      try {
+        handle.terminate("test cleanup");
+      } catch (Exception ignored) {
+      }
+    }
+  }
+
   // ---------------------------------------------------------------------------
   // Interceptor helpers
   // ---------------------------------------------------------------------------