JVMCBC-1658 Better filtering of suppressed exception stack traces

Motivation
----------
Remove uninteresting Netty stack frames from suppressed
exceptions, just as we do for the causal chain.

Modifications
-------------
Move the stack trace filtering code into
CbThrowables as a generic `filterStackTrace`
method.

Recursively filter suppressed exceptions.

Protect against circular causes and suppression.

Change-Id: I597ace7c3546100bb0e6b81de463cee21a1dc34b
Reviewed-on: https://review.couchbase.org/c/couchbase-jvm-clients/+/229292
Tested-by: Build Bot <[email protected]>
Reviewed-by: Graham Pople <[email protected]>

Author: dnault

core-io/src/main/java/com/couchbase/client/core/endpoint/BaseEndpoint.java

@@ -78,9 +78,6 @@
 import java.net.InetSocketAddress;
 import java.net.SocketAddress;
 import java.time.Duration;
-import java.util.Arrays;
-import java.util.LinkedList;
-import java.util.List;
 import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.TimeUnit;
@@ -92,6 +89,7 @@
 import java.util.function.Supplier;
 
 import static com.couchbase.client.core.logging.RedactableArgument.redactMeta;
+import static com.couchbase.client.core.util.CbThrowables.filterStackTrace;
 
 /**
  * This {@link BaseEndpoint} implements all common logic for endpoints that wrap the IO layer.
@@ -491,18 +489,10 @@ public synchronized Throwable fillInStackTrace() {
    * removing all the generic netty stack we do not need.
    *
    * @param input the input exception.
-   * @return the trimmed exception.
+   * @return the same exception instance, now with filtered stack trace.
    */
-  @SuppressWarnings("ThrowableResultOfMethodCallIgnored")
-  private Throwable trimNettyFromStackTrace(final Throwable input) {
-    if (input == null) {
-      return null;
-    }
-
-    final List<StackTraceElement> elements = new LinkedList<>(Arrays.asList(input.getStackTrace()));
-    elements.removeIf(next -> next.getClassName().startsWith("com.couchbase.client.core.deps.io.netty"));
-    input.setStackTrace(elements.toArray(new StackTraceElement[]{}));
-    trimNettyFromStackTrace(input.getCause());
+  private static Throwable trimNettyFromStackTrace(final Throwable input) {
+    filterStackTrace(input, frame -> !frame.getClassName().startsWith("com.couchbase.client.core.deps.io.netty"));
     return input;
   }
 

core-io/src/main/java/com/couchbase/client/core/util/CbThrowables.java

@@ -18,11 +18,17 @@
 
 import com.couchbase.client.core.annotation.Stability;
 import com.couchbase.client.core.error.CouchbaseException;
+import org.jspecify.annotations.Nullable;
 
 import java.io.PrintWriter;
 import java.io.StringWriter;
+import java.util.Arrays;
+import java.util.IdentityHashMap;
 import java.util.Optional;
+import java.util.Set;
+import java.util.function.Predicate;
 
+import static java.util.Collections.newSetFromMap;
 import static java.util.Objects.requireNonNull;
 
 @Stability.Internal
@@ -92,4 +98,41 @@ public static String getStackTraceAsString(Throwable t) {
     t.printStackTrace(new PrintWriter(w));
     return w.toString();
   }
+
+  /**
+   * Modifies the stack trace of the given throwable by removing elements
+   * that do not match the filter predicate.
+   * <p>
+   * Applies the modification recursively to the throwable's causal chain
+   * and suppressed throwables.
+   */
+  public static void filterStackTrace(
+    Throwable t,
+    Predicate<StackTraceElement> filter
+  ) {
+    requireNonNull(t);
+    filterStackTraceRecursive(t, filter, newSetFromMap(new IdentityHashMap<>()));
+  }
+
+  private static void filterStackTraceRecursive(
+    @Nullable Throwable t,
+    Predicate<StackTraceElement> filter,
+    Set<Throwable> seen
+  ) {
+    if (t == null || !seen.add(t)) {
+      return;
+    }
+
+    t.setStackTrace(
+      Arrays.stream(t.getStackTrace())
+        .filter(filter)
+        .toArray(StackTraceElement[]::new)
+    );
+
+    filterStackTraceRecursive(t.getCause(), filter, seen);
+
+    for (Throwable suppressed : t.getSuppressed()) {
+      filterStackTraceRecursive(suppressed, filter, seen);
+    }
+  }
 }

core-io/src/test/java/com/couchbase/client/core/util/CbThrowablesTest.java

@@ -20,7 +20,10 @@
 
 import java.util.Optional;
 
+import static com.couchbase.client.core.util.CbThrowables.filterStackTrace;
+import static com.couchbase.client.core.util.CbThrowables.getStackTraceAsString;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
@@ -77,4 +80,38 @@ void throwIfUncheckedWorks() {
     assertThrows(IndexOutOfBoundsException.class, () ->
         CbThrowables.throwIfUnchecked(new IndexOutOfBoundsException()));
   }
+
+  @Test
+  void canFilterStackTraceWithCircularCause() {
+    Throwable a = new RuntimeException();
+    Throwable b = new RuntimeException(a);
+    a.initCause(b);
+    filterStackTrace(a, frame -> true);
+  }
+
+  @Test
+  void canFilterStackTraceWithCircularSuppression() {
+    Throwable a = new RuntimeException();
+    Throwable b = new RuntimeException();
+    a.addSuppressed(b);
+    b.addSuppressed(a);
+    filterStackTrace(a, frame -> true);
+  }
+
+  @Test
+  void canFilterStackTrace() {
+    String className = getClass().getName();
+
+    Throwable t = new RuntimeException(new RuntimeException(new RuntimeException()));
+    t.addSuppressed(new RuntimeException(new RuntimeException()));
+
+    assertTrue(getStackTraceAsString(t).contains(className)); // sanity check
+
+    filterStackTrace(t, frame -> !frame.getClassName().equals(className));
+
+    String s = getStackTraceAsString(t);
+    assertFalse(
+      s.contains(className),
+      "Stack trace should not contain " + className + ", but got: " + s);
+  }
 }