httpx.client.send() doesn't timeout when using a new httpx.Request instance instead of client.build_request

[alexgmin]

I've been having situations in which under gunicorn, code like this:

with httpx.Client(timeout=30) as client:
    response = client.send(request)

Does not timeout after 30 seconds, and reaches the 60 seconds of the gunicorn worker timeout.

I created a this test script, using https://httpstat.us/ which lets you configure how long the request will take to answer

import httpx
import time
import signal

def handler(signum, frame):
    raise ValueError

signal.signal(signal.SIGALRM, handler)

print('client.send new Request')
with httpx.Client(timeout=1) as client:
    start = time.time()
    signal.alarm(10) # Call the handler function and throw a ValueError after 10 seconds
    try:
        response = client.send(httpx.Request(method='GET', url='https://httpstat.us/504?sleep=60000'))
    except httpx.ReadTimeout as e:
        print(f'httpx timeout: {e}')
    except ValueError:
        print('Signal 10s timeout')
    else:
        print(f'Success - Elapsed: {response.elapsed_time.total_seconds()}')

    print(f'Duration {time.time() - start}')

print('\nclient.send build.request timeout')
with httpx.Client(timeout=1) as client:
    start = time.time()
    signal.alarm(10) # Call the handler function and throw a ValueError after 10 seconds
    try:
        response = client.send(client.build_request(method='GET', url='https://httpstat.us/504?sleep=60000'))
    except httpx.ReadTimeout as e:
        print(f'httpx timeout: {e}')
    except ValueError:
        print('Signal 10s timeout')
    else:
        print(f'Success - Elapsed: {response.elapsed_time.total_seconds()}')

    print(f'Duration {time.time() - start}')

signal.alarm(0)
print('\nclient.get timeout')
with httpx.Client(timeout=1) as client:
    start = time.time()
    signal.alarm(10) # Call the handler function and throw a ValueError after 10 seconds
    try:
        response = client.get(url='https://httpstat.us/504?sleep=60000')
    except httpx.ReadTimeout as e:
        print(f'httpx timeout: {e}')
    except ValueError:
        print('Signal 10s timeout')
    else:
        print(f'Success - Elapsed: {response.elapsed_time.total_seconds()}')

    print(f'Duration {time.time() - start}')

signal.alarm(0)

And my results are:

❯ python main.py
client.send new Request
Signal 10s timeout
Duration 10.000704050064087

client.send build.request timeout
httpx timeout: The read operation timed out
Duration 1.6372973918914795

client.get timeout
httpx timeout: The read operation timed out
Duration 1.442279577255249

If you send a httpx.Request() not built with client.build_request() it doesn't seem to be a timeout at all, not even the default 5 second one.

This is on 0.27.0 but it also happens in at least 0.25.2

[tomchristie]

Yes... the timeout happens to be implemented as a Request extension, and if you instantiate the Request without using build_request it's not being populated.

We either want to document this as "expected behaviour" or alter it.

It could be resolved in...

httpx/httpx/_client.py

Line 881 in 326b943

def send(

httpx/httpx/_client.py

Line 1628 in 326b943

async def send(

Ensuring that the timeout is always populated.

httpx/httpx/_client.py

Lines 350 to 356 in 326b943

	if "timeout" not in extensions:
	timeout = (
	self.timeout
	if isinstance(timeout, UseClientDefault)
	else Timeout(timeout)
	)
	extensions = dict(**extensions, timeout=timeout.as_dict())

[alexgmin]

I don't know the codebase well enough for this, I think some relevant questions would be:

• Does this only affect Timeout due to being implemented in a different way (with a specific parameter as a shortcut)?
• Could it affect future extensions?

And finally, this is more for my own curiosity, why was it implemented as a extension?

So the fix would be to add this to both send methods?

if "timeout" not in request.extensions:
    timeout = (
        self.timeout
        if isinstance(timeout, UseClientDefault)
        else Timeout(timeout)
    )
    request.extensions = dict(**request.extensions, timeout=timeout.as_dict())

I could try doing a PR, but I'm not sure if I'm the right person to do it, or knowledgeable enough.

[tomchristie]

And finally, this is more for my own curiosity, why was it implemented as a extension?

Yeah... the Transport API has a nice simple send(request) -> response interface. Timeouts are implemented using request.extension because we want to be able to support per-request timeouts (rather than having timeouts only.)

I'm not sure if I'm the right person to do it, or knowledgeable enough.

Good news... I checked the books and you are the right person to do it. (If you do choose to give it a try I can help you work through the PR)

So the fix would be to add this to both send methods?

Seems about right.

[alexgmin]

Good news... I checked the books and you are the right person to do it. (If you do choose to give it a try I can help you work through the PR)

Well, since I was enlisted, here's the PR: #3116