Exception thrown from onError() is swallowed when using groupBy/flatMap

[gdela]

This issue is related to #969, where it has been said that following code should throw exception:

Observable.error(new Exception())
  .subscribe(new Observer<Object>() {
    public void onCompleted() {
      // noop
    }
    public void onError(Throwable e) {
      throw new IllegalStateException("This should crash the app");
    }
    public void onNext(Object o) {
      // noop
    }
  });

And it does throw exception, but when you add groupBy/flatMap like that:

Observable.error(new Exception())
  .groupBy(o -> o)
  .flatMap(g -> g)
  .subscribe(new Observer<Object>() {
    public void onCompleted() {
      // noop
    }
    public void onError(Throwable e) {
      throw new IllegalStateException("This should crash the app");
    }
    public void onNext(Object o) {
      // noop
    }
  });

Then the exception is silently swallowed. I tried to debug it a little bit, and seems that it could be because OnErrorFailedException is wrapped with CompositeException, so Exceptions.throwIfFatal() doesn't recognize it as fatal.

[akarnokd]

You shouldn't throw from onError() because that exception, usually, has nowhere to go. The RxJava operators are a bit inconsistent about this; some catch it, some let it through and others wrap it around.

[gdela]

I see, so I shouldn't use exception thrown from onError() to control flow, because it only seldom bubbles up to the subscribe() caller. I think that this wiki doc is a little bit misleading about that, because it says something like: "if the onError() call itself fails, the Observable [...] will throw a RuntimeException, an OnErrorFailedException, or an OnErrorNotImplementedException".

[benjchristensen]

If we are swallowing an error that's a bug.

[benjchristensen]

It would be helpful it someone can create a failing unit test for this issue that demonstrates where the exception is being swallowed.

[konmik]

@Test(expected = Exception.class)
public void throws_exception_from_onNext_onError() throws Exception {
    Observable
        .just(1)
        .doOnNext(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                throw new RuntimeException();
            }
        })
        .subscribe(
            new Action1<Integer>() {
                @Override
                public void call(Integer integer) {

                }
            }, new Action1<Throwable>() {
                @Override
                public void call(Throwable throwable) {
                    throw new RuntimeException();
                }
            });
}

@Test(expected = Exception.class)
public void throws_exception_from_switchMap_onError() throws Exception {
    Observable
        .just(1)
        .switchMap(new Func1<Integer, Observable<Integer>>() {
            @Override
            public Observable<Integer> call(Integer integer) {
                return Observable.error(new RuntimeException());
            }
        })
        .subscribe(
            new Action1<Integer>() {
                @Override
                public void call(Integer integer) {

                }
            }, new Action1<Throwable>() {
                @Override
                public void call(Throwable throwable) {
                    throw new RuntimeException();
                }
            });
}

@Test(expected = Exception.class)
public void throws_exception_from_flatMap_onError() throws Exception {
    Observable
        .just(1)
        .flatMap(new Func1<Integer, Observable<Integer>>() {
            @Override
            public Observable<Integer> call(Integer integer) {
                return Observable.error(new RuntimeException());
            }
        })
        .subscribe(
            new Action1<Integer>() {
                @Override
                public void call(Integer integer) {

                }
            }, new Action1<Throwable>() {
                @Override
                public void call(Throwable throwable) {
                    throw new RuntimeException();
                }
            });
}

@Test(expected = Exception.class)
public void throws_exception_from_groupBy_onError() throws Exception {
    Observable
        .just(1)
        .groupBy(new Func1<Integer, Integer>() {
            @Override
            public Integer call(Integer integer) {
                throw new RuntimeException();
            }
        })
        .subscribe(
            new Action1<GroupedObservable<Integer, Integer>>() {
                @Override
                public void call(GroupedObservable<Integer, Integer> integerIntegerGroupedObservable) {

                }
            }, new Action1<Throwable>() {
                @Override
                public void call(Throwable throwable) {
                    throw new RuntimeException();
                }
            });
}

[konmik]

Please let me know if someone is going to fix this.

Sorry, I don't feel that I can fix this myself - concurrency is not my strongest skill.

[akarnokd]

This has nothing to do with concurrency but with fault tolerance. The problem is that if the call to onError throws, there is no clear path that could propagate the exception out of the operator chain. For example, if an onNext calls an onError which throws, the caller of onNext can't know if onNext itself failed or who else and may happily call a chain of onErrors which end up throwing again. Therefore, either we always propagate exceptions up the stack until the thread-root is reached or sink the exception of onError into some plugin handler.

[konmik]

I think that a clean way to do this could be creation of RethrowAlwaysException which decorates the original exception and which should be rethrown on every check. It should be unwrapped at the top loop and rethrown again unwrapped out of reach of rx chain.

[akarnokd]

That works until the first async boundary where it will probably be swallowed by the ExecutorService.