tweak some existing others

before, canceling a timer connected to an interval which would become empty would delete it from the main intervals store; this deletion now moves away from the request critical path, and pinging for intervals will drop elapsed-or-empty before returning the shortest one

beyond that, the intervals store won't be constantly recreated if there's no need for it (i.e. nothing has elapsed), which reduce the gc pressure

searching for existing interval on #after now uses bsearch; since the list is ordered, this should make finding one more performant

using Hash#new(capacity: ) to better predict size; reduce the number of allocated arrays by passing the result of  to the store when possible, and only calling #downcased(str) once; #array_value will also not try to clean up errors in the passed data (it'll either fail loudly, or be fixed downstream)

allows plugins to override

abstracts some logic around whether a request has request body bytes to buffer

this plugin is an HTTP/2 only plugin which enables bidirectional streaming

the client can continue writing request streams as response streams arrive midway

Closes https://github.com/HoneyryderChuck/httpx/discussions/71

only for ruby 3.1 or higher. adapted from a similar feature from the connection_pool gem

ruby 3.4 features

Closes #336

See merge request !372

subplugins are modules of plugins which register as post-plugins of other plugins

a specific plugin may want to have a side-effect on the functionality of another plugin, so they can use this to register it when the other plugin is loaded

added as a plugin for explicit opt-in, as it's still an experimental feature (RFC in draft)

QUERY plugin

Closes #339

See merge request !374

adding  option, which automatically closes sessions on fork

See merge request !377

:stream_bidi plugin

See merge request !365

this was being used as an internal cache for finished responses; this can be however superseded by Request#response, which fulfills the same role alongside the #finished? call; this allows us to drop one variable-size hash which would grow at least as large as the number of requests per call, and was inadvertedly shared across threads when using the same session (even at no danger of colliding, but could cause perhaps problems in jruby?)

also allows to remove one less callback

the previous option was there to allow reconnecting on non-idempotent (i.e. POST) requests, but had the unfortunate side-effect of allowing retries for failures (i.e. timeouts) which had nothing to do with a failed connection error; this mitigates it by enabling retries for ping-aware requests, i.e. if there is an error during PING, always retry

in situations where the connection is already open/active, the requests would be buffered before setting the timeouts, which would skip transition callbacks associated with writes, such as write timeouts and request timeouts

persistent plugin: when errors happen during connection ping phase, make sure that only connection lost errors are going to be retriable

http-2 1.1.0 uses the string input as the ultimate buffer (when input not frozen), which will mutate the argument. in order to keep it around for further comparison, the string is dupped

persistent plugin: drop , allow retries for ping requests, regardless of idempotency property

See merge request !381

response age wasn't being taken into account, and cache invalidation request was always being sent; fresh response will stay in the store until expired; when it expires, cache invalidation will be tried (if possible); if invalidated, the new response is put in the store; Bif validated, the body of the cached response is copied, and the cached response stays in the store

response cache: store cached response in request, so that copying and cache invalidating work a bit OOTB

the cache key will be also determined by the supported vary headers values, when present; this means easier lookups, and one level hash fetch, where the same url-verb request may have multiple entries depending on those headers

checking response vary header will therefore be something done at cache response lookup; writes may override when they shouldn't though, as a full match on supported vary headers will be performed, and one can't know in advance the combo of vary headers, which is why insterested parties will have to be judicious with the new  option

it stores the cached responses in the filesystem

#get, #set, #clear, that's all you need. this can now be some bespoke custom class implementing these primitives

it's called with a fresh response already

cleaner to select from one of the two available options

response_cache plugin: return cached response from store unless stale

Closes #341

See merge request !382

this new option declares how many max inflight-or-idle open connections a session may hold. connections get recycled in case a new one is needed and the pool has closed connections to discard. the same pool timeout error applies as for max_connections_per_origin

pool option: max_connections

Closes #328

See merge request !371

also, testing usage of symbol response cache store options.

including header tags, and other missing span tags

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

adding missing datadog span decoration

See merge request !384

it's only used internally

such as '.with' or '.wrap', which create a new session object on the fly

this was not happening for errors happening during name resolution, particularly when HEv2 was used, as the second resolver was kept open and didn't stop the selector loop

Closes #348

:callbacks plugin fix: copy callbacks to new session when using the session builder methods

Closes #347 and #348

See merge request !386

that isn't a connection-related type of failure, and confuses users when it gets retried, as connection was fine, request was just slow

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

persistent plugin: by default, do not retry requests which failed due to a request timeout

See merge request !385

this is achieved by inserting some synchronization primitives when buffering the content, and waking up the main select loop, via an IO pipe

stream_bidi: allows payload to be buffered to requests from other threads

See merge request !383

In Ruby 3.5, most of the `cgi` gem will be removed and moved to a bundled gem.

Luckily, the escape/unescape methods have been left around. So, only the require path needs to be adjusted to avoid a warning.
`cgi/escape` was available since Ruby 2.3

I also moved the require to the file that actually uses it.

https://bugs.ruby-lang.org/issues/21258

In file (any serialized) store need to response.finish! on get

Closes #350

See merge request !392

Only require from `cgi` what is required

See merge request !391

this is achieved by inserting some synchronization primitives when buffering the content, and waking up the main select loop, via an IO pipe

stream_bidi: allows payload to be buffered to requests from other threads

See merge request !389

also, establishing the selectable interface for resolvers

sig improvements

See merge request !390

when true, text passed to log messages considered sensitive (wrapped in a +#log_redact+ call) will be logged as "[REDACTED}"

also show transition states in connected

pool: do not decrement conn counter when returning existing connection, nor increment it when acquiring

this variable is supposed to monitor new connections being created or dropped, existing connection management shouldn't affect it

the whole "found connection not open" branch was removed, as currently,
a mergeable connection must not be closed; this means that only
open/inactive connections will be picked up from selector/pool, as
they're the only coalescable connections (have addresses/ssl cert
state). this may be extended to support closed connections though, as
remaining ssl/addresses are enough to make it coalescable at that point,
and then it's just a matter of idling it, so it'll be simpler than it is
today.

coalesced connection gets closed via Connection#terminate at the end
now, in order to propagate whether it was a cloned connection.

added log messages in order to monitor coalescing handshake from logs.

leaving bytes around messes up the termination handshake and may raise other unwanted errors

this should be dependent on the exception only, as connections may have closed before ping was released

this addresses https://github.com/HoneyryderChuck/httpx/issues/87\#issuecomment-2866564479

added :debug_redact option

See merge request !387

session may be interrupted earlier than the connection has finished
the handshake; in such a case, simulate early termination.

Closes https://github.com/HoneyryderChuck/httpx/issues/91