Angular HttpClient interceptor error‑handling pipeline: ambiguous order

Question

Goal
To understand how Angular’s HttpClient interceptor chain processes errors when multiple interceptors are registered.
Context
Angular invokes interceptors sequentially. When an interceptor returns a non‑null response, the chain is short‑circuited for success paths. For errors, the spec does not state a deterministic order among interceptors that handle the same error, leading to inconsistent error‑response transformations.
Constraints
The current implementation may allow any interceptor that throws or returns a failed observable to capture the error, but the order in which they run is undocumented. This uncertainty can cause subtle bugs in logging, retry logic, or user‑facing error messages.
Unresolved Questions

What guarantees does Angular provide for the execution order of error interceptors when multiple interceptors throw or transform the same HTTP error?
Is there a documented mechanism (e.g., priority, registration order, or explicit configuration) to enforce a specific order of error handling interceptors?
How does the retryWhen operator interact with error interceptors in terms of order and potential duplicate requests?

Tasadduq Burney · Answer

Direct answerAngular executes HttpClient interceptors in the exact order they are registered; there is no documented priority for error‑handling interceptors, and retryWhen causes the whole chain to run again on the resubmitted request.Likely explanation (speculative)Because the spec only describes short‑circuiting on success, it is possible that different interceptors affect each other’s side‑effects, but the order in which they observe the error remains the registration sequence.Confirmed factsThe interceptor chain is built once during module initialization, using the provider order in @NgModule.providers.Interceptors are invoked sequentially; a non‑null response stops the chain, otherwise the error proceeds to the next interceptor.retryWhen resubscribes the original request, causing the entire interceptor chain to execute again, which can duplicate side‑effects if order is uncontrolled.No API or metadata exists to assign priority to an interceptor; registration order is the sole deterministic factor.Steps to verify in your projectInspect the @NgModule.providers list to record the order of all HttpInterceptor entries.Add a console.log at the start and end of each interceptor’s intercept method to capture execution sequence.Trigger an HTTP error (e.g., 404) with retryWhen and observe the log order to confirm the chain runs twice in the recorded sequence.Please share the exact registration order of your HttpInterceptor providers (the list as it appears in the module file). This information is needed to determine whether the current order could cause duplicate side‑effects or missed logging when retryWhen is used.

Angular HttpClient interceptor error‑handling pipeline: ambiguous order

Goal

Context

Constraints

Unresolved Questions

1 answer

Direct answer

Likely explanation (speculative)

Confirmed facts

Steps to verify in your project

Your perspective belongs here.

0 question comments