fix: handle circular exception references (#63)

Author: andclt

aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/UserFault.java

@@ -4,6 +4,8 @@
 
 import java.io.PrintWriter;
 import java.io.StringWriter;
+import java.util.HashSet;
+import java.util.Set;
 
 public final class UserFault extends RuntimeException {
     private static final long serialVersionUID = -479308856905162038L;
@@ -65,6 +67,16 @@ public static String trace(Throwable t) {
      * the same object for convenience.
      */
     public static <T extends Throwable> T filterStackTrace(T t) {
+        return filterStackTrace(t, new HashSet<>(), new HashSet<>());
+    }
+
+    private static <T extends Throwable> T filterStackTrace(T t, Set<Throwable> visited, Set<Throwable> visitedSuppressed) {
+        if (visited.contains(t)) {
+            return t;
+        }
+
+        visited.add(t);
+
         StackTraceElement[] trace = t.getStackTrace();
         for (int i = 0; i < trace.length; i++) {
             if (trace[i].getClassName().startsWith(packagePrefix)) {
@@ -78,12 +90,15 @@ public static <T extends Throwable> T filterStackTrace(T t) {
 
         Throwable cause = t.getCause();
         if (cause != null) {
-            filterStackTrace(cause);
+            filterStackTrace(cause, visited, visitedSuppressed);
         }
 
         Throwable[] suppressedExceptions = t.getSuppressed();
-        for (Throwable suppressed : suppressedExceptions) {
-            filterStackTrace(suppressed);
+        for(Throwable suppressed: suppressedExceptions) {
+            if (!visitedSuppressed.contains(suppressed)) {
+                visitedSuppressed.add(suppressed);
+                filterStackTrace(suppressed, visited, visitedSuppressed);
+            }
         }
 
         return t;

aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/UserFaultTest.java

@@ -84,4 +84,44 @@ public void testSuppressedExceptionsAreIncluded() {
             assertTrue(reportableUserFault.contains("Suppressed: java.lang.RuntimeException: error 2"), "Suppressed error 2 missing in reported UserFault");
         }
     }
+
+    @Test
+    public void testCircularExceptionReference() {
+        RuntimeException e1 = new RuntimeException();
+        RuntimeException e2 = new RuntimeException(e1);
+        e1.initCause(e2);
+
+        try {
+            throw e2;
+        } catch (Exception e) {
+            String stackTrace = UserFault.trace(e);
+            String expectedStackTrace = "java.lang.RuntimeException: java.lang.RuntimeException\n" +
+                            "Caused by: java.lang.RuntimeException\n" +
+                            "Caused by: [CIRCULAR REFERENCE: java.lang.RuntimeException: java.lang.RuntimeException]\n";
+
+            assertEquals(expectedStackTrace, stackTrace);
+        }
+    }
+
+    @Test
+    public void testCircularSuppressedExceptionReference() {
+        RuntimeException e1 = new RuntimeException("Primary Exception");
+        RuntimeException e2 = new RuntimeException(e1);
+        RuntimeException e3 = new RuntimeException("Exception with suppressed");
+
+        e1.addSuppressed(e2);
+        e3.addSuppressed(e2);
+
+        try {
+            throw e3;
+        } catch (Exception e) {
+            String stackTrace = UserFault.trace(e);
+            String expectedStackTrace = "java.lang.RuntimeException: Exception with suppressed\n" +
+                            "\tSuppressed: java.lang.RuntimeException: java.lang.RuntimeException: Primary Exception\n" +
+                            "\tCaused by: java.lang.RuntimeException: Primary Exception\n" +
+                            "\t\tSuppressed: [CIRCULAR REFERENCE: java.lang.RuntimeException: java.lang.RuntimeException: Primary Exception]\n";
+
+            assertEquals(expectedStackTrace, stackTrace);
+        }
+    }
 }