`request.signal` is not aborted for aborted `http.ClientRequest`

[piranmontford-ww]

How do I see that a request was timed out or aborted using @mswjs/interceptors ?

Why? I'm using @mswjs/interceptors to log calls made by a number of SDKs we're using, and we can't intercept the HTTP requests they make through their SDK's API. Therefore we're using @mswjs/interceptors to log calls, timings, response headers, errors etc. However, I'd also like to log timeouts. Some of the SDKs retry on timeouts, and we'd like to know when they do that and see both requests.

Details:

• Node v22.14.0 with yarn 3.8.7
• @mswjs/interceptors 0.41.3

In this JavaScript Jest test below, neither on('response') or on('unhandledException') are called when the request times out:

const { describe, expect, it, beforeEach, afterEach } = require('@jest/globals')
const { BatchInterceptor } = require('@mswjs/interceptors')
const nodeInterceptors = require('@mswjs/interceptors/presets/node')
const https = require('node:https')

describe('@mswjs/interceptors timeout tests', () => {
    let interceptor
    beforeEach(() => {
        interceptor = new BatchInterceptor({
            name: 'a test',
            interceptors: nodeInterceptors,
        })

        interceptor.on('request', ({ requestId }) => {
            console.log('request', requestId) // <-- This does get called
        })

        interceptor.on('response', ({ requestId }) => {
            console.log('response', requestId) // <-- This doesn't get called
        })

        interceptor.on('unhandledException', ({ error }) => {
            console.log('unhandledException', error) // <-- This doesn't get called
        })

        interceptor.apply()
    })
    afterEach(() => {
        interceptor.dispose()
    })

    it('fetch', async () => {
        try {
            const response = await fetch('https://httpbin.org/delay/10', {
                signal: AbortSignal.timeout(1_000),
            })
            expect(response).toEqual('this should not happen')
        } catch (e) {
            expect(e.name).toEqual('TimeoutError')
        }

        // leave some time for background processes
        await new Promise((resolve) => {
            setTimeout(resolve, 2_000)
        })
    })
    it('node:https', async () => {
        try {
            const promiseWithResolver = Promise.withResolvers()
            const request = https.get(
                'https://httpbin.org/delay/10',
                {
                    timeout: 1_000,
                    signal: AbortSignal.timeout(1_000),
                },
                (result) => {
                    promiseWithResolver.resolve(result)
                },
            )
            request.on('error', promiseWithResolver.reject)

            const response = await promiseWithResolver.promise
            expect(response).toEqual('this should not happen')
        } catch (e) {
            expect(e.name).toEqual('AbortError')
        }

        // leave some time for background processes
        await new Promise((resolve) => {
            setTimeout(resolve, 2_000)
        })
    })
})

[kettanaito]

Hi, @piranmontford-ww. That's a good question!

First of all, I took this chance to improve our existing tests around AbortSignal.timeout in #769. Both of your scenarios are passing, behaving as expected.

It's worth pointing out that despite the name, AbortSignal.timeout does not cause the request to timeout. Instead, it aborts the request, listing the timeout as the reason. In other words, it's a narrower variant of the regular AbortController.signal. Just clarifying that you mustn't expect the timeout event to fire on ClientRequest when using AbortSignal.timeout.

But both fetch and ClientRequest do produce the correct aborted/errored states when provided with AbortSignal.timeout. This differentiation with the regular timeout option (applicable only to ClientRequest) is important because if your SDKs time out, that is likely the route the request will take, not an error.

How to intercept timed-out requests

Based on your scenario, you want to do this:

1. Intercept a request.
2. Let is passthrough (timeout implies something else times out the request other than our request listener).
3. Then listen to the timeout occurring on the already intercepted request.

This is tricky because Interceptors uses the Fetch API Request as the common ground for every intercepted request. And the Fetch API does not have the concept of a timed out request, only the aborted one. Most of SDKs in Node.js will rely on node:http so you should instead listen to the timeout event on the ClientRequest to catch those timeout scenarios.

For that, you need to reference the ClientRequest instance behind the intercepted request. You can do that via the getRawRequest function:

import { ClientRequest } from 'node:http'
import { getRawRequest } from '@mswjsw/interceptors'

interceptor.on('request', ({ request }) => {
  const rawRequest = getRawRequest(request)

  if (rawRequest instanceof http.ClientRequest) {
    rawRequest.on('timeout', () => {
      console.log('Intercepted request timed out!', request.method, request.url)
    })
  }
})

You can do similar handling for XMLHttpRequest instances by listening to their timeout event. Note that the Fetch API does not offer any means to listen to timeouts specifically as (1) those aren't a thing; (2) AbortSignal.timeout will be treated as regular request promise rejection errors.

