Finalize exception serialization implementation with comprehensive tests

Co-authored-by: YunchuWang <12449837+YunchuWang@users.noreply.github.com>

Author: Copilot

client/src/main/java/com/microsoft/durabletask/FailureDetails.java

@@ -34,6 +34,16 @@ public final class FailureDetails {
         this.isNonRetriable = isNonRetriable;
     }
 
+    /**
+     * Creates a new failure details object from an exception.
+     * This constructor captures comprehensive exception information including:
+     * - Exception type
+     * - Exception message (including multiline messages)
+     * - Complete stack trace with inner/nested exceptions
+     * - Suppressed exceptions
+     * 
+     * @param exception The exception to create failure details from
+     */
     FailureDetails(Exception exception) {
         // Use the most specific exception in the chain for error type
         String errorType = exception.getClass().getName();
@@ -124,7 +134,18 @@ public boolean isCausedBy(Class<? extends Exception> exceptionClass) {
         }
     }
 
+    /**
+     * Generates a comprehensive stack trace string from a throwable, including inner exceptions, suppressed exceptions,
+     * and handling circular references. The format closely resembles Java's standard exception printing format.
+     * 
+     * @param e The throwable to convert to a stack trace string
+     * @return A formatted stack trace string
+     */
     static String getFullStackTrace(Throwable e) {
+        if (e == null) {
+            return "";
+        }
+        
         StringBuilder sb = new StringBuilder();
 
         // Process the exception chain recursively
@@ -166,16 +187,24 @@ private static void appendExceptionDetails(StringBuilder sb, Throwable ex, Stack
         Throwable[] suppressed = ex.getSuppressed();
         if (suppressed != null && suppressed.length > 0) {
             for (Throwable s : suppressed) {
-                sb.append("\tSuppressed: ");
-                appendExceptionDetails(sb, s, currentStackTrace);
+                if (s != ex) { // Avoid circular references
+                    sb.append("\tSuppressed: ");
+                    appendExceptionDetails(sb, s, currentStackTrace);
+                } else {
+                    sb.append("\tSuppressed: [CIRCULAR REFERENCE]").append(System.lineSeparator());
+                }
             }
         }
 
         // Handle cause (inner exception)
         Throwable cause = ex.getCause();
-        if (cause != null && cause != ex) { // Avoid infinite recursion
-            sb.append("Caused by: ");
-            appendExceptionDetails(sb, cause, currentStackTrace);
+        if (cause != null) {
+            if (cause != ex) { // Avoid direct circular references
+                sb.append("Caused by: ");
+                appendExceptionDetails(sb, cause, currentStackTrace);
+            } else {
+                sb.append("Caused by: [CIRCULAR REFERENCE]").append(System.lineSeparator());
+            }
         }
     }
 

client/src/test/java/com/microsoft/durabletask/ComplexExceptionTest.java

@@ -0,0 +1,112 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+package com.microsoft.durabletask;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Tests for handling complex exception serialization scenarios.
+ */
+public class ComplexExceptionTest {
+
+    @Test
+    public void testDeepNestedExceptions() {
+        // Create a chain of 5 nested exceptions
+        Exception level5 = new IllegalArgumentException("Level 5 exception");
+        Exception level4 = new IllegalStateException("Level 4 exception", level5);
+        Exception level3 = new RuntimeException("Level 3 exception", level4);
+        Exception level2 = new Exception("Level 2 exception", level3);
+        Exception level1 = new Exception("Level 1 exception", level2);
+        
+        FailureDetails details = new FailureDetails(level1);
+        
+        assertEquals("java.lang.Exception", details.getErrorType());
+        assertEquals("Level 1 exception", details.getErrorMessage());
+        
+        String stackTrace = details.getStackTrace();
+        assertNotNull(stackTrace);
+        
+        // Verify all exception levels are present in the stack trace
+        assertTrue(stackTrace.contains("Level 1 exception"));
+        assertTrue(stackTrace.contains("Caused by: java.lang.Exception: Level 2 exception"));
+        assertTrue(stackTrace.contains("Caused by: java.lang.RuntimeException: Level 3 exception"));
+        assertTrue(stackTrace.contains("Caused by: java.lang.IllegalStateException: Level 4 exception"));
+        assertTrue(stackTrace.contains("Caused by: java.lang.IllegalArgumentException: Level 5 exception"));
+    }
+    
+    @Test
+    public void testExceptionWithSuppressedExceptions() {
+        Exception mainException = new RuntimeException("Main exception");
+        Exception suppressed1 = new IllegalArgumentException("Suppressed exception 1");
+        Exception suppressed2 = new IllegalStateException("Suppressed exception 2");
+        
+        mainException.addSuppressed(suppressed1);
+        mainException.addSuppressed(suppressed2);
+        
+        FailureDetails details = new FailureDetails(mainException);
+        
+        assertEquals("java.lang.RuntimeException", details.getErrorType());
+        assertEquals("Main exception", details.getErrorMessage());
+        
+        String stackTrace = details.getStackTrace();
+        assertNotNull(stackTrace);
+        
+        // Verify suppressed exceptions are in the stack trace
+        assertTrue(stackTrace.contains("Main exception"));
+        assertTrue(stackTrace.contains("Suppressed: java.lang.IllegalArgumentException: Suppressed exception 1"));
+        assertTrue(stackTrace.contains("Suppressed: java.lang.IllegalStateException: Suppressed exception 2"));
+    }
+    
+    @Test
+    public void testNullMessageException() {
+        NullPointerException exception = new NullPointerException();  // NPE typically has null message
+        
+        FailureDetails details = new FailureDetails(exception);
+        
+        assertEquals("java.lang.NullPointerException", details.getErrorType());
+        assertEquals("", details.getErrorMessage());  // Should convert null to empty string
+        assertNotNull(details.getStackTrace());
+    }
+    
+    @Test
+    public void testCircularExceptionReference() {
+        try {
+            // Create an exception with a circular reference (should be handled gracefully)
+            ExceptionWithCircularReference ex = new ExceptionWithCircularReference("Circular");
+            ex.setCircularCause();
+            
+            FailureDetails details = new FailureDetails(ex);
+            
+            assertEquals(ExceptionWithCircularReference.class.getName(), details.getErrorType());
+            assertEquals("Circular", details.getErrorMessage());
+            assertNotNull(details.getStackTrace());
+            
+            // No infinite loop, test passes if we get here
+        } catch (StackOverflowError e) {
+            fail("StackOverflowError occurred with circular exception reference");
+        }
+    }
+    
+    /**
+     * Exception class that can create a circular reference in the cause chain.
+     */
+    private static class ExceptionWithCircularReference extends Exception {
+        public ExceptionWithCircularReference(String message) {
+            super(message);
+        }
+        
+        public void setCircularCause() {
+            try {
+                // Use reflection to set the cause field directly to this exception
+                // to create a circular reference
+                java.lang.reflect.Field causeField = Throwable.class.getDeclaredField("cause");
+                causeField.setAccessible(true);
+                causeField.set(this, this);
+            } catch (Exception e) {
+                // Ignore any reflection errors, this is just for testing
+            }
+        }
+    }
+}