udpate

nytian · nytian · commit 17f1ec25ed97 · 2026-02-23T11:50:31.000-08:00
diff --git a/client/build.gradle b/client/build.gradle
@@ -57,7 +57,8 @@ compileTestJava {
     sourceCompatibility = JavaVersion.VERSION_11
     targetCompatibility = JavaVersion.VERSION_11
     options.fork = true
-    options.forkOptions.executable = "${PATH_TO_TEST_JAVA_RUNTIME}/bin/javac"
+    def javacName = org.gradle.internal.os.OperatingSystem.current().isWindows() ? 'javac.exe' : 'javac'
+    options.forkOptions.executable = "${PATH_TO_TEST_JAVA_RUNTIME}/bin/${javacName}"
 }
 
 task downloadProtoFiles {
@@ -90,7 +91,9 @@ protobuf {
     }
     generateProtoTasks {
         all()*.plugins { grpc {} }
-        all()*.dependsOn downloadProtoFiles
+        if (project.gradle.startParameter.taskNames.any { it.contains('downloadProtoFiles') }) {
+            all()*.dependsOn downloadProtoFiles
+        }
     }
 }
 
@@ -107,7 +110,8 @@ sourceSets {
 }
 
 tasks.withType(Test) {
-    executable = new File("${PATH_TO_TEST_JAVA_RUNTIME}", 'bin/java')
+    def javaName = org.gradle.internal.os.OperatingSystem.current().isWindows() ? 'java.exe' : 'java'
+    executable = new File("${PATH_TO_TEST_JAVA_RUNTIME}", "bin/${javaName}")
 }
 
 test {
diff --git a/client/src/main/java/com/microsoft/durabletask/DurableTaskGrpcWorker.java b/client/src/main/java/com/microsoft/durabletask/DurableTaskGrpcWorker.java
@@ -34,6 +34,7 @@ public final class DurableTaskGrpcWorker implements AutoCloseable {
     private final DataConverter dataConverter;
     private final Duration maximumTimerInterval;
     private final DurableTaskGrpcWorkerVersioningOptions versioningOptions;
+    private final ExceptionPropertiesProvider exceptionPropertiesProvider;
 
     private final TaskHubSidecarServiceBlockingStub sidecarClient;
 
@@ -65,6 +66,7 @@ public final class DurableTaskGrpcWorker implements AutoCloseable {
         this.dataConverter = builder.dataConverter != null ? builder.dataConverter : new JacksonDataConverter();
         this.maximumTimerInterval = builder.maximumTimerInterval != null ? builder.maximumTimerInterval : DEFAULT_MAXIMUM_TIMER_INTERVAL;
         this.versioningOptions = builder.versioningOptions;
+        this.exceptionPropertiesProvider = builder.exceptionPropertiesProvider;
     }
 
     /**
@@ -118,7 +120,8 @@ public void startAndBlock() {
                 this.dataConverter,
                 this.maximumTimerInterval,
                 logger,
-                this.versioningOptions);
+                this.versioningOptions,
+                this.exceptionPropertiesProvider);
         TaskActivityExecutor taskActivityExecutor = new TaskActivityExecutor(
                 this.activityFactories,
                 this.dataConverter,
@@ -228,8 +231,9 @@ public void startAndBlock() {
                                 activityRequest.getInput().getValue(),
                                 activityRequest.getTaskId());
                         } catch (Throwable e) {
-                            failureDetails = new FailureDetails(
-                                    e instanceof Exception ? (Exception) e : new RuntimeException(e)).toProto();
+                            Exception ex = e instanceof Exception ? (Exception) e : new RuntimeException(e);
+                            failureDetails = FailureDetails.fromException(
+                                    ex, this.exceptionPropertiesProvider).toProto();
                         }
 
                         ActivityResponse.Builder responseBuilder = ActivityResponse.newBuilder()
diff --git a/client/src/main/java/com/microsoft/durabletask/DurableTaskGrpcWorkerBuilder.java b/client/src/main/java/com/microsoft/durabletask/DurableTaskGrpcWorkerBuilder.java
@@ -18,6 +18,7 @@ public final class DurableTaskGrpcWorkerBuilder {
     DataConverter dataConverter;
     Duration maximumTimerInterval;
     DurableTaskGrpcWorkerVersioningOptions versioningOptions;
+    ExceptionPropertiesProvider exceptionPropertiesProvider;
 
     /**
      * Adds an orchestration factory to be used by the constructed {@link DurableTaskGrpcWorker}.
@@ -125,6 +126,21 @@ public DurableTaskGrpcWorkerBuilder useVersioning(DurableTaskGrpcWorkerVersionin
         return this;
     }
 
+    /**
+     * Sets the {@link ExceptionPropertiesProvider} to use for extracting custom properties from exceptions.
+     * <p>
+     * When set, the provider is invoked whenever an activity or orchestration fails with an exception. The returned
+     * properties are included in the {@link FailureDetails} and can be retrieved via
+     * {@link FailureDetails#getProperties()}.
+     *
+     * @param provider the exception properties provider
+     * @return this builder object
+     */
+    public DurableTaskGrpcWorkerBuilder exceptionPropertiesProvider(ExceptionPropertiesProvider provider) {
+        this.exceptionPropertiesProvider = provider;
+        return this;
+    }
+
     /**
      * Initializes a new {@link DurableTaskGrpcWorker} object with the settings specified in the current builder object.
      * @return a new {@link DurableTaskGrpcWorker} object
diff --git a/client/src/main/java/com/microsoft/durabletask/ExceptionPropertiesProvider.java b/client/src/main/java/com/microsoft/durabletask/ExceptionPropertiesProvider.java
@@ -0,0 +1,45 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+package com.microsoft.durabletask;
+
+import javax.annotation.Nullable;
+import java.util.Map;
+
+/**
+ * Provider interface for extracting custom properties from exceptions.
+ * <p>
+ * Implementations of this interface can be registered with a {@link DurableTaskGrpcWorkerBuilder} to include
+ * custom exception properties in {@link FailureDetails} when activities or orchestrations fail.
+ * These properties are then available via {@link FailureDetails#getProperties()}.
+ * <p>
+ * Example usage:
+ * <pre>{@code
+ * DurableTaskGrpcWorker worker = new DurableTaskGrpcWorkerBuilder()
+ *     .exceptionPropertiesProvider(exception -> {
+ *         if (exception instanceof MyCustomException) {
+ *             MyCustomException custom = (MyCustomException) exception;
+ *             Map<String, Object> props = new HashMap<>();
+ *             props.put("errorCode", custom.getErrorCode());
+ *             props.put("retryable", custom.isRetryable());
+ *             return props;
+ *         }
+ *         return null;
+ *     })
+ *     .addOrchestration(...)
+ *     .build();
+ * }</pre>
+ */
+@FunctionalInterface
+public interface ExceptionPropertiesProvider {
+
+    /**
+     * Extracts custom properties from the given exception.
+     * <p>
+     * Return {@code null} or an empty map if no custom properties should be included for this exception.
+     *
+     * @param exception the exception to extract properties from
+     * @return a map of property names to values, or {@code null}
+     */
+    @Nullable
+    Map<String, Object> getExceptionProperties(Exception exception);
+}
diff --git a/client/src/main/java/com/microsoft/durabletask/FailureDetails.java b/client/src/main/java/com/microsoft/durabletask/FailureDetails.java
@@ -58,10 +58,36 @@ public final class FailureDetails {
              exception.getMessage(),
              getFullStackTrace(exception),
              false,
-             exception.getCause() != null ? fromExceptionRecursive(exception.getCause()) : null,
+             exception.getCause() != null ? fromExceptionRecursive(exception.getCause(), null) : null,
              null);
     }
 
+    /**
+     * Creates a {@code FailureDetails} from an exception, optionally using the provided
+     * {@link ExceptionPropertiesProvider} to extract custom properties.
+     *
+     * @param exception the exception that caused the failure
+     * @param provider  the provider for extracting custom properties, or {@code null}
+     * @return a new {@code FailureDetails} instance
+     */
+    static FailureDetails fromException(Exception exception, @Nullable ExceptionPropertiesProvider provider) {
+        Map<String, Object> properties = null;
+        if (provider != null) {
+            try {
+                properties = provider.getExceptionProperties(exception);
+            } catch (Exception ignored) {
+                // Don't let provider errors mask the original failure
+            }
+        }
+        return new FailureDetails(
+                exception.getClass().getName(),
+                exception.getMessage(),
+                getFullStackTrace(exception),
+                false,
+                exception.getCause() != null ? fromExceptionRecursive(exception.getCause(), provider) : null,
+                properties);
+    }
+
     FailureDetails(TaskFailureDetails proto) {
         this(proto.getErrorType(),
              proto.getErrorMessage(),
@@ -195,17 +221,27 @@ TaskFailureDetails toProto() {
     }
 
     @Nullable
-    private static FailureDetails fromExceptionRecursive(@Nullable Throwable exception) {
+    private static FailureDetails fromExceptionRecursive(
+            @Nullable Throwable exception,
+            @Nullable ExceptionPropertiesProvider provider) {
         if (exception == null) {
             return null;
         }
+        Map<String, Object> properties = null;
+        if (provider != null && exception instanceof Exception) {
+            try {
+                properties = provider.getExceptionProperties((Exception) exception);
+            } catch (Exception ignored) {
+                // Don't let provider errors mask the original failure
+            }
+        }
         return new FailureDetails(
                 exception.getClass().getName(),
                 exception.getMessage(),
                 getFullStackTrace(exception),
                 false,
-                exception.getCause() != null ? fromExceptionRecursive(exception.getCause()) : null,
-                null);
+                exception.getCause() != null ? fromExceptionRecursive(exception.getCause(), provider) : null,
+                properties);
     }
 
     @Nullable
diff --git a/client/src/main/java/com/microsoft/durabletask/TaskOrchestrationExecutor.java b/client/src/main/java/com/microsoft/durabletask/TaskOrchestrationExecutor.java
@@ -31,18 +31,30 @@ final class TaskOrchestrationExecutor {
     private final Logger logger;
     private final Duration maximumTimerInterval;
     private final DurableTaskGrpcWorkerVersioningOptions versioningOptions;
+    private final ExceptionPropertiesProvider exceptionPropertiesProvider;
 
     public TaskOrchestrationExecutor(
             HashMap<String, TaskOrchestrationFactory> orchestrationFactories,
             DataConverter dataConverter,
             Duration maximumTimerInterval,
             Logger logger,
             DurableTaskGrpcWorkerVersioningOptions versioningOptions) {
+        this(orchestrationFactories, dataConverter, maximumTimerInterval, logger, versioningOptions, null);
+    }
+
+    public TaskOrchestrationExecutor(
+            HashMap<String, TaskOrchestrationFactory> orchestrationFactories,
+            DataConverter dataConverter,
+            Duration maximumTimerInterval,
+            Logger logger,
+            DurableTaskGrpcWorkerVersioningOptions versioningOptions,
+            ExceptionPropertiesProvider exceptionPropertiesProvider) {
         this.orchestrationFactories = orchestrationFactories;
         this.dataConverter = dataConverter;
         this.maximumTimerInterval = maximumTimerInterval;
         this.logger = logger;
         this.versioningOptions = versioningOptions;
+        this.exceptionPropertiesProvider = exceptionPropertiesProvider;
     }
 
     public TaskOrchestratorResult execute(List<HistoryEvent> pastEvents, List<HistoryEvent> newEvents) {
@@ -68,7 +80,7 @@ public TaskOrchestratorResult execute(List<HistoryEvent> pastEvents, List<Histor
             // The orchestrator threw an unhandled exception - fail it
             // TODO: What's the right way to log this?
             logger.warning("The orchestrator failed with an unhandled exception: " + e.toString());
-            context.fail(new FailureDetails(e));
+            context.fail(FailureDetails.fromException(e, this.exceptionPropertiesProvider));
         }
 
         if ((context.continuedAsNew && !context.isComplete) || (completed && context.pendingActions.isEmpty() && !context.waitingForEvents())) {
diff --git a/client/src/test/java/com/microsoft/durabletask/FailureDetailsTest.java b/client/src/test/java/com/microsoft/durabletask/FailureDetailsTest.java
@@ -385,6 +385,112 @@ void constructFromProto_withInnerFailureAndProperties() {
         assertEquals(false, details.getInnerFailure().getProperties().get("retryable"));
     }
 
+    @Test
+    void fromException_withProvider_extractsProperties() {
+        ExceptionPropertiesProvider provider = exception -> {
+            if (exception instanceof IllegalArgumentException) {
+                Map<String, Object> props = new HashMap<>();
+                props.put("paramName", exception.getMessage());
+                props.put("severity", 3);
+                props.put("isCritical", true);
+                return props;
+            }
+            return null;
+        };
+
+        IllegalArgumentException ex = new IllegalArgumentException("userId");
+
+        FailureDetails details = FailureDetails.fromException(ex, provider);
+
+        assertEquals("java.lang.IllegalArgumentException", details.getErrorType());
+        assertEquals("userId", details.getErrorMessage());
+        assertNotNull(details.getProperties());
+        assertEquals(3, details.getProperties().size());
+        assertEquals("userId", details.getProperties().get("paramName"));
+        assertEquals(3, details.getProperties().get("severity"));
+        assertEquals(true, details.getProperties().get("isCritical"));
+    }
+
+    @Test
+    void fromException_withProvider_propertiesOnInnerCauseToo() {
+        ExceptionPropertiesProvider provider = exception -> {
+            Map<String, Object> props = new HashMap<>();
+            props.put("exceptionType", exception.getClass().getSimpleName());
+            return props;
+        };
+
+        IOException inner = new IOException("disk full");
+        RuntimeException outer = new RuntimeException("failed", inner);
+
+        FailureDetails details = FailureDetails.fromException(outer, provider);
+
+        assertNotNull(details.getProperties());
+        assertEquals("RuntimeException", details.getProperties().get("exceptionType"));
+
+        assertNotNull(details.getInnerFailure());
+        assertNotNull(details.getInnerFailure().getProperties());
+        assertEquals("IOException", details.getInnerFailure().getProperties().get("exceptionType"));
+    }
+
+    @Test
+    void fromException_withProvider_returnsNull_noProperties() {
+        ExceptionPropertiesProvider provider = exception -> null;
+
+        RuntimeException ex = new RuntimeException("test");
+
+        FailureDetails details = FailureDetails.fromException(ex, provider);
+
+        assertNull(details.getProperties());
+    }
+
+    @Test
+    void fromException_withNullProvider_noProperties() {
+        RuntimeException ex = new RuntimeException("test");
+
+        FailureDetails details = FailureDetails.fromException(ex, null);
+
+        assertEquals("java.lang.RuntimeException", details.getErrorType());
+        assertEquals("test", details.getErrorMessage());
+        assertNull(details.getProperties());
+    }
+
+    @Test
+    void fromException_providerThrows_gracefullyIgnored() {
+        ExceptionPropertiesProvider provider = exception -> {
+            throw new RuntimeException("provider error");
+        };
+
+        IllegalStateException ex = new IllegalStateException("original error");
+
+        FailureDetails details = FailureDetails.fromException(ex, provider);
+
+        assertEquals("java.lang.IllegalStateException", details.getErrorType());
+        assertEquals("original error", details.getErrorMessage());
+        assertNull(details.getProperties());
+    }
+
+    @Test
+    void fromException_withProvider_roundTripsViaProto() {
+        ExceptionPropertiesProvider provider = exception -> {
+            Map<String, Object> props = new HashMap<>();
+            props.put("errorCode", "VALIDATION_FAILED");
+            props.put("retryCount", 3);
+            props.put("isCritical", true);
+            return props;
+        };
+
+        IllegalArgumentException ex = new IllegalArgumentException("bad input");
+        FailureDetails details = FailureDetails.fromException(ex, provider);
+
+        TaskFailureDetails proto = details.toProto();
+        FailureDetails roundTripped = new FailureDetails(proto);
+
+        assertNotNull(roundTripped.getProperties());
+        assertEquals("VALIDATION_FAILED", roundTripped.getProperties().get("errorCode"));
+        assertEquals(3.0, roundTripped.getProperties().get("retryCount"));
+        assertEquals(true, roundTripped.getProperties().get("isCritical"));
+    }
+
     @Test
     void constructFromProto_withProperties_containsNullKey() {
         // Properties map with a null-valued entry should be preserved

Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,8 @@ compileTestJava {`
`57`	`57`	`sourceCompatibility = JavaVersion.VERSION_11`
`58`	`58`	`targetCompatibility = JavaVersion.VERSION_11`
`59`	`59`	`options.fork = true`
`60`		`- options.forkOptions.executable = "${PATH_TO_TEST_JAVA_RUNTIME}/bin/javac"`
	`60`	`+ def javacName = org.gradle.internal.os.OperatingSystem.current().isWindows() ? 'javac.exe' : 'javac'`
	`61`	`+ options.forkOptions.executable = "${PATH_TO_TEST_JAVA_RUNTIME}/bin/${javacName}"`
`61`	`62`	`}`
`62`	`63`
`63`	`64`	`task downloadProtoFiles {`
`@@ -90,7 +91,9 @@ protobuf {`
`90`	`91`	`}`
`91`	`92`	`generateProtoTasks {`
`92`	`93`	`all()*.plugins { grpc {} }`
`93`		`- all()*.dependsOn downloadProtoFiles`
	`94`	`+ if (project.gradle.startParameter.taskNames.any { it.contains('downloadProtoFiles') }) {`
	`95`	`+ all()*.dependsOn downloadProtoFiles`
	`96`	`+ }`
`94`	`97`	`}`
`95`	`98`	`}`
`96`	`99`
`@@ -107,7 +110,8 @@ sourceSets {`
`107`	`110`	`}`
`108`	`111`
`109`	`112`	`tasks.withType(Test) {`
`110`		`- executable = new File("${PATH_TO_TEST_JAVA_RUNTIME}", 'bin/java')`
	`113`	`+ def javaName = org.gradle.internal.os.OperatingSystem.current().isWindows() ? 'java.exe' : 'java'`
	`114`	`+ executable = new File("${PATH_TO_TEST_JAVA_RUNTIME}", "bin/${javaName}")`
`111`	`115`	`}`
`112`	`116`
`113`	`117`	`test {`