build filtered stack trace directly from throwable

#918 (comment)

Author: abyrd

src/main/java/com/conveyal/analysis/components/HttpApi.java

@@ -26,7 +26,6 @@
 import static com.conveyal.analysis.AnalysisServerException.Type.RUNTIME;
 import static com.conveyal.analysis.AnalysisServerException.Type.UNAUTHORIZED;
 import static com.conveyal.analysis.AnalysisServerException.Type.UNKNOWN;
-import static com.conveyal.r5.util.ExceptionUtils.filterStackTrace;
 
 /**
  * This Component is a web server that serves up our HTTP API endpoints, contacted by both the UI and the workers.
@@ -180,7 +179,7 @@ private void respondToException(Exception e, Request request, Response response,
         // Include a stack trace except when the error is known to be about unauthenticated or unauthorized access,
         // in which case we don't want to leak information about the server to people scanning it for weaknesses.
         if (type != UNAUTHORIZED && type != FORBIDDEN) {
-            body.put("stackTrace", filterStackTrace(errorEvent.stackTrace));
+            body.put("stackTrace", errorEvent.filteredStackTrace);
         }
         response.status(code);
         response.type("application/json");

src/main/java/com/conveyal/analysis/components/eventbus/ErrorEvent.java

@@ -11,11 +11,11 @@
  */
 public class ErrorEvent extends Event {
 
-    // We may serialize this object, so we convert the Throwable to two strings to control its representation.
+    // All Events are intended to be eligible for serialization into a log or database, so we convert the Throwable to
+    // some Strings to determine its representation in a simple way.
     // For flexibility in event handlers, it is tempting to hold on to the original Throwable instead of derived
     // Strings. Exceptions are famously slow, but it's the initial creation and filling in the stack trace that are
-    // slow. Once the instace exists, repeatedly examining its stack trace should not be prohibitively costly. Still,
-    // we do probably gain some efficiency by converting the stack trace to a String once and reusing that.
+    // slow. Once the instance exists, repeatedly examining its stack trace should not be prohibitively costly.
 
     public final String summary;
 
@@ -25,11 +25,16 @@ public class ErrorEvent extends Event {
      */
     public final String httpPath;
 
+    /** The full stack trace of the exception that occurred. */
     public final String stackTrace;
 
+    /** A minimal stack trace showing the immediate cause within Conveyal code. */
+    public final String filteredStackTrace;
+
     public ErrorEvent (Throwable throwable, String httpPath) {
         this.summary = ExceptionUtils.shortCauseString(throwable);
         this.stackTrace = ExceptionUtils.stackTraceString(throwable);
+        this.filteredStackTrace = ExceptionUtils.filterStackTrace(throwable);
         this.httpPath = httpPath;
     }
 
@@ -56,7 +61,7 @@ public String traceWithContext (boolean verbose) {
         if (verbose) {
             builder.append(stackTrace);
         } else {
-            builder.append(filterStackTrace(stackTrace));
+            builder.append(filteredStackTrace);
         }
         return builder.toString();
     }

src/main/java/com/conveyal/r5/util/ExceptionUtils.java

@@ -55,8 +55,8 @@ public static String shortAndLongString (Throwable throwable) {
      * and all additional frames that come from Conveyal packages. This yields a much shorter stack trace that still
      * shows where the exception was thrown and where the problem originates in our own code.
      */
-    public static String filterStackTrace (String stackTrace) {
-        if (stackTrace == null) return null;
+    public static String filterStackTrace (Throwable throwable) {
+        String stackTrace = stackTraceString(throwable);
         final String unknownFrame = "Unknown stack frame, probably optimized out by JVM.";
         String error = stackTrace.lines().findFirst().get();
         String frame = stackTrace.lines()
@@ -71,8 +71,4 @@ public static String filterStackTrace (String stackTrace) {
         return String.join("\n", error, frame, conveyalFrame);
     }
 
-    public static String filterStackTrace (Throwable throwable) {
-        return filterStackTrace(stackTraceString(throwable));
-    }
-
 }