windowCount dropping values - reactive-programming

Question

I'm trying to group my observable values into groups using windowCount, and for each value of each group send request.Then, concatenate those groups so that next group's requests would not start before current group's request are not completed.The problem is some values get skipped.Here's my code.(I'm not making actual ajax calls here, but Observable.timer should work for an example).
Observable.interval(300)
.take(12)
.windowCount(3)
.concatMap(obs => {
return obs.mergeMap(
v => Observable.timer(Math.random() * 1500).mapTo(v)
);
})
.do(v => console.log(v))
.finally(() => console.log('fin'))
.subscribe();
I tried to replace windowCount by creating the groups manually. And it works perfectly. No values are skipped.
Observable.interval(900)
.take(4)
.map(i => Observable.interval(300).take(3).map(j => j + i * 3))
.concatMap(obs => {
return obs.mergeMap(
v => Observable.timer(Math.random() * 1500).mapTo(v)
);
})
.do(v => console.log(v))
.finally(() => console.log('fin'))
.subscribe();
I was under impression that windowCount should group the emitted values the same way.But, apparently it does something else.
I would be really thankful for any explanation of its behavior. Thanks!

Answer 1

The missing values are a result of using a hot observable (Observable.interval(300)) that continues to output values that you are not storing for use.
Following is a slightly simplified version of your code that also logs the times that numbers are emitted. I replaced Math.random() with 1 so that the output is deterministic. I have also loaded the code in jsbin for you to try out:
https://jsbin.com/burocu/edit?js,console
Observable.interval(300)
.do(x => console.log(x + ") hot observable at: " + (x * 300 + 300)))
.take(12)
.windowCount(3)
.do(observe3 => {observe3.toArray()
.subscribe(x => console.log(x + " do window count at: " + (x[2] * 300 + 300)));})
.concatMap(obs => {
return obs.mergeMap(
v => Observable.timer(1 * 1500).mapTo(v)
)
.do(v => console.log(v + " merge map at: " + (v * 300 + 300 + 1500)));
})
.finally(() => console.log('fin windowCount'))
.subscribe();
It results in the output below. Notice that the hot observables march on while the other operators are still being processed.
This is what is giving you the impression that values are being dropped. You can see that windowCount(3) is doing what you thought but not when you thought.
"0) hot observable at: 300"
"1) hot observable at: 600"
"2) hot observable at: 900"
"0,1,2 do window count at: 900"
"3) hot observable at: 1200"
"4) hot observable at: 1500"
"5) hot observable at: 1800"
"3,4,5 do window count at: 1800"
"0 merge map at: 1800"
"6) hot observable at: 2100"
"1 merge map at: 2100"
"7) hot observable at: 2400"
"2 merge map at: 2400"
"8) hot observable at: 2700"
"6,7,8 do window count at: 2700"
"9) hot observable at: 3000"
"10) hot observable at: 3300"
"11) hot observable at: 3600"
"9,10,11 do window count at: 3600"
" do window count at: NaN"
"8 merge map at: 4200"
"fin windowCount"
Edit: further explanation...
After windowCount(3) there is a call to concatMap. concatMap is a combination of map and concatAll.
concatAll:
Joins every Observable emitted by the source (a higher-order
Observable), in a serial fashion. It subscribes to each inner
Observable only after the previous inner Observable has completed (emphasis added), and
merges all of their values into the returned observable.
So, looking at the output above we see that the first windowCount(3) values [0,1,2] are emitted between 1800 and 2400.
Notice that the second windowCount(3) values [3,4,5] are emitted at 1800. concatAll is not ready to subscribe when [3,4,5] is emitted because the previous inner Observable has not completed yet. So these values are effectively dropped.
Next, notice that the previous inner Observable [0,1,2] completes at 2400. concatAll subscribes at 2400.
The next value to appear is the value 8 at 2700 (300ms after the subscription started at 2400). The value 8 is then output by mergeMap at 4200 because of the interval delay of 300 from the subscription start point of 2400 and then a timer delay of 1500 (i.e 2400 + 300 + 1500 = 4200).
After this point the sequence is completed so no further values are emitted.
Please add a comment if more clarification is needed.