Java Stacktrace cuts off too soon

Sometimes I have a long chain (caused by x, caused by y) in a stack trace that abruptly cuts off before it gets to what I suspect is the good part. The good part being the code I've written and have control over and not the various refined third party code I'm using (server, JSP, etc.) that probably doesn't contain an error. The stack trace will end with something like:

> ....and 70 more.

What can I do in this situation? Is there a way to tell Java to share a fuller stack trace?

I'm working in Eclipse.

There isn't, but, the clue is, the stacktrace is still there.

This ... 70 more. stuff is short for: "... and from here it is the same as the thing I am the cause of".

So, just scroll up one exception and look at the bottom 70 lines of that one. (and maybe that's 20 stacktrace lines and then '... and 50 more', in which case, repeatedly apply this principle).

Simple test:

class Example {
    public static void main(String[] args) {
        foo();
    }

    static void foo() {
        bar();
    }

    static void bar() {
        try {
            throw new RuntimeException("Cause");
        } catch (Exception e) {
            throw new RuntimeException("Actual", e);
        }
    }
}

this prints:

Exception in thread "main" java.lang.RuntimeException: Actual
	at Example.bar(Example.java:14)
	at Example.foo(Example.java:7)
	at Example.main(Example.java:3)
Caused by: java.lang.RuntimeException: Cause
	at Example.bar(Example.java:12)
	... 2 more

You can calculate the proper stacktrace by hand because the example is so simple. Those 2 more? They are:

	at Example.foo(Example.java:7)
	at Example.main(Example.java:3)

-- the same 2 lines that the thing that 'Cause' was the cause of ('Actual') end with.