these errors aren't retried by the resolv library, but they are by
getaddrinfo, so we should stick with that default.

connections set timeout to connect_timeout on transition to :idle already

this will preempt @timeout calculation and not raise when it is nil, which fixes some edge cases

an additional layer of bookkeeping is added to prevent readiness-based timeouts to also benefit from it without losing its advantage

in case a wrong value is left behind

this allows passing HTTP headers which are **only** supposed to be sent
in the proxy tunnel CONNECT request, and won't interfere with the main
request.

At the same time this fixes an issue where headers passed to the
`:headers` option were being passed to the CONNECT request.

when set to true, can for a CONNECT proxy to be established in cases
where it wouldn't automatically make it so (such as when the request is
a "http://" request).

it is documented that `:addresses` can also be a hash of "hostname to
ips", but in practice this was not supported, so made it so.

in case another plugin overrides it, as we're planning to do

during ping management.

fix tracing init time

See merge request !470

remove unreachable statement

See merge request !469

fix: make the dns resolver retry queries for NotImpl and Refused err

See merge request !468

Kiril Mitov authored May 31, 2026 and Tiago committed Sep 14, 2026

so `:callbacks` `on_response_completed` sees an empty body

In the `httpx` webmock adapter (`lib/httpx/adapters/webmock.rb`),
the response body is appended **after** `request.emit_response(response)` fires. U
nder the `:callbacks` plugin, `on_response_completed` callbacks fire
from `request.on(:response)`, which means user code that reads `response.body`
inside a `response_completed` callback sees an empty body under webmock —
even though the same code works correctly against a live server.

In real `httpx` (e.g. `lib/httpx/connection/http1.rb#dispatch`,
and `lib/httpx/connection.rb` near `response.finish! ; request.emit(:response, ...)`),
body chunks are streamed into the response **before** `:response` is emitted.

The webmock adapter has the order reversed.

this may block a request from successfully completing, despite the server having replied
already with a response, and timing out. observed in a multi-request scenario

http2: do not just wait for writable readiness when also waiting for streams to complete

See merge request !471

the previous system was not taking into account ping time, or massive
reconnection time, as the init time was recorded as the time the request
was being sent.

This has been fixed by simplifying the calculation for request as
starting when the first bytes are buffered to be sent; then, if the
request is involved in a cold connection which needs to connect, then
the several handshakes (TCP/TLS/HTTP-2) are taken into account and
calculated accordingly.

tracing: fix span initial time calculation

See merge request !472

this is specific to tls, but it's added generically.

Fixes https://github.com/HoneyryderChuck/httpx/issues/151

new simplecov does not support them, so we keep the old API around for them

requests which were never sent to the parser will not have an accurate beginning of span without this, despite having waited on the connection to connect too

this improves the performance of #connection_options_match? by not requiring ivars to be sorted

it also useses accessors to get options values instead of reading the ivars indirectly

detect potential sources of state corruption

if getting the response takes too long, the existing token may have expired by the time the request is retried, and in such a situation, a new token needs to be generated before the retry

before enqueuing new requests in the pending queue

at that point, it can't be an error response

when socket errors happen, override #handle_connect_error to discard the connect request

when theres's a request timeout while waiting for the tunnel proxy request, bubble up as a ConnectTimeoutError

also, use the #send method to not reinvent connection bookkeeping

instead of maintaining state, it'll return a full edited copy when moving on to the next item in the proxy list

this sorts out an issue where failing proxies would be retried later on for other hostnames from the same session

makes digest auth options frozen-able

the expectation is that options objects are always frozne, and this fell through the cracks

also, fixed ssh proxy rotation on error

also fixed the remainder of unsupported cases due to the tests using the wrong assertion helper

connection state wasn't accounting and caching multiple authorities for a given host, so requests to a second alt service would fail in weird ways

added a test that walks the full tree of clauses this time

the params were only being passed to the first request

been useful for me locally

ci small fixes

See merge request !473

also includes a check to, on unblock, not synchronize when the lock has
been acquired. This may happen because the mutex may also switch to the
next fiber.

the previous fix exposed non-supported options to Options#merge. This fixes it by dealing with it in the session and duping reusable hashes

only the string version is used

always assume it's new

using string splitting and manipulation instead of plain regexs

forego needless computation; also, avoid build extra strings while checking expects header

in the session, this will avoid going back to the selector needless and having the penalty of a select call when the socket is available for writing

using an http-2 based test server.

http: do not parse http version to array of integers then back to string

See merge request !474

will make some operations a tad simpler. also, make sure drain is removed when stream closes with error

If a request is sent to a connection which isn't open, then the time to
connect, usually covered by `:connect_timeout`, will also be account for
in `:request_timeout` and `:total_request_timeout`. This is a
potentially significant change of behaviour, which I think rectifies
something that always catches peeps off-guard.

This was done by using a new connection callback, and set the timeout
based on it for an incoming request if the connection is `connecting?`.

A previously unexistent check is performed so that only one type of
timeout is set for a given request, while on the same connection.

make request_timeout and total_request_timeout account for connect phase

See merge request !475

an internal representation of the timeouts container moves to a struct
(rather than a hash). This reduces the chance of typos, presents better
memory layout, and allows late binding of defaults.

This is also an important complement of the new functionality of
deadline timeouts covering the connect phase, as before, the connect
timeout would always be set, and could conflict with the request
timeout, whereas now, it can be avoided if one of the deadline timeouts
is set (request_ or total_request_timeout).

this allows a request to be sent over two connections at the same time
in a race; it'll then, on first successful response, close the other one
+ respective connection.

hedging plugin

Closes #369

See merge request !465