Is there a nicer (java8?) way to collect the "cause stack" of an exception?

Question

We have a BaseException extends Exception in our project, and basically all our other exceptions derive from this class. I want to change some methods that deal with the "cause stack" at runtime.

As starting point, I wrote the following method:

class BaseException extends Exception {
...

  /**
   * Helper: creates a list containing the complete "cause stack" of this exception.
   * Please note: the exception on which this method is called is part of result!
   *
   * @return a {@link List} of all "causes" of this exception 
   */
  List<Throwable> getAllCauses() {
    Throwable cause = this;
    List<Throwable> causes = new ArrayList<>();
    while (cause != null) {
      causes.add(cause);
      cause = cause.getCause();
    }          
    return causes;
  }

This gets the job done, although it is not perfect (name isn't exactly great, and single layer of abstraction is violated, too) .

But still: is there a "more elegant" way of collecting this result? Especially given the fact that it would helpful to directly return a Stream<Throwable>.

( I am mainly wondering if there is a java8 lambda/idiom that could help here )

Bonus request: suggestions for a better name for that method are welcome and might result in a very grateful GhostCat ... — GhostCat, Aug 23 '17 at 18:38
Instead of injecting a new base class, I suggest creating a utility class with static methods such as `Exceptions.getAllCauses(Throwable)`. — John Kugelman, Aug 23 '17 at 18:54
@JohnKugelman I do need to modify my base class anyway ... but I like your idea of putting this very method in a special class! — GhostCat, Aug 23 '17 at 19:01
@GhostCat Using Java9, you might also be able to use `Stream.iterate` combined with `takeWhile`. — Alexis C., Aug 23 '17 at 19:27
@AlexisC. My project updated to Java8 6 months ago. I will be glad if I get a chance to use Java9 in my project before 2020. — GhostCat, Aug 23 '17 at 19:29
@Jean-BaptisteYunès Feel free to add your answer in case you have significantly different content to offer ;-) — GhostCat, Aug 24 '17 at 06:46
No just a comment, this has been already answered and flagged. I'm pretty sure you know how to do it. Anyway, better name hint: `getCauses()`? — Jean-Baptiste Yunès, Aug 24 '17 at 06:51
@Jean-BaptisteYunès That was my first thought as well. But I found that "too close" to the existing `Throwable getCause()` that you inherit from Throwable. — GhostCat, Aug 24 '17 at 06:52
Stream#iterate is what I was looking for. Finally! @AlexisC. - please, please add this as an answer. — , Aug 25 '17 at 14:42

score 11 · Accepted Answer · edited Aug 23 '17 at 18:52

11

This article should be of help. In particular,

Stream<Throwable> causes(Throwable t){
    if (t == null) return Stream.empty();
    return Stream.concat(Stream.of(t), causes(t.getCause()));
}

edited Aug 23 '17 at 18:52

John Kugelman

349,597
67
533
578

answered Aug 23 '17 at 18:41

2

Just a tiny caveat: This is susceptible to cycles in the cause chain (but so is your current implementation). I don't think this will be an issue, but e.g. Apache's [`ExceptionUtils.getThrowables`](https://commons.apache.org/proper/commons-lang/javadocs/api-3.6/org/apache/commons/lang3/exception/ExceptionUtils.html#getThrowables-java.lang.Throwable-) explicitly mentions it. Otherwise this is pret-ty nifty. – Marvin Aug 23 '17 at 19:36
1

It's also very garbage-intensive and may not optimize as well as plain loop. – Aug 23 '17 at 19:46
first upvote. there is an implementation I implemented [here](https://stackoverflow.com/questions/44700006/is-there-java-stream-equivalent-to-while-with-variable-assignment/44700862#44700862) by spliterator. I wish it helped. – holi-java Aug 24 '17 at 04:41
1

@Arkadiy I don't care about cycles - our existing code doesn't either. I agree about the garbage - but well: we are talking about exceptions here. Exceptions shouldnt be thrown thousands of time per second. And I guess creating the stack trace and stacking things up will outweigh the cost of such calls anyway. – GhostCat Aug 24 '17 at 06:50

score 4 · Answer 2 · answered Aug 24 '17 at 07:33

Here is my implementation that implemented by Spliterator as below:

public static <T> Stream<T> 
       iterateUntil(T seed, UnaryOperator<T> generator, Predicate<T> proceed){
  return stream(new AbstractSpliterator<T>(Long.MAX_VALUE, Spliterator.ORDERED){
    private T value = seed;
    public boolean tryAdvance(Consumer<? super T> action){
      if(!proceed.test(value)) return false;
      action.accept(value);
      value = generator.apply(value);
      return true;
    }
  }, false);
}

Then you can implements your getCauses as below and it drop the recursive calls:

List<Throwable> getAllCauses() {
    return iterateUntil(this, Throwable::getCause, Objects::nonNull)
              .collect(toList());
}

@GhostCat thanks, sir. in java8 the almost way you can operate a Spliterator as possible to achieve your way. there many answer I wrote base on it. e.g: `generateUntil` , `chunk` and .etc. in this way you can traversing `getCause` until the terminal operation is called. — holi-java, Aug 24 '17 at 07:39

score 1 · Answer 3 · answered Aug 24 '17 at 06:58

Using some enumeration seems more appropriate to me, then something like

class BaseException extends Exception {
...

  Enumeration<Throwable> getCauses() {
    return new Enumeration<Throwable>() {
       private Throwable current = BaseException.this;
       public boolean hasMoreElements() {
         return current != null;
       }
       public Throwable nextElement() {
         Throwable c = current;
         current = current.getCause();
         return c;
       }
    }
  }

With Java 8 you can also create a new interface with a default method doing the trick and then use that interface in any of your exception class (slightly better than subclassing Exception?).

I think I prefer the current solution (as I need a stream, and the enumeration would need to be converted to a stream then). — GhostCat, Aug 24 '17 at 07:09

Is there a nicer (java8?) way to collect the "cause stack" of an exception?

3 Answers3