cybrid_api_id_ruby 0.129.1137 → 0.129.1138

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/1_6_3.md

@@ -0,0 +1,47 @@
+# 1.6.3
+
+## Features
+
+* allow redacting only headers, or only the body, when using `debug_redact: :headers` or `debug_redact: :body` respectively.
+
+## Improvements
+
+* `system` resolver now works in a non-blocking manner, initiating the dns query in a separate thread and waiting on the pipe after that (it was blocking the main thread during resolution before).
+* reduce allocation to a single shared option object when headers are passed as a session-level option, like `HTTPX.with(headers: headers).get(...)`
+* favour using `String#replace` in buffer operations (instead of "clean-then-append").
+* using `Array#unshift` instead of `Array#concat` in order to ensure that request ordering is respected in the face of an in-between error which requires reconnect-and-resend.
+* replaced more internal callback indirection with plain method calls.
+
+
+## Bugfixes
+
+* https: prevent modification of the ssl context object when performing a reconnection.
+* compression: do not return early if the decompression buffer yields an empty string (more frequent under jruby 10).
+* response cache: take query params into account when caching or retrieving cached responses.
+* response cache: do not decompress cached responses on body consumption (the response bodies are cached in plaintext).
+* native resolver: pick next timeout associated with the hostname being resolved (and not the hostnames in the queue).
+* pool: assume that, even when signalled that a connection is available, context may be switched to a session which also checks the same connection out, before it's able to pick it up; in such a case, start from the beginning, until the pool timeout expires.
+* session: forego bookkeeping when a connection is coalesced (instead, allow it to be dropped).
+* digest_auth: make sure that an array is sent back if the probe response fails.
+* alt-svc: when alt-svc handshake happens with more in-flight requests, defer termination to when these requests are made.
+* http2: fix use of unexisting var `ex` when processing the connection closed callback.
+* connection: fix potential session dereferencing, which allowed connections to be used across sessions, therefore bypassing needed synchronization and leading to the `undefined method 'after' for nil:NilClass` error.
+* selector: close only selected connections (instead of all selectable connections) when an error occurs during IO readiness wait calls.
+* resolvers: correctly propagate abrupt termination errors to the connection objects waiting for the answer.
+* resolvers: when errors happenm force-close unresolved connections (and ensure they're both pinned to the corresponding session before the error happens, and are unpinned after error is propagated).
+* resolvers: ensure resolvers transition to "closed" state, on all cases, when any error happens.
+* resolvers: ensure that the next hostname is resolved when a timeout happens on the current one.
+* native resolver: fixed duplication of the hostname to resolve in the list of candidates.
+* https resolver: use a `system` resolver to resolve the DoH server hostname (instead of rerouting it to itself).
+* https resolver: skip loop error reporting when error happens outside of it.
+* https resolver: close connection on resolve errors, which prevents it from being around in the pool after termination; also deactivate it after successful use.
+* multi resolver: do not check resolvers back into the pool if it's a multi resolver and the peer is still resolving (and do the check outside of the critical area).
+* sentry adapter: removed usage of deprecated method which has been removed in sentry-ruby 6.0.0.
+* selector: when coalescing connections, pin the current session before merging connections, to prevent it from registering in a selector being used in a different thread, and inadvertedly allowing it to be used across threads.
+* session: fix: always pin connection before early-or-lazy resolution (fixes connection pool accounting under connection coalescing).
+
+## Chores
+
+* logging emits a timestamp as well (to monitor timeouts).
+* `:stream_bidi` plugin: extends HTTP2 module by using plugin extensions.
+* connection: remove session/selector references when closing a connection (prevents leaking them beyond the usage scope).

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/1_7_0.md

@@ -0,0 +1,149 @@
+# 1.7.0
+
+## Features
+
+### All AUTH plugin improvements!!
+
+#### `:auth`
+
+The `:auth` plugin can now be used with a dynamic callable object (methods, procs...) to generate the token.
+
+```ruby
+# static token, pre 1.7.0
+HTTPX.plugin(:auth).authorization("API-TOKEN")
+# dynamically generate token!
+HTTPX.plugin(:auth).authorization { generate_new_ephemeral_token }
+```
+
+The `.authorization` method is now syntactic sugar for a new option, `:auth_header_value`, which can be used directly, alongside a `:auth_header_type`:
+
+```ruby
+HTTPX.plugin(:auth).authorization("API-TOKEN")
+HTTPX.plugin(:auth).authorization { generate_new_ephemeral_token }
+HTTPX.plugin(:auth).authorization("Bearer API-TOKEN")
+# same as
+HTTPX.plugin(:auth, auth_header_value: "API-TOKEN")
+HTTPX.plugin(:auth, auth_header_value: -> { generate_new_ephemeral_token })
+HTTPX.plugin(:auth, auth_header_type: "Bearer", auth_header_value: "API-TOKEN")
+```
+
+A new option `:generate_auth_value_on_retry` (which can be passed a callable receiving a response object) is now available; when used alongside the `:retries` plugin, it'll use the callable passed to the `.authorization` method to generate a new token before retrying the request:
+
+```ruby
+authed = HTTPX.plugin(:retries).plugin(:auth, generate_auth_value_on_retry: ->(res) {
+  res.status == 401
+}).authorization { generate_new_ephemeral_token }
+authed.get("https://example.com")
+```
+
+Read more about it in the [auth plugin wiki](https://honeyryderchuck.gitlab.io/httpx/wiki/Auth).
+
+#### `:oauth`
+
+The `:oauth` plugin implementation was revamped to make use of the `:auth` plugin new functionality, in order to make managing an oauth session more seamless.
+
+Take the following example:
+
+```ruby
+session = HTTPX.plugin(:oauth).with_oauth_options(
+  issuer: server.origin,
+  client_id: "CLIENT_ID",
+  client_secret: "SECRET",
+)
+session.get("https://example.com") #=> will load server metadata, request an access token, and perform the request with the access token.
+# 2 hours later...
+session.get("https://example.com")
+# it'll reuse the same acces token, and if the request fails with 401, it'll request a new
+# access token using the refresh token grant (when supported by the token issuer), and
+# reperform the original request with the new access token.
+```
+
+A new option, `:oauth_options`, is now available. The same parameters previously supported by the `:oauth_session` options are supported.
+
+The following components are therefore deprecated and scheduled for removal in a future major version:
+
+* `:oauth_session` option
+* `.oauth_auth` session method
+* `.with_access_token` session method
+
+#### `:bearer_auth`, `:digest_auth`; `:ntlm_auth`
+
+The `:auth` plugin is now the foundation of each of these plugins, which haven't suffered major API changes.
+
+Read more about it in the [auth plugin wiki](https://honeyryderchuck.gitlab.io/httpx/wiki/OAuth).
+
+### `:retries` plugin: `:retry_after` backoff algorithms
+
+The `:retries` plugins supports two new possible values for the `:retry_after` option: `:exponential_backoff` and `:polynomial_backoff`. They'll implement the respective calculation per each retry of a given request.
+
+```ruby
+# will wait 1, 2, 4, 8, 16 seconds... depending of how many retries it can wait for
+session = HTTPX.plugin(:retries, retry_after: :exponential_backoff)
+```
+
+Read more about it in the [retries plugin wiki](https://honeyryderchuck.gitlab.io/httpx/wiki/Retries).
+
+### Ractor compatibility
+
+`httpx` can be used within a ractor:
+
+```ruby
+# ruby 4.0 syntax
+response = Ractor.new(uri) do |uri|
+  HTTPX.get(uri)
+end.value
+```
+
+Bear in mind that, if you're connection via HTTPS, you'll need make sure you're using version 4.0 or higher of the `openssl` gem.
+
+The test suite isn't exhaustive for ractors yet, but most plugins should also be ractor-compatible. If they don't work, that's a bug, and you're recommended to report it.
+
+## Improvements
+
+* When encoding the `:json` param to send it as `application/json` payload, (example: `HTTPX.post("https://example.com", json: { foo: "bar })`), and the method uses the `json` standard library, it'll use `JSON.generate` (instead of `JSON.dump`) to encode the JSON payload. The reason is that, unlike `JSON.dump`, it doesn't rely on access to a global mutable hash, and is therefore ractor-safe.
+* `:stream` plugin: the stream response class (the object that is returned in request calls is a stream response) can be extended now. You can add a `StreamResponseMethods` method to your plugin. Read more about it in the documentation.
+* The resolver name cache (used by the native and https resolvers) was remade into a LRU cache, and will therefore not keep on growing when `httpx` is used to connect to a huge number of hostnames in a process.
+* the native and https DNS resolvers will ignore answers with SERVFAIL code while there are retries left (some resolvers use such error code for rate limiting).
+* `:timeout` option values are now validated, and an error is raised when passing an unrecognized timeout option (which is a good layer of protection for typos).
+* pool: try passing the scheduler to a thread waiting on a connection, to avoid the current case where a connection may be checked-in-then-immediately-out-after when doing multiple requests in a loop, never giving a chance to others and potentially making the pool time out.
+* headers deep-freeze and dup.
+
+## Bugfixes
+
+* recover and close connection when an `IOError` is raised while waiting for IO readiness (could cause busy loops during HTTP/2 termination handshake).
+* `:stream_bidi` plugin: improve thread-safety of buffer operations when the session is used from multiple threads.
+* `:stream_bidi` plugin: added missing methods to signal in order to comply with the Selectable API (it was reported as raising `NoMethodError` under certain conditions).
+* `:stream_bidi` plugin: can support non-bidirectional stream requests using the same session.
+* `:stream` plugin: is now compatible with fiber scheduler engines (via the `:fiber_concurrency` plugin).
+* `:stream` plugin: make sure that stream long-running requests do not share the same connection as regular threads.
+* `:digest_auth` plugin: can now support qop values wrapped inside parentheses in the `www-authenticate` header (i.e. `qop="('auth',)"`).
+* https resolver: handle 3XX redirect responses in HTTP DNS queries.
+* https resolver: do not close HTTP connections whhich are shared across AAAA and A resolution paths when its in use by one of them.
+* fix access to private method from `http-2` which was made public in more recent versions, but not in older still-supported versions.
+* fixed resolver log message using a "connection" label.
+* `HTTPX::Response.copy_to` will explicitly close the response at the end; given that the body file can be moved as a result, there is no guarantee that the response is still usable, so might as well just close it altogether.
+* selector: avoid skipping persistent connections in the selector to deactivate due to iterate-and-modify.
+
+## Breaking Changes
+
+### `:digest_auth` error
+
+The main error class for the `:digest_auth` plugin has been moved to a different location. If you were rescuing the `HTTPX::Plugins::DigestAuth::DigestError` error, you should now point to the `HTTPX::Authentication::Digest::Error`.
+
+### `:stream` plugin: `build_request` should receive `stream: true` for stream requests
+
+In case you're building request objects before passing them to the session, you're now forced to create them with the `:stream` option on:
+
+```ruby
+session = HTTPX.plugin(:stream)
+
+# before
+req = session.build_request("GET", "https://example.com/stream")
+session.request(req, stream: true)
+
+# after
+req = session.build_request("GET", "https://example.com/stream", stream: true)
+session.request(req)
+```
+
+Previous code may still work in a few cases, but it is not guaranteed to work on all cases.

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/1_7_1.md

@@ -0,0 +1,20 @@
+# 1.7.1
+
+## Improvements
+
+* fixed timers handling in the selector loop which caused them to be traversed-for-drop twice on each tick.
+* connection: take proxy connecting states when transitioning to `:closing` state.
+* refactored name resolution cache to a cache adapter API with a default memory cache which keeps the current behaviour and will allow to add others.
+  * a new option, `:resolver_cache`, was added, which is `:memory` by default.
+  * this fixes an issue introduced for multi-ractor support where the cache store would not be thread-safe when used in a non main ractor.
+* `:auth` plugin: when loaded with the `:retries` plugin, and the auth value method is dynamic/callable, will recover out-of-the-box from 401 HTTP responses by retrying the request with a newly-generated token.
+  * the `:rate_limiter` plugin will use this work to retry rate-limited responses without having to set setting `:retry_change_requests` to true, thereby eliminating a potential issue with non-idempotent requests.
+
+## Bugfixes
+
+* HTTP1 parser: clear buffer on reset.
+* http1 fix: handle the case in `#handle_error` where the response is an error response
+* `:stream_bidi` plugin: fix internal state preventing bidi requests from being retried.
+* `:stream_bidi` plugin: will only allow initial request body being passed using `:body` param (others, like `:json`, will raise an exception)
+* https resolver: return `:idle` on `#state` calls when no connection is available (sometimes called in internal log messages).
+* selector loop fix: when there are no selectables and an interval is passed, sleep instead of returning (thereby avoiding potential busy loop).

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/1_7_2.md

@@ -0,0 +1,6 @@
+# 1.7.2
+
+## Bugfixes
+
+* `:stream_bidi` plugin: when used with the `:retries` plugin, it will skip calling callbacks referencing state from the connection/stream the request was moved from.
+* `:auth` plugin: fix issue causing tokens to be concatenated on non-auth errors.

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/1_7_3.md

@@ -0,0 +1,29 @@
+# 1.7.3
+
+## Improvements
+
+### cookies plugin: Jar as CookieStore
+
+While previously an implementation detail, the cookie jar from a `:cookie` plugin-enabled session can now be manipulated by the end user:
+
+```ruby
+cookies_sess = HTTPX.plugin(:cookies)
+
+jar = cookies.make_jar
+
+sess = cookies_ses.with(cookies: jar)
+
+# perform requests using sess, get/set/delete cookies in jar
+```
+
+The jar API now closely follows the [Web Cookie Store API](https://developer.mozilla.org/en-US/docs/Web/API/CookieStore), by providing the same set of functions.
+
+Some API backwards compatibility is maintained, however since this was an internal implementation detail, this effort isn't meant to be thorough.
+
+## Bugfixes
+
+* `http-2`: clear buffered data chunks when receiving a `GOAWAY` stream frame; without this, the client kept sending the corresponding `DATA` frames, despite the peer server making it known that it wouldn't process it. While this is valid HTTP/2, this could increase the connection window until a point where it'd go over the max frame size. this issue was observed during large file uploads where the first request could fail and make the client renegotiate.
+* `webmock` adapter: fixed response body length accounting which was making `response.body.empty?` return true for responses with payload.
+* `:rate_limiter` plugin relies on an internal refactoring to be able to wait for the time suggested by the peer server instead of the potentially relying on custom user logic via own `:retry_after`.
+* `:fiber_concurrency`: fix wrong names for native/system resolver overrides.
+* connection: fix for race condition when closing the connection, where the state only transitions to `closed` after checking the connection back in to the pool, potentially corrupting it if another session meanwhile has picked it up and manipulated it.

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/1_7_4.md

@@ -0,0 +1,42 @@
+# 1.7.4
+
+## Features
+
+### Tracing plugin
+
+A new `:tracing` plugin was introduced. It adds support for a new option, `:tracer`, which accepts an object which responds to the following callbacks:
+
+* `#enabled?(request)` - should return true or false depending on whether tracing is enabled
+* `#start(request)` - called when a request is about to be sent
+* `#finish(request, response)` - called when a response is received
+* `#reset(request)` - called when a request is being prepared to be resent, in cases where it makes sense (i.e. when a request is retried).
+
+You can pass chain several tracers, and callbacks will be relayed to all of them:
+
+```ruby
+HTTP.plugin(:tracing).with(tracer: telemetry_platform_tracer).with(tracer: telemetry2_platform_tracer)
+```
+
+This was developed to be the foundation on top of which the datadog and OTel integrations will be built.
+
+## Improvements
+
+* try fetching response immediately after send the request to the connection; this allows returning from errors much earlier and bug free than doing another round of waits on I/O.
+* when a connection is reconnected, and it was established the first time that the peer can accept only 1 request at a time, the connection will keep that informaation and keep sending requests 1 at a time afterwards.
+
+## Bugfixes
+
+* fix regression from introducing connection post state transition callbacks, by foregoing disconnect when there's pending backlog.
+* transition requests to `:idle` before routing them to a different connection on merge (this could possibly leave dangling timeout callbacks otherwise).
+* `:brotli` plugin was integrated with the stream writer component which allows writing compressed payload in chunks.
+* `:brotli` plugin integrates with the `brotli` gem v0.8.0, which fixed an issue dealing with large payload responses due to the lack of support for decoding payloads in chunks.
+* http1 parser: reset before early returning on `Upgrade` responses (it was left in an invalid "parsing headers", which in the case of a keep-alive connection, would cause the next request to fail being parsed).
+* `datadog` adapter: fixed initialization of the request start time after connections were opened (it was being set to connection initialization time every time, instead of just on the first request before connection is established).
+* parsers: also reroute non-completed in-flight requests back to the connection so they can be retried (previously, only pending requests were).
+* `:proxy` plugin: do not try disconnecting unnecessarily when resetting may already do so (if conditions apply).
+* `:proxy` plugin: removed call to unexisting `#reset!` function.
+* `:proxy` plugin: also close wrapped sockets.
+* connection: on force_close, move connection disconnection logic below so that, if requests are reenqueued from the parser, this can be halted.
+* connection: when transition to `:idle`, reenqueue requests from parser before resetting it.
+* implement `#lazy_resolve` on resolvers, as when they're picked from the selector (instead of from the pool), they may not be wrapped by a Multi proxy.
+* allow resolvers transitioning from `:idle` to `:closed` and forego disconnecting when the resolver is not able to transition to `:closed` (which protects from a possible fiber scheduler context switch which changed the state under the hood).

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/1_7_5.md

@@ -0,0 +1,10 @@
+# 1.7.5
+
+## Improvements
+
+* `:tracing` plugin: make `Request#init_time` a UTC timestamp.
+
+## Bugfixes
+
+* fixed handling of conditional responses which was making a batch of concurrent requests being handled serially after they failed.
+* `datadog` adapter: use `Request#init_time` as the span start time, which will fix the bug where the span wasn't including the time it takes to open the connection (TCP/TLS handhshakes).

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/1_7_6.md

@@ -0,0 +1,24 @@
+# 1.7.6
+
+## Improvements
+
+* `datadog` adapter: support setting custom `peer.service`.
+* stopped doing `Thread.pass` after checking connections back into the pool. The goal of this was to allow threads potentially waiting on a connection for the same origin to have the opportunity to take it before the same thread could check the same connection out, thereby preventing starvation on limited pool sizes; this however backfired for the common case of unbounded pool sizes (the default), and was specially bad when used for multiple concurrent requests on multiple origins, where avoidable lag was introduced on the whole processing every time a connection was checked back in. Thereby, the initial problem needs to be solved at the mutex implementation of CRuby.
+* connection: after keep alive timeout expired, try writing `PING` frame to the socket as soon as it's emitted (previously, the frame was being buffered and the socket would be probed for readiness before writing it, whereas in most cases this is avoidable).
+
+
+## Bugfixes
+
+* reuse the same resolver instance when resolving multiple concurrent requests in the same option (it was previously instantiating different ones based on option heuristics, such as when requests had different `:origin`).
+* on successful early name resolution (from cache or hosts file, for example), check the resolver back to the pool (the object was being dereferenced).
+* http1 parser: turn buffer back into a string on reset, instead of preserving its current type (in cases where it was a chunked transfer decoder and connection was kept-alive, it was keeping it around and using it to parse the next request, which broke).
+* http1 parser: enable pipelining based on the max concurrent requests, which the connection may have had pre-set to 1 based on prior knowledge of origin or other heuristics.
+* http1 parser: when disabling pipelining, mark incomplete inlined requests as idle before sending them back to the pending queue.
+* http1 and http2 parser: remove references to requests escalating an error; in scenarios of connection reuse (such as when using the `:persistent` plugin), these requests could be, on a transition to idle state, resent even in the absence of an external session reference, causing avoidable overhead or contention leading to timeouts or errors.
+* connection: rescue and ignore exceptions when calling `OpenSSL::SSL::SSLSocket#close` or `Socket#close`.
+* connection: when sending multiple requests into an open HTTP/2 connection which keep alive may have expired, only a single (instead of multiple, as before) `PING` frame will be sent (in the prior state, only the first `PING` was being acknowledged, which made the connection accumulate unacknowledged ping payloads).
+* connection: on handling errors, preventing potential race condition by copying pending requests into a local var before calling `parser.handle_error` (this may trigger a callback which calls `#reset`, which may call `#disconnect`, which would check the connection back into the pool and make it available for another thread, which could change the state of the ivar containing pending requests).
+* connection: skip resetting a connection when idle and having pending requests; this may happen in situation where parsers may have reset-and-back-to-idle the connection to resend failed requests as protocol (such as in the case of failed HTTP/1 pipelinining requests where incomplete requests are to be resent to the connection once pipelining is disabled).
+* connection: raise request timeout errors for the request the connection is currently in, instead of the connection where it was initially sent on and set timeouts on; this happens in situations where the request may be retried and sent to a different connection, which forces the request to keep a reference to the connection it's currently in (and discard it when it no longer needs it to prevent it from being GC'ed).
+* `:auth` plugin: when used alongside the `:retries` plugin for multiple concurrent requests, it was calling the dynamic token generator block once for each request; fixed to call the block only once per retry window, so retrying requests will reuse the same.
+* `:retries` plugin: retry request immediately if `:retry_after` is negative (while the option is validated for numbers, it can't control proc-based calculation).

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/1_7_7.md

@@ -0,0 +1,17 @@
+# 1.7.7
+
+## Improvements
+
+* ssl cert info will also be redacted when `:debug_redact` option is enabled.
+* fix performance regression of #receive_requests recent loop change (which also improved performance of previous baseline).
+* header/data logs indexed by request (instead of parser).
+
+## Bugfixes
+
+* proxy: fixed issue when basic auth to proxy failed with 407 and it'd raise NoMethodError when retrying (marked as unretriable now).
+* selector: prevent removal of wrong selectable when previous closed via `#on_close` during selectables traversal.
+* http1: only reset requests which weren't completed (prevent issuing errors twice).
+* http1: forego clearing buffer on reset (avoid deleting potential next request bytes).
+* response_cache: reset cached response age on successful cache revalidation, as per RFC.
+* rate_limiter: do not apply jitter when delay comes from `retry-after` header.
+* digest: digest header parsing issues results in an error response (instead of an exception raised).

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/1_7_8.md

@@ -0,0 +1,5 @@
+# 1.7.8
+
+## Bugfixes
+
+retries: do not calculate jitter when there's no retry_after interval

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/1_8_0.md

@@ -0,0 +1,100 @@
+# 1.8.0
+
+## Features
+
+### New plugins
+
+#### `:server_sent_events` plugin
+
+The `:server_sent_events` plugin provides a convenience API to deal with `text/event-stream` requests, on top of the `:stream` plugin.
+
+```ruby
+session = HTTPX.plugin(:server_sent_events)
+
+sse_response = session.get("https://example.com/event-stream", event_stream: true)
+
+sse_response.each_message do |message|
+  puts message.id
+  puts message.event
+  puts message.data
+end
+```
+
+You can read more about it in https://gitlab.com/os85/httpx/wikis/Server-Sent-Events .
+
+#### `:cache` plugin
+
+The `:cache` plugin allows caching responses. It exposes some options to determine some of its functionality, i.e. whether a request can use a cached response, whether a response can be cached, whether a cached response is still valid, etc.
+
+This functionality was extracted from the `:response_cache` plugin, which now uses it under the hood.
+
+You can read more about it in https://gitlab.com/os85/httpx/wikis/Cache .
+
+#### `:ntlm_v2_auth` plugin
+
+The `:ntlm_v2_auth` plugin is now available. It implements the most recent version of the NTLM authentication scheme supported by Microsoft products.
+
+You can read more about it in https://gitlab.com/os85/httpx/wikis/Auth#ntlm-v2-auth .
+
+### New timeouts
+
+#### `:total_request_timeout`
+
+You can use the `:total_request_timeout` to time the time it takes a request to get its final response. This includes when your requests follows redirects (via the `:follow_redirects` plugin) or is retried multiple times (via the `:retries´ plugin).
+
+#### `:ping_timeout`
+
+Defines the number of seconds a connection waits to receive a ping response when probing for a connection for liveness.
+
+Defaults to 2 seconds.
+
+### `:ssrf_filter` plugin new options
+
+#### `:extra_unsafe_ranges`
+
+A list of extra unsafe IPs or IP ranges to the default deny list.
+
+#### `:safe_private_ranges`
+
+A list of IPs or IP ranges which are allowed and would otherwise be denied.
+
+### `:auth` plugin new option
+
+#### `:reset_auth_header_expires_in/at`
+
+The `:reset_auth_header_expires_in` and `:reset_auth_header_expires_at`  options enable discarding an authorization token an X number of seconds after it has been generated, or at a particuar point in time, respectively. This is useful when the token is dynamically generated, so that you can preemptively renegotiate a new one.
+
+The `:oauth` plugin makes use of these fields, alongside the `expires_in` claim from token responses, to refresh the token as soon as the it expires.
+
+### `:max_response_body_size`
+
+Can be set to the maximum number of bytes a response may have, after which it'll return an `HTTPX::ErrorResponse`. The limit is enforced based on the `content-length` header and as bytes are received.
+
+### `:max_response_headers`
+
+Can be set to the maximum number of headers a response may have.
+
+### `:max_response_header_value_size`
+
+Can be set to the maximum number of bytes a header value may have. In cases where a header field may be spread across multiple entries (ex. `"cookie"`), the limit is enforced on the aggregate byte size.
+
+### resolver file cache
+
+By specifying `:file` as the resolver `:cache` option, the DNS entries will be cached in a known location in your file system. This will allow sharing entries across processes within the same machine to reduce overall DNS traffic. You can use it via:
+
+```ruby
+session = HTTPX.with(resolver_options: { cache: :file })
+session.get("https://example.com")
+```
+
+## Improvements
+
+* `http-2` minimum version is now 1.2.0, which brings performance benefits around frame parsing and other common operations.
+
+## Bugfixes
+
+* several fixes to make `httpx` usable inside a fiber scheduler in ruby 4.
+* `:proxy` plugin: unescape user/password from proxy options before reusing it (to avoid using percent-encoded values when p.ex. generating base64-encoding for basic auth).
+* `:retries` plugin: fixed the polynomial and exponential backoff `:retry_after` strategies calculation.
+* `:tracing` plugin: fixing span start time set up when request is sent to a closed connection, or when a long-lived connection will be probed for liveness.
+* datadog adapter: fixed integration with the `datadog` gem v2.34 or higher.

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/1_8_1.md

@@ -0,0 +1,27 @@
+# 1.8.1
+
+## Improvements
+
+* the session will now eagerly write initial data to connections instead of waiting for I/O the first time (saves a syscall).
+* removed all rescue blocks rescuing `StandardError` internally; this could interfere with usages of `httpx` inside `Timeout.timeout` blocks, which may emit an exception at any point, including in blocks where that exception could be rescued, leaving the session in a potentially irrecoverable state and looping.
+* debug logs change the display of ids from 'tid:123, fid:123' to 'tid=123 fid:123'.
+  * and when using the `datadog` adapter, all related correlation ids (trace id, span id, etc) will also be added to the identifiers in the same format
+* plugins built on top of the `:retries` plugin will skip the `retry_after` interval when certain conditions are met.
+  * `:persistent` plugin: request will be retried immediately, when the error happens after the keep alive interval expired.
+  * `:auth` plugin: request will be retried immediately if it failed due to a "401 Unauthorized Error".
+* `:ssrf_filter` plugin: removed public/private references of exception message.
+
+## Bugfixes
+
+* `:auth` plugin: handle edge case where `:auth_header_expires_at` returns no value.
+* `:digest_auth` plugin: do not retry if there was an issue building building the authorization header after the probe.
+* `webmock` adapter: prevent mocked requests from opening a connection to the peer server that will not be used.
+* clear and cancel request timers on completion or reset, ensuring that they won't be retained way past the point where the request is gone.
+* connection: cancel and discard ping timer before closing (removes timer reference)
+* connection: fix logic where purging-while-resending requests to a coalesced connection was leaving references in the old connection.
+* moved an `on_body_chunk` callback to the `:callbacks` plugin, where it's used and expected to be defined.
+* `http2`: avoid closing the connection on internal errors which are supposed to be specific to a request, such as the max headers or max response body size checks.
+* system resolver will use an internal exception when using `Timeout.timeout` on resolutions to avoid conflicts with the default timeout exception class.
+* prevent edge case where `#alpn_protocol` was being called on a `TCPSocket`.
+* fixed v1.8.0 regression causing connection to loop when an error happens while connecting.
+* resolver cache: fixed cache eviction logic, where alias answers weren't being evicted, causing resolutions to stall after a certain number of resolutions.

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/1_8_2.md

@@ -0,0 +1,30 @@
+# 1.8.2
+
+## Improvements
+
+* `:proxy` plugin: allow setting `:no_proxy` option to `"*"` (or `["*"]`) to allow bypassing proxy for all requests.
+* Extending sessions with unknown options will now raise an error, instead of silently ignoring them (consistent with the initialization case now):
+
+```ruby
+session = HTTPX.with(unknown_option: 1) # will raise a HTTPX::Error: unknown option: unknown_option
+```
+
+* Use `HTTP2::Connection#closed?` internally (instead of `#state`) to check for connection state; this will, in a future release of `http-2`, seamlessly support the new `:closing` state.
+* Add missing `response` attribute reader to `HTTPX::RequestTimeoutError`.
+* Improve correctness of calling `#dup` on requests and connections.
+
+## Bugfixes
+
+* `:auth` plugin: generate token first, then set the "expires_at" timestamp (bearer tokens, specially if JWT, may carry information about when it expires).
+* `:auth` plugin: do not check for token freshness on a retry, instead force token regeneration.
+* `:retries` plugin: do not apply "retry after" delay after a ping timeout error (the ping timeout already implies a delay, so retry on a new connection should be immediate).
+* `:retries` plugin: do not retry on any HTTP/2 frame error (only on GOAWAY or PING frame errors).
+* `:persistent` plugin: do not decrement request remaining retries on ping or GOAWAY frame errors.
+* `:tracing` plugin: set connection initialization time to nil no termination (so that it doesn't get reused on persistent connections after reuse).
+* `:follow_redirects` plugin: fixed issue when a timeout error would be raised but only bubble up to the root request, not properly closing the in-flight follow up request, and leaving the request handling phase in a broken state.
+* datadog adapter: the connection initialization time is now set only on connect or first request received, the reason, making it more accurate.
+* webmock adapter: `.to_timeout` helper will make the request raise a `HTTPX::RequestTimeoutError` instead of a plain `TimeoutError` (otherwise, if using persistent sessions, it'd trigger a retry instead and mess with webmock request count bookkeeping).
+* native resolver: do not transition to `:open` if the socket was closed during resolution (which happens when an error is raised while the query bytes are buffered).
+* fix for when setting a new session callback on an ssl context object which has been frozen after the first connection attempt (done by binding the ssl context callback to an internal ivar which can be changed).
+* connection: protect against `Errno::ETIMEDOUT` errors on socket close by forcing transition to closed.
+* do not set a ping timer for HTTP/1.1 on keep alive flow, as there's no ping and the connection is reestablished.

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/1_8_3.md

@@ -0,0 +1,9 @@
+# 1.8.3
+
+## Bugfixes
+
+options print a  warning instead of raising an error on unknown option
+
+the approach introduced in the previous version, of erroring on something people have been accidentally relying on, is too strict in hindsight for a patch version. This was reverted, and instead, a deprecation warning will be printed, to give time for folks to migrate.
+
+the format of options messages (exceptions and warnings) also slightly changes to wrap the option in quotes, for proper highlighting.

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/1_8_4.md

@@ -0,0 +1,13 @@
+# 1.8.4
+
+## Improvements
+
+* send requests which were not sent, or were not processed by the server, when the server sends back a GOAWAY frame (which is deemed recoverable, like when there's no error), after forcing a reconnection (instead of bubbling up the GOAWAY error for all of them).
+
+## Bugfixes
+
+* `:retries` plugin: also retry requests which failed due to a RST_STREAM frame with REFUSED_STREAM error code.
+* `:retries` plugin: resend requests which were piped to a closed connection internally.
+* `:proxy` plugin: fix issue related with reconnecting inactive connections shut down by the peer, when used with the `:persistent` plugin, where the CONNECT request wasn't being sent to establish the tunnel.
+* fixed compatibility issue starting with the `json` gem 3.0.0, when calling `HTTPX::Response#json`.
+* avoid bookkepping issue in session, where the `on_response_arrived` on a request may be called more than once (which it can happen in the `:follow_redirects` plugin, where a request may have completed due to an error, while the request is waiting to be resent due to `retry-after`).