Example #1
0
 private void printScriptFrames(StringBuilder sb, Realm realm, Throwable e, int level) {
   final String indent = Strings.repeat('\t', level);
   final int maxDepth = options.stacktraceDepth;
   int depth = 0;
   StackTraceElement[] stackTrace = StackTraces.scriptStackTrace(e);
   for (; depth < Math.min(stackTrace.length, maxDepth); ++depth) {
     StackTraceElement element = stackTrace[depth];
     String methodName = element.getMethodName();
     String fileName = element.getFileName();
     int lineNumber = element.getLineNumber();
     sb.append(indent)
         .append("at ")
         .append(methodName)
         .append(" (")
         .append(fileName)
         .append(':')
         .append(lineNumber)
         .append(")\n");
   }
   if (depth < stackTrace.length) {
     int skipped = stackTrace.length - depth;
     sb.append("\t.. ").append(skipped).append(" frames omitted\n");
   }
   if (e.getSuppressed().length > 0 && level == 1) {
     Throwable suppressed = e.getSuppressed()[0];
     String message;
     if (suppressed instanceof ScriptException) {
       message = ((ScriptException) suppressed).getMessage(realm.defaultContext());
     } else {
       message = Objects.toString(suppressed.getMessage(), suppressed.getClass().getSimpleName());
     }
     sb.append(indent).append(formatMessage("suppressed_exception", message)).append('\n');
     printScriptFrames(sb, realm, suppressed, level + 1);
   }
 }
  public void testNotSerializableExceptionWrapper() throws IOException {
    NotSerializableExceptionWrapper ex =
        serialize(new NotSerializableExceptionWrapper(new NullPointerException()));
    assertEquals("{\"type\":\"null_pointer_exception\",\"reason\":null}", toXContent(ex));
    ex = serialize(new NotSerializableExceptionWrapper(new IllegalArgumentException("nono!")));
    assertEquals("{\"type\":\"illegal_argument_exception\",\"reason\":\"nono!\"}", toXContent(ex));

    Throwable[] unknowns =
        new Throwable[] {
          new JsonParseException("foobar", new JsonLocation(new Object(), 1, 2, 3, 4)),
          new GroovyCastException("boom boom boom"),
          new IOException("booom")
        };
    for (Throwable t : unknowns) {
      if (randomBoolean()) {
        t.addSuppressed(new IOException("suppressed"));
        t.addSuppressed(new NullPointerException());
      }
      Throwable deserialized = serialize(t);
      assertTrue(deserialized instanceof NotSerializableExceptionWrapper);
      assertArrayEquals(t.getStackTrace(), deserialized.getStackTrace());
      assertEquals(t.getSuppressed().length, deserialized.getSuppressed().length);
      if (t.getSuppressed().length > 0) {
        assertTrue(deserialized.getSuppressed()[0] instanceof NotSerializableExceptionWrapper);
        assertArrayEquals(
            t.getSuppressed()[0].getStackTrace(), deserialized.getSuppressed()[0].getStackTrace());
        assertTrue(deserialized.getSuppressed()[1] instanceof NullPointerException);
      }
    }
  }
Example #3
0
 TruncatedThrowable(Throwable throwable, int depth) {
   super();
   this.throwable = throwable;
   setStackTrace(truncate(throwable, depth));
   if (throwable.getCause() != null) {
     initCause(new TruncatedThrowable(throwable.getCause(), depth));
   }
   for (Throwable suppressed : throwable.getSuppressed()) {
     addSuppressed(new TruncatedThrowable(suppressed, depth));
   }
 }
 private static List<ThrowableInfo> getFlatThrowableInfoList(
     Throwable t, boolean isCause, boolean isSurpressed, int level) {
   List<ThrowableInfo> list = new ArrayList<ThrowableInfo>();
   list.add(new ThrowableInfo(isCause, isSurpressed, level, t));
   for (Throwable supp : t.getSuppressed()) {
     // suppressed are presented one level below
     list.addAll(getFlatThrowableInfoList(supp, false, true, level + 1));
   }
   if (t.getCause() != null) {
     // cause is presented at the same level
     list.addAll(getFlatThrowableInfoList(t.getCause(), true, false, level));
   }
   return list;
 }
    private void addStackTraceDetail(final Throwable throwable, final Map<Throwable, Integer> seen)
        throws Exception {
      if (throwable == null) {
        return;
      }
      if (seen.containsKey(throwable)) {
        writeStart(getKey(Key.EXCEPTION_CIRCULAR_REFERENCE));
        writeExceptionMessage(throwable, seen.get(throwable));
        writeEnd(); // end circular reference
      } else {
        final int id = stackTraceId++;
        seen.put(throwable, id);
        writeStart(getKey(Key.EXCEPTION));
        writeExceptionMessage(throwable, id);

        final StackTraceElement[] elements = throwable.getStackTrace();
        for (StackTraceElement e : elements) {
          writeStart(getKey(Key.EXCEPTION_FRAME));
          add(getKey(Key.EXCEPTION_FRAME_CLASS), e.getClassName());
          add(getKey(Key.EXCEPTION_FRAME_METHOD), e.getMethodName());
          final int line = e.getLineNumber();
          if (line >= 0) {
            add(getKey(Key.EXCEPTION_FRAME_LINE), e.getLineNumber());
          }
          writeEnd(); // end exception frame
        }

        writeEnd(); // end exception

        // Render the suppressed messages
        final Throwable[] suppressed = throwable.getSuppressed();
        if (suppressed != null && suppressed.length > 0) {
          writeStart(getKey(Key.EXCEPTION_SUPPRESSED));
          for (Throwable s : suppressed) {
            addStackTraceDetail(s, seen);
          }
          writeEnd();
        }

        // Render the cause
        final Throwable cause = throwable.getCause();
        if (cause != null) {
          writeStart(getKey(Key.EXCEPTION_CAUSED_BY));
          addStackTraceDetail(cause, seen);
          writeEnd();
        }
      }
    }