2.x: .zipWith() with the same shared source crashes the app

The following code crashes the app with a IllegalStateException (using version 2.1.3):

        Observable myObservable = Observable.just(1)
            .flatMap(i -> {
                throw new IllegalStateException();
            }).share();

        myObservable
            .zipWith(myObservable, Pair::new)
            .subscribe(pair -> {
                //ignore
            }, throwable -> {
                //ignore
            });

If I comment the .zipWith(myObservable, Pair::new) line, then everything works. Is that the expected behavior?

In trying to investigate the issue, the PublishObserver object on onError(Throwable e) loops through 2 inner disposables, both containing the same instance of ZipCoordinator.

The first time the publish observer propagates the error to inner.child.onError(e), the zip coordinator sets itself to 0 on innerError(...):

        void innerError(Throwable ex, int index) {
            if (getAndSet(0) > 0) {
                disposeExcept(index);
                actual.onError(ex);
            } else {
                RxJavaPlugins.onError(ex);
            }
        }

But since inner.child.onError(e) is called again, it gets propagated to RxJavaPlugins.onError(ex); and crashes the app. It seems to me since this is a shared source, that the error should be propagated only once, no?

[riclage]

The original reactive concept defines max one error per Observer and we can’t do much about that

I agree but then the error should be propagated down from the .zipWith() like I tried here. As it is in my original example, I have “one” observer but RxJava is trying to propagate the same error twice.

[akarnokd]

The original reactive concept defines max one error per Observer and we can’t do much about that: we either drop it, send it to some handler or the user doesn’t let an exception bubble back into RxJava. That’s what io.reactivex.Notification<T> should allow you: turning an error into an item.