switchMap inner observable completion timing during concurrent emissions

Answer to the Core Question

In RxJS 6+ the switchMap operator performs the following steps when a new value arrives from the source observable:

1. The operator synchronously calls unsubscribe() on the currently active inner subscription.
2. It then immediately subscribes to the new inner observable returned by the projection function.

The unsubscribe() call is a normal teardown signal. It does not trigger the inner observable’s complete callback. The inner observable’s completion logic is only executed when the inner observable itself finishes (e.g., via complete() or when its source completes). Therefore, the previous inner observable never receives a complete notification from switchMap; it only receives an unsubscribe and any teardown logic defined in its finally/finalize block runs immediately.

Confirming the Timing with TestScheduler

To observe the exact order, use RxJS’s TestScheduler and marble diagrams. The following example logs subscription and unsubscription times for each inner observable:

const { TestScheduler } = require('rxjs/testing');
const { switchMap, map } = require('rxjs/operators');
const { of } = require('rxjs');

const testScheduler = new TestScheduler((actual, expected) => {
  expect(actual).toEqual(expected);
});

testScheduler.run(({ cold, expectObservable, expectSubscriptions }) => {
  const source =   cold('  -a---b----|');
  const innerA =   cold('  1--2--|');
  const innerB =   cold('  3-4---|');
  const proj = val => val === 'a' ? innerA : innerB;

  const result = source.pipe(switchMap(proj));

  expectObservable(result).toBe('  -1-2---3-4---|');
  expectSubscriptions(source.subscriptions).toBe('  ^-----------!');
});

Notice that the unsubscription of innerA occurs at the exact moment b arrives, before innerB starts emitting. No complete notification from innerA appears in the output.

Practical Steps for Your High‑Frequency Emission Scenario

• Ensure each inner observable cleans up its resources in its teardown logic (e.g., finalize or the return function of new Observable).
• Use switchMap only when you truly need to cancel the previous inner stream; otherwise consider exhaustMap or concatMap to avoid excessive unsubscriptions.
• If you need to know when an inner observable has finished normally, subscribe to its complete event inside the projection and emit a distinct marker.
• Measure subscription/unsubscription overhead with performance.now() or a custom logger if you suspect a bottleneck.

Missing Diagnostic Detail

To give you a more tailored recommendation, could you confirm whether your inner observables perform any asynchronous cleanup that might be affected by a sudden unsubscribe? If they rely on external resources (e.g., WebSocket close, HTTP abort), the teardown timing could matter.