Add ApplicationFailure.Builder

Author: Quinn-With-Two-Ns

temporal-sdk/src/main/java/io/temporal/failure/ApplicationErrorCategory.java

@@ -29,5 +29,4 @@ public enum ApplicationErrorCategory {
   UNSPECIFIED,
   /** Expected application error with little/no severity. */
   BENIGN,
-  ;
 }

temporal-sdk/src/main/java/io/temporal/failure/ApplicationFailure.java

@@ -51,7 +51,7 @@
  *   <li>nonRetryable is set to false
  *   <li>details are set to null
  *   <li>stack trace is copied from the original exception
- *   <li>category is set to ApplicationErrorCategory.APPLICATION_ERROR_CATEGORY_UNSPECIFIED
+ *   <li>category is set to {@link ApplicationErrorCategory#UNSPECIFIED}
  * </ul>
  */
 public final class ApplicationFailure extends TemporalFailure {
@@ -61,6 +61,16 @@ public final class ApplicationFailure extends TemporalFailure {
   private Duration nextRetryDelay;
   private final ApplicationErrorCategory category;
 
+  /** Creates a new builder for {@link ApplicationFailure}. */
+  public static ApplicationFailure.Builder newBuilder() {
+    return new ApplicationFailure.Builder();
+  }
+
+  /** Creates a new builder for {@link ApplicationFailure} initialized with the provided failure. */
+  public static ApplicationFailure.Builder newBuilder(ApplicationFailure options) {
+    return new ApplicationFailure.Builder(options);
+  }
+
   /**
    * New ApplicationFailure with {@link #isNonRetryable()} flag set to false.
    *
@@ -178,45 +188,7 @@ public static ApplicationFailure newNonRetryableFailureWithCause(
         ApplicationErrorCategory.UNSPECIFIED);
   }
 
-  /**
-   * New ApplicationFailure with a specified category and {@link #isNonRetryable()} flag set to
-   * false.
-   *
-   * <p>Note that this exception still may not be retried by the service if its type is included in
-   * the doNotRetry property of the correspondent retry policy.
-   *
-   * @param message optional error message
-   * @param type error type
-   * @param category the category of the application failure.
-   * @param cause failure cause. Each element of the cause chain will be converted to
-   *     ApplicationFailure for network transmission across network if it doesn't extend {@link
-   *     TemporalFailure}
-   * @param details optional details about the failure. They are serialized using the same approach
-   *     as arguments and results.
-   */
-  public static ApplicationFailure newFailureWithCategory(
-      String message,
-      String type,
-      ApplicationErrorCategory category,
-      @Nullable Throwable cause,
-      Object... details) {
-    return new ApplicationFailure(
-        message, type, false, new EncodedValues(details), cause, null, category);
-  }
-
-  static ApplicationFailure newFromValues(
-      String message,
-      String type,
-      boolean nonRetryable,
-      Values details,
-      Throwable cause,
-      Duration nextRetryDelay,
-      ApplicationErrorCategory category) {
-    return new ApplicationFailure(
-        message, type, nonRetryable, details, cause, nextRetryDelay, category);
-  }
-
-  ApplicationFailure(
+  private ApplicationFailure(
       String message,
       String type,
       boolean nonRetryable,
@@ -274,4 +246,123 @@ private static String getMessage(String message, String type, boolean nonRetryab
         + ", nonRetryable="
         + nonRetryable;
   }
+
+  public static final class Builder {
+    private String message;
+    private String type;
+    private Values details;
+    private boolean nonRetryable;
+    private Throwable cause;
+    private Duration nextRetryDelay;
+    private ApplicationErrorCategory category;
+
+    private Builder() {}
+
+    private Builder(ApplicationFailure options) {
+      if (options == null) {
+        return;
+      }
+      this.message = options.getOriginalMessage();
+      this.type = options.type;
+      this.details = options.details;
+      this.nonRetryable = options.nonRetryable;
+      this.nextRetryDelay = options.nextRetryDelay;
+      this.category = options.category;
+    }
+
+    /**
+     * Sets the error type of this failure. This is used by {@link
+     * io.temporal.common.RetryOptions.Builder#setDoNotRetry(String...)} to determine if the
+     * exception is non retryable.
+     */
+    public Builder setType(String type) {
+      this.type = type;
+      return this;
+    }
+
+
+    /**
+     * Set the optional error message.
+     *
+     * <p>Default is "".
+     */
+    public Builder setMessage(String message) {
+      this.message = message;
+      return this;
+    }
+
+    /**
+     * Set the optional details of the failure.
+     *
+     * <p>Details are serialized using the same approach as arguments and results.
+     */
+    public Builder setDetails(Object... details) {
+      this.details = new EncodedValues(details);
+      return this;
+    }
+
+    /**
+     * Set the optional details of the failure.
+     *
+     * <p>Details are serialized using the same approach as arguments and results.
+     */
+    public Builder setDetails(Values details) {
+      this.details = details;
+      return this;
+    }
+
+    /**
+     * Set the non retryable flag on the failure.
+     *
+     * <p>It means that this exception is not going to be retried even if it is not included into
+     * retry policy doNotRetry list.
+     *
+     * <p>Default is false.
+     */
+    public Builder setNonRetryable(boolean nonRetryable) {
+      this.nonRetryable = nonRetryable;
+      return this;
+    }
+
+    /**
+     * Set the optional cause of the failure. Each element of the cause chain will be converted to
+     * {@link ApplicationFailure} for network transmission across network if it doesn't extend
+     * {@link TemporalFailure}.
+     */
+    public Builder setCause(Throwable cause) {
+      this.cause = cause;
+      return this;
+    }
+
+    /**
+     * Set the optional delay before the next retry attempt. Overrides the normal retry delay.
+     *
+     * <p>Default is null.
+     */
+    public Builder setNextRetryDelay(Duration nextRetryDelay) {
+      this.nextRetryDelay = nextRetryDelay;
+      return this;
+    }
+
+    /**
+     * Set the optional category of the failure.
+     *
+     * <p>Default is {@link ApplicationErrorCategory#UNSPECIFIED}.
+     */
+    public Builder setCategory(ApplicationErrorCategory category) {
+      this.category = category;
+      return this;
+    }
+
+    public ApplicationFailure build() {
+      return new ApplicationFailure(
+          message,
+          type,
+          nonRetryable,
+          details == null ? new EncodedValues(null) : details,
+          cause,
+          nextRetryDelay,
+          category);
+    }
+  }
 }

temporal-sdk/src/main/java/io/temporal/failure/DefaultFailureConverter.java

@@ -99,16 +99,18 @@ private RuntimeException failureToExceptionImpl(Failure failure, DataConverter d
           ApplicationFailureInfo info = failure.getApplicationFailureInfo();
           Optional<Payloads> details =
               info.hasDetails() ? Optional.of(info.getDetails()) : Optional.empty();
-          return ApplicationFailure.newFromValues(
-              failure.getMessage(),
-              info.getType(),
-              info.getNonRetryable(),
-              new EncodedValues(details, dataConverter),
-              cause,
-              info.hasNextRetryDelay()
-                  ? ProtobufTimeUtils.toJavaDuration(info.getNextRetryDelay())
-                  : null,
-              FailureUtils.categoryFromProto(info.getCategory()));
+          return ApplicationFailure.newBuilder()
+              .setMessage(failure.getMessage())
+              .setType(info.getType())
+              .setNonRetryable(info.getNonRetryable())
+              .setDetails(new EncodedValues(details, dataConverter))
+              .setCause(cause)
+              .setNextRetryDelay(
+                  info.hasNextRetryDelay()
+                      ? ProtobufTimeUtils.toJavaDuration(info.getNextRetryDelay())
+                      : null)
+              .setCategory(FailureUtils.categoryFromProto(info.getCategory()))
+              .build();
         }
       case TIMEOUT_FAILURE_INFO:
         {
@@ -148,14 +150,12 @@ private RuntimeException failureToExceptionImpl(Failure failure, DataConverter d
               info.hasLastHeartbeatDetails()
                   ? Optional.of(info.getLastHeartbeatDetails())
                   : Optional.empty();
-          return ApplicationFailure.newFromValues(
-              failure.getMessage(),
-              "ResetWorkflow",
-              false,
-              new EncodedValues(details, dataConverter),
-              cause,
-              null,
-              ApplicationErrorCategory.UNSPECIFIED);
+          return ApplicationFailure.newBuilder()
+              .setMessage(failure.getMessage())
+              .setType("ResetWorkflow")
+              .setDetails(new EncodedValues(details, dataConverter))
+              .setCause(cause)
+              .build();
         }
       case ACTIVITY_FAILURE_INFO:
         {
@@ -211,14 +211,12 @@ private RuntimeException failureToExceptionImpl(Failure failure, DataConverter d
       case FAILUREINFO_NOT_SET:
       default:
         // All unknown types are considered to be retryable ApplicationError.
-        return ApplicationFailure.newFromValues(
-            failure.getMessage(),
-            "",
-            false,
-            new EncodedValues(Optional.empty(), dataConverter),
-            cause,
-            null,
-            ApplicationErrorCategory.UNSPECIFIED);
+        return ApplicationFailure.newBuilder()
+            .setMessage(failure.getMessage())
+            .setType("")
+            .setDetails(new EncodedValues(Optional.empty(), dataConverter))
+            .setCause(cause)
+            .build();
     }
   }
 

temporal-sdk/src/test/java/io/temporal/internal/worker/ActivityFailedMetricsTests.java

@@ -111,8 +111,11 @@ public void execute(boolean isBenign) {
       if (!isBenign) {
         throw ApplicationFailure.newFailure("Non-benign activity failure", "NonBenignType");
       } else {
-        throw ApplicationFailure.newFailureWithCategory(
-            "Benign activity failure", "BenignType", ApplicationErrorCategory.BENIGN, null);
+        throw ApplicationFailure.newBuilder()
+            .setMessage("Benign activity failure")
+            .setType("BenignType")
+            .setCategory(ApplicationErrorCategory.BENIGN)
+            .build();
       }
     }
   }

temporal-sdk/src/test/java/io/temporal/internal/worker/WorkflowFailedMetricsTests.java

@@ -130,8 +130,11 @@ public void execute(boolean isBenign) {
       if (!isBenign) {
         throw ApplicationFailure.newFailure("Non-benign failure", "NonBenignType");
       } else {
-        throw ApplicationFailure.newFailureWithCategory(
-            "Benign failure", "BenignType", ApplicationErrorCategory.BENIGN, null);
+        throw ApplicationFailure.newBuilder()
+            .setMessage("Benign failure")
+            .setType("BenignType")
+            .setCategory(ApplicationErrorCategory.BENIGN)
+            .build();
       }
     }
   }