[piranmontford-ww]

Hi @kettanaito, thanks for getting back to me.

I tried your code, and it did NOT work for fetch or for node:https. Updated test case is below.

I could get the time out by rawRequest.on('error', (err) => { if (err.name === 'AbortError')... for node:https. (Solution 1) — i.e., using the error event and not the timeout event as you had done.

I also tried getting the signal from the request, and watching for an abort on that. This worked in fetch (Solution 2), but not for node:https. The request.signal for node:https is a different signal from the calling code (hence why my code adds a test attribute to the signal), and doesn't fire when the original signal fires.

But Solution 1 works for node:https and Solution 2 works for fetch, so I have both routes covered (although it's a little messy).

By the way, I'm running CJS in this test. Our production is TypeScript targeted to CJS, because our commercial monitoring tool (Dynatrace) only supports CJS.

I've not tried XMLHttpRequest, as I'm running server only.

const { describe, expect, it, beforeEach, afterEach } = require('@jest/globals')
const { BatchInterceptor, getRawRequest } = require('@mswjs/interceptors')
const nodeInterceptors = require('@mswjs/interceptors/presets/node')
const https = require('node:https')
const http = require('node:http')

describe('@mswjs/interceptors timeout tests', () => {
    let interceptor
    beforeEach(() => {
        interceptor = new BatchInterceptor({
            name: 'a test',
            interceptors: nodeInterceptors,
        })

        interceptor.on('request', ({ requestId, request, controller }) => {
            console.log('request', requestId) // <-- This does get called
            if (request.signal) {
                request.signal.addEventListener('abort', (...args) => {
                    console.log('aborted', args) // <-- This DOES get called for fetch, but NOT for node:https (Solution 2)
                })
            }

            const rawRequest = getRawRequest(request)
            if (rawRequest instanceof http.ClientRequest) {
                console.log('is an instanceof http.ClientRequest') // only node:https gets in here
                rawRequest.on('timeout', () => {
                    // this does NOT get called by node:https or fetch
                    console.log('Intercepted request timed out!', request.method, request.url)
                })
                rawRequest.on('error', (err) => {
                    // this DOES get called with an AbortError for node:https, but NOT for fetch (Solution 1)
                    console.log('Intercepted request error!', err)
                })
                rawRequest.on('abort', () => {
                    // this does NOT get called by node:https or fetch
                    console.log('Intercepted request abort!', request.method, request.url)
                })
            }
        })

        interceptor.on('response', ({ requestId }) => {
            console.log('response', requestId) // <-- This doesn't get called
        })

        interceptor.on('unhandledException', ({ error }) => {
            console.log('unhandledException', error) // <-- This doesn't get called
        })

        interceptor.apply()
    })
    afterEach(() => {
        interceptor.dispose()
    })

    it('fetch', async () => {
        try {
            const response = await fetch('https://httpbin.org/delay/10', {
                signal: AbortSignal.timeout(1_000),
            })
            expect(response).toEqual('this should not happen')
        } catch (e) {
            expect(e.name).toEqual('TimeoutError')
        }

        // leave some time for background processes
        await new Promise((resolve) => {
            setTimeout(resolve, 2_000)
        })
    })
    it('node:https', async () => {
        try {
            const promiseWithResolver = Promise.withResolvers()

            const signal = AbortSignal.timeout(1_000)
            Object.assign(signal, { note: 'The Original' })
            const request = https.get(
                'https://httpbin.org/delay/10',
                {
                    // timeout: 1_000,
                    signal: signal,
                },
                (result) => {
                    promiseWithResolver.resolve(result)
                },
            )
            request.on('error', (err) => {
                console.log('error event', err)
                promiseWithResolver.reject(err)
            })

            const response = await promiseWithResolver.promise
            expect(response).toEqual('this should not happen')
        } catch (e) {
            expect(e.name).toEqual('AbortError')
        }

        // leave some time for background processes
        await new Promise((resolve) => {
            setTimeout(resolve, 2_000)
        })
    })
})

[kettanaito]

I could get the time out by rawRequest.on('error', (err) => { if (err.name === 'AbortError')... for node:https.

This strongly suggests you want to listen to errored requests, not timed out ones. AbortSignal.timeout does not time out a request, it aborts it.

The request.signal for node:https is a different signal from the calling code (hence why my code adds a test attribute to the signal), and doesn't fire when the original signal fires.

I honestly don't remember if we ever supported request.signal and forwarded the request aborts that way. This might be a missing functionality at this point! I'll reopen this issue as a candidate to consider the request.signal behavior for http.ClientRequest.