Stacktraces and subscribeOn/observeOn

RxJava in not nice when it comes to stacktraces.

The worst thing is observeOn that schedules execution on different threads. Every time we use observeOn we get our stacktrace from the process root, all the call history gets erased.

The idea is to make schedulers save the caller’s stack, wrap action calls and attach the stacktrace to each exception that has been thrown by scheduled actions.

Pros: traceable exceptions Cons: Performance cost Leaks because of recursion

I think that we can have Schedulers.io(boolean trace) alternative that will save the stacktrace, so we could call it Schedules.io(DEBUG) to turn stacktracing off on production for performance critical parts.

How do you guys find this idea?

[whatisaphone]

Since this is the top Google result for rxjava observeon stack trace, I’d like to point everybody (and myself next time I search for this) to the excellent Traceur library which solved this issue for me. It’s a library for RxJava2 which replicates RxJava1’s RxJavaHooks.enableAssemblyTracking().

[konmik]

Here is the solution I came up with.

Just add .lift(traceOnError()) to a chain to get localized stacktraces.

public class OperatorTraceOnError<T> implements Observable.Operator<T, T> {

    private final StackTraceElement[] trace = new Throwable().getStackTrace();

    public static <T> OperatorTraceOnError<T> traceOnError() {
        return new OperatorTraceOnError<>();
    }

    @Override
    public Subscriber<? super T> call(Subscriber<? super T> child) {
        Subscriber<T> parent = new Subscriber<T>() {
            @Override
            public void onCompleted() {
                child.onCompleted();
            }

            @Override
            public void onError(Throwable throwable) {
                child.onError(new TracedException(throwable, trace));
            }

            @Override
            public void onNext(T t) {
                child.onNext(t);
            }
        };

        child.add(parent);
        return parent;
    }

    private static class TracedException extends RuntimeException {
        public TracedException(Throwable throwable, StackTraceElement[] trace) {
            super(throwable);
            setStackTrace(trace);
        }
    }
}

P.S. It will not help with the case of the bloking operator error because the exception happens after .lift(traceOnError()).