alogram_payrisk 0.2.9

data/vendor/bundle/ruby/3.3.0/gems/httpx-1.7.6/doc/release_notes/1_3_0.md

@@ -0,0 +1,18 @@
+# 1.3.0
+
+## Dependencies
+
+`http-2` v1.0.0 is replacing `http-2-next` as the HTTP/2 parser.
+
+`http-2-next` was forked from `http-2` 5 years ago; its improvements have been merged back to `http-2` recently though, so `http-2-next` willl therefore no longer be maintained.
+
+## Improvements
+
+Request-specific options (`:params`, `:form`, `:json` and `:xml`) are now separately kept by the request, which allows them to share `HTTPX::Options`, and reduce the number of copying / allocations.
+
+This means that `HTTPX::Options` will throw an error if you initialize an object which such keys; this should not happen, as this class is considered internal and you should not be using it directly.
+
+## Fixes
+
+* support for the `datadog` gem v2.0.0 in its adapter has been unblocked, now that the gem has been released.
+* loading the `:cookies` plugin was making the `Session#build_request` private.

data/vendor/bundle/ruby/3.3.0/gems/httpx-1.7.6/doc/release_notes/1_3_1.md

@@ -0,0 +1,17 @@
+# 1.3.1
+
+## Improvements
+
+* `:request_timeout` will be applied to all HTTP interactions until the final responses returned to the caller. That includes:
+  * all redirect requests/responses (when using the `:follow_redirects` plugin)
+  * all retried requests/responses (when using the `:retries` plugin)
+  * intermediate requests (such as "100-continue")
+* faraday adapter: allow further plugins of internal session (ex: `builder.adapter(:httpx) { |sess| sess.plugin(:follow_redirects) }...`)
+
+## Bugfixes
+
+* fix connection leak on proxy auth failed (407) handling
+* fix busy loop on deferred requests for the duration interval
+* do not further enqueue deferred requests if they have terminated meanwhile.
+* fix busy loop caused by coalescing connections when one of them is on the DNS resolution phase still.
+* faraday adapter: on parallel mode, skip calling `on_complete` when not defined.

data/vendor/bundle/ruby/3.3.0/gems/httpx-1.7.6/doc/release_notes/1_3_2.md

@@ -0,0 +1,6 @@
+# 1.3.2
+
+## Bugfixes
+
+* Prevent `NoMethodError` in an edge case when the `:proxy` plugin is autoloaded via env vars and webmock adapter are used in tandem, and a real request fails.
+* raise invalid uri error if passed request uri does not contain the host part (ex: `"https:/get"`)

data/vendor/bundle/ruby/3.3.0/gems/httpx-1.7.6/doc/release_notes/1_3_3.md

@@ -0,0 +1,5 @@
+# 1.3.3
+
+## Bugfixes
+
+* fixing a regression introduced in 1.3.2 associated with the webmock adapter, which expects matchable request bodies to be strings

data/vendor/bundle/ruby/3.3.0/gems/httpx-1.7.6/doc/release_notes/1_3_4.md

@@ -0,0 +1,6 @@
+# 1.3.4
+
+## Bugfixes
+
+* webmock adapter: fix tempfile usage in multipart requests.
+* fix: fallback to binary encoding when parsing incoming invalid charset in HTTP "content-type" header.

data/vendor/bundle/ruby/3.3.0/gems/httpx-1.7.6/doc/release_notes/1_4_0.md

@@ -0,0 +1,43 @@
+# 1.4.0
+
+## Features
+
+### `:content_digest` plugin
+
+The `:content_digest` can be used to calculate the digest of request payloads and set them in the `"content-digest"` header; it can also validate the integrity of responses which declare the same `"content-digest"` header.
+
+More info under https://honeyryderchuck.gitlab.io/httpx/wiki/Content-Digest
+
+## Per-session connection pools
+
+This architectural changes moves away from per-thread shared connection pools, and into per-session (also thread-safe) connection pools. Unlike before, this enables connections from a session to be reused across threads, as well as limiting the number of connections that can be open on a given origin peer. This fixes long-standing issues, such as reusing connections under a fiber scheduler loop (such as the one from the gem `async`).
+
+A new `:pool_options` option is introduced, which can be passed an hash with the following sub-options:
+
+* `:max_connections_per_origin`: maximum number of connections a pool allows (unbounded by default, for backwards compatibility).
+* `:pool_timeout`: the number of seconds a session will wait for a connection to be checked out (default: 5)
+
+More info under https://honeyryderchuck.gitlab.io/httpx/wiki/Connection-Pools
+
+
+## Improvements
+
+* `:aws_sigv4` plugin: improved digest calculation on compressed request bodies by buffering content to a tempfile.
+* `HTTPX::Response#json` will parse payload from extended json MIME types (like `application/ld+json`, `application/hal+json`, ...).
+
+## Bugfixes
+
+* `:aws_sigv4` plugin: do not try to rewind a request body which yields chunks.
+* fixed request encoding when `:json` param is passed, and the `oj` gem is used (by using the `:compat` flag).
+* native resolver: on message truncation, bubble up tcp handshake errors as resolve errors.
+* allow `HTTPX::Response#json` to accept extended JSON mime types (such as responses with `content-type: application/ld+json`)
+
+## Chore
+
+* default options are now fully frozen (in case anyone relies on overriding them).
+
+### `:xml` plugin
+
+XML encoding/decoding (via `:xml` request param, and `HTTPX::Response#xml`) is now available via the `:xml` plugin.
+
+Using `HTTPX::Response#xml` without the plugin will issue a deprecation warning.

data/vendor/bundle/ruby/3.3.0/gems/httpx-1.7.6/doc/release_notes/1_4_1.md

@@ -0,0 +1,19 @@
+# 1.4.1
+
+## Bugfixes
+
+* several `datadog` integration bugfixes
+    * only load the `datadog` integration when the `datadog` sdk is loaded (and not other gems that may define the `Datadog` module, like `dogstatsd`)
+    * do not trace if datadog integration is loaded but disabled
+    * distributed headers are now sent along (when the configuration is enabled, which it is by default)
+* fix for handling multiple `GOAWAY` frames coming from the server (node.js servers seem to send multiple frames on connection timeout)
+* fix regression for when a url is used with `httpx` which is not `http://` or `https://` (should raise `HTTPX::UnsupportedSchemaError`)
+* worked around `IO.copy_stream` which was emitting incorrect bytes for HTTP/2 requests which bodies larger than the maximum supported frame size.
+* multipart requests: make sure that a body declared as `Pathname` is opened for reading in binary mode.
+* `webmock` integration: ensure that request events are emitted (such as plugins and integrations relying in it, such as `datadog` and the OTel integration)
+* native resolver: do not propagate successful name resolutions for connections which were already closed.
+* native resolver: fixed name resolution stalling, in a multi-request to multi-origin scenario, when a resolution timeout would happen.
+
+## Chore
+
+* refactor of the happy eyeballs and connection coalescing logic to not rely on callbacks, and instead on instance variable management (makes code more straightforward to read).

data/vendor/bundle/ruby/3.3.0/gems/httpx-1.7.6/doc/release_notes/1_4_2.md

@@ -0,0 +1,20 @@
+# 1.4.2
+
+## Bugfixes
+
+* faraday: use default reason when none is matched by Net::HTTP::STATUS_CODES
+* native resolver: keep sending DNS queries if the socket is available, to avoid busy loops on select
+* native resolver fixes for Happy Eyeballs v2
+  * do not apply resolution delay if the IPv4 IP was not resolved via DNS
+  * ignore ALIAS if DNS response carries IP answers
+  * do not try to query for names already awaiting answer from the resolver
+  * make sure all types of errors are propagated to connections
+  * make sure next candidate is picked up if receiving NX_DOMAIN_NOT_FOUND error from resolver
+* raise error happening before any request is flushed to respective connections (avoids loop on non-actionable selector termination).
+* fix "NoMethodError: undefined method `after' for nil:NilClass", happening for requests flushed into persistent connections which errored, and were retried in a different connection before triggering the timeout callbacks from the previously-closed connection.
+
+
+## Chore
+
+* Refactor of timers to allow for explicit and more performant single timer interval cancellation.
+* default log message restructured to include info about process, thread and caller.

data/vendor/bundle/ruby/3.3.0/gems/httpx-1.7.6/doc/release_notes/1_4_3.md

@@ -0,0 +1,11 @@
+# 1.4.3
+
+## Bugfixes
+
+* `webmock` adapter: reassign headers to signature after callbacks are called (these may change the headers before virtual send).
+* do not close request (and its body) right after sending, instead only on response close
+  * prevents retries from failing under the `:retries` plugin
+  * fixes issue when using `faraday-multipart` request bodies
+* retry request with HTTP/1 when receiving an HTTP/2 GOAWAY frame with `HTTP_1_1_REQUIRED` error code.
+* fix wrong method call on HTTP/2 PING frame with unrecognized code.
+* fix EOFError issues on connection termination for long running connections which may have already been terminated by peer and were wrongly trying to complete the HTTP/2 termination handshake.

data/vendor/bundle/ruby/3.3.0/gems/httpx-1.7.6/doc/release_notes/1_4_4.md

@@ -0,0 +1,14 @@
+# 1.4.4
+
+## Improvements
+
+* `:stream` plugin: response will now be partially buffered in order to i.e. inspect response status or headers on the response body without buffering the full response
+  * this fixes an issue in the `down` gem integration when used with the `:max_size` option.
+* do not unnecessarily probe for connection liveness if no more requests are inflight, including failed ones.
+* when using persistent connections, do not probe for liveness right after reconnecting after a keep alive timeout.
+
+## Bugfixes
+
+* `:persistent` plugin: do not exhaust retry attempts when probing for (and failing) connection liveness.
+  * since the introduction of per-session connection pools, and consequentially due to the possibility of multiple inactive connections for the same origin being in the pool, which may have been terminated by the peer server, requests would fail before being able to establish a new connection.
+* prevent retrying to connect the TCP socket object when an SSLSocket object is already in place and connecting.

data/vendor/bundle/ruby/3.3.0/gems/httpx-1.7.6/doc/release_notes/1_5_0.md

@@ -0,0 +1,126 @@
+# 1.5.0
+
+## Features
+
+### `:stream_bidi` plugin
+
+The `:stream_bidi` plugin enables bidirectional streaming support (an HTTP/2 only feature!). It builds on top of the `:stream` plugin, and uses its block-based syntax to process incoming frames, while allowing the user to pipe more data to the request (from the same, or another thread/fiber).
+
+```ruby
+http = HTTPX.plugin(:stream_bidi)
+request = http.build_request(
+  "POST",
+  "https://your-origin.com/stream",
+  headers: { "content-type" => "application/x-ndjson" },
+  body: ["{\"message\":\"started\"}\n"]
+)
+
+chunks = []
+
+response = http.request(request, stream: true)
+
+Thread.start do
+  response.each do |chunk|
+    handle_data(chunk)
+  end
+end
+
+# now send data...
+request << "{\"message\":\"foo\"}\n"
+request << "{\"message\":\"bar\"}\n"
+# ...
+```
+
+You can read more about it in https://honeyryderchuck.gitlab.io/httpx/wiki/Stream-Bidi
+
+### `:query` plugin
+
+The `:query` plugin adds public methods supporting the `QUERY` HTTP verb:
+
+```ruby
+http = HTTPX.plugin(:query)
+
+http.query("https://example.com/gquery", body: "foo=bar") # QUERY /gquery ....
+```
+
+You can read more about it in https://honeyryderchuck.gitlab.io/httpx/wiki/Query
+
+this functionality was added as a plugin for explicit opt-in, as it's experimental (RFC for the new HTTP verb is still in draft).
+
+### `:response_cache` plugin filesystem based store
+
+The `:response_cache` plugin supports setting the filesystem as the response cache store (instead of just storing them in memory, which is the default `:store`).
+
+```ruby
+# cache store in the filesystem, writes to the temporary directory from the OS
+http = HTTPX.plugin(:response_cache, response_cache_store: :file_store)
+# if you want a separate location
+http = HTTPX.plugin(:response_cache).with(response_cache_store: HTTPX::Plugins::ResponseCache::FileStore.new("/path/to/dir"))
+```
+
+You can read more about it in https://honeyryderchuck.gitlab.io/httpx/wiki/Response-Cache#:file_store
+
+### `:close_on_fork` option
+
+A new option `:close_on_fork` can be used to ensure that a session object which may have open connections will not leak them in case the process is forked (this can be the case of `:persistent` plugin enabled sessions which have add usage before fork):
+
+```ruby
+http = HTTPX.plugin(:persistent, close_on_fork: true)
+
+# http may have open connections here
+fork do
+  # http has no connections here
+end
+```
+
+You can read more about it in https://honeyryderchuck.gitlab.io/httpx/wiki/Connection-Pools#Fork-Safety .
+
+### `:debug_redact` option
+
+The `:debug_redact` option will, when enabled, replace parts of the debug logs (enabled via `:debug` and `:debug_level` options) which may contain sensitive information, with the `"[REDACTED]"` placeholder.
+
+You can read more about it in https://honeyryderchuck.gitlab.io/httpx/wiki/Debugging .
+
+### `:max_connections` pool option
+
+A new `:max_connections` pool option (settable under `:pool_options`) can be used to defined the maximum number **overall** of connections for a pool ("in-transit" or "at-rest"); this complements, and supersedes when used, the already existing `:max_connections_per_origin`, which does the same per connection origin.
+
+```ruby
+HTTPX.with(pool_options: { max_connections: 100 })
+```
+
+You can read more about it in https://honeyryderchuck.gitlab.io/httpx/wiki/Connection-Pools .
+
+### Subplugins
+
+An enhancement to the plugins architecture, it allows plugins to define submodules ("subplugins") which are loaded if another plugin is in use, or is loaded afterwards.
+
+You can read more about it in https://honeyryderchuck.gitlab.io/httpx/wiki/Custom-Plugins#Subplugins .
+
+## Improvements
+
+* `:persistent` plugin: several improvements around reconnections of failure:
+  * reconnections will only happen for "connection broken" errors (and will discard reconnection on timeouts)
+  * reconnections won't exhaust retries
+* `:response_cache` plugin: several improements:
+  * return cached response if not stale, send conditional request otherwise (it was always doing the latter).
+  * consider immutable (i.e. `"Cache-Control: immutable"`) responses as never stale.
+* `:datadog` adapter: decorate spans with more tags (header, kind, component, etc...)
+* timers operations have been improved to use more efficient algorithms and reduce object creation.
+
+## Bugfixes
+
+* ensure that setting request timeouts happens before the request is buffered (the latter could trigger a state transition required by the former).
+* `:response_cache` plugin: fix `"Vary"` header handling by supporting a new plugin option, `:supported_vary_headers`, which defines which headers are taken into account for cache key calculation.
+* fixed query string encoded value when passed an empty hash to the `:query` param and the URL already contains query string.
+* `:callbacks` plugin: ensure the callbacks from a session are copied when a new session is derived from it (via a `.plugin` call, for example).
+* `:callbacks` plugin: errors raised from hostname resolution should bubble up to user code.
+* fixed connection coalescing selector monitoring in cases where the coalescable connecton is cloned, while other branches were simplified.
+* clear the connection write buffer in corner cases where the remaining bytes may be interpreted as GOAWAY handshake frame (and may cause unintended writes to connections already identified as broken).
+* remove idle connections from the selector when an error happens before the state changes (this may happen if the thread is interrupted during name resolution).
+
+## Chore
+
+`httpx` makes extensive use of features introduced in ruby 3.4, such as `Module#set_temporary_name` for otherwise plugin-generated anonymous classes (improves debugging and issue reporting), or `String#append_as_bytes` for a small but non-negligible perf boost in buffer operations. It falls back to the previous behaviour when used with ruby 3.3 or lower.
+
+Also, and in preparation for the incoming ruby 3.5 release, dependency of the `cgi` gem (which will be removed from stdlib) was removed.

data/vendor/bundle/ruby/3.3.0/gems/httpx-1.7.6/doc/release_notes/1_5_1.md

@@ -0,0 +1,6 @@
+# 1.5.1
+
+## Bugfixes
+
+* connection errors on persistent connections which have just been checked out from the pool no longer account for retries bookkeeping; the assumption should be that, if a connection has been checked into the pool in an open state, chances are, when it eventually gets checked out, it may be corrupt. This issue was more exacerbated in `:persistent` plugin connections, which by design have a retry of 1, thus failing often immediately after check out without a legitimate request try.
+* native resolver: fix issue with process interrupts during DNS request, which caused a busy loop when closing the selector.

data/vendor/bundle/ruby/3.3.0/gems/httpx-1.7.6/doc/release_notes/1_6_0.md

@@ -0,0 +1,50 @@
+# 1.6.0
+
+## Features
+
+### `:fiber_concurrency` plugin
+
+While simple use cases of `httpx` being used inside a fiber scheduler (such as [async](github.com/socketry/async)) worked, a serious of issues were identified when connections were reused across fibers for multiple requests (such as when using the `:persistent` plugin). The `:fiber_concurrency` plugin fixes that, by bookkeeping which requests are being used in which fibers in order to avoid spurious wakeups and busy loops.
+
+This plugin is loaded by default when using the `:persistent` plugin, and by extension the `faraday` adapter.
+
+You can read more about it in https://honeyryderchuck.gitlab.io/httpx/wiki/Fiber-Concurrency
+
+## Improvements
+
+* proxy errors are now retriable (when using the `:retries` plugin alongside the `:proxy` plugin).
+* several options improvements:
+  * improve initialization by caching options names in the class, which facilitates predictable option ivar initialization, which avoids "too many shapes" performance penalty.
+  * when using `HTTPX::Options#merge`, enforce usage of Hash or `HTTPX::Options` object as the argument to merge with, instead of silently ignoring when none of the former.
+  * `option_` setter methods are now private.
+  * all options ivars are frozen on initialize, which enforces the immutability guarantees (**note**: in case you were relying on it not being truly mutable, this may break your code. Try either passing immutable values to options, or instead use procs).
+* several selector loop improvements:
+  * move selectable checks a layer above to avoid calling `IO.select` with a single socket at all costs.
+  * Improve connection interest calculation to reduce spurious wakeups.
+  * skip early when finding closed selectables
+* improve connection initialization to avoid "too many shapes" performance penalty.
+* Plugins are now able to extend the functionality of both HTTP1 and HTTP2 connections, as well as resolvers.
+  * see instructions in the [custom lugins wiki](https://gitlab.com/os85/httpx/-/wikis/Custom-Plugins).
+* IP addresses which have expired their TTL (from the respective DNS answer) will be invalidated and force a new name resolution on operations requiring it, such as reconnections or cache lookups.
+* connections are removed from errors which store it internally (for internal purposes) before returning the respective error response (so that it can be garbage collected).
+
+## Bugfixes
+
+* remove check for non-unique local ipv6 which was preventing Happy Eyeballs v2 from kicking in.
+* recover from "network unreachable" errors triggered by using a cached IP.
+* dealing with requests which are rerouted for retries in the main session response handling loop.
+* `datadog` adapter: compatibility with support versions under 1.13.0 is working again.
+* http2 connection: fix calculation when connection closes and there's no termination handshake
+* `callback_for`: check for existence of ivar `@callbacks` first.
+* native resolver: do not buffer DNS query if waiting on a previous reply (even across fibers).
+* http2: do not allow deactivating connections which finished all requests but are still waiting for the ack of the PING frame (which can happen in a multi-fiber usage scenario).
+* pool: fix when connection is acquired after waiting on it; return it immediately, instead of bookkeeping on `:max_connections` (when defined).
+* session: fix deactivation flow, when connections get deregistered from selector and removed from the array being iterated on.
+* `:proxy` plugin: fix ssl reconnection such as, on close, the IO downgrades to the respective tcp socket, so that reconnection handshake starts from scratch with the original IO.
+* `:persistent` plugin: calling `HTTPX::Session#close` will close selectors from other threads (instead of just the thread it was called on).
+* `:callbacks` plugin: propagate callbacks to "derived-via `.plugin`" sessions.
+* `:callbacks` plugin: do not trigger the `on_response_completed` callback if there was an error (as that's what the `on_request_error` callback is for).
+
+## Chore
+
+*  decoupled form and multipart transcoders, moved "form or multipart" check to request body.

data/vendor/bundle/ruby/3.3.0/gems/httpx-1.7.6/doc/release_notes/1_6_1.md

@@ -0,0 +1,17 @@
+# 1.6.1
+
+## Improvements
+
+* `:oauth` plugin: `.oauth_session` can be called with an `:audience` parameter, which has the effect of adding it as an extra form body parameter of the token request.
+
+## Bugfixes
+
+* options: when freezing the options, skip freezing `:debug`; it's usually a file/IO/stream object (stdout, stderr...), which makes it error when log messages are written.
+* tcp: fixed adding IPv6 addresses to a tcp object when IPv4 connection probe is ongoing so that the next try uses the first ipv6 address.
+* tcp: reorder addresses on reconnection, so ipv6 is tried first in case it is still valid.
+* tcp: make sure ip index is decremented on error, so the next tried IP may be a valid one.
+* tcp: do not reattempt connecting if there are no available addresses to connect. This may happen in a fiber-aware context, where fiber A waits on connection, fiber B reconnects as a result on an error or GOAWAY frame and waits on the resolver DNS answer, and when context is passed back to fiber B, it should go back to the invalidate the response and try again while waiting on the resolver as well.
+* ssl: on connection coalescing, do not merge the ssl sessions, as these are frozen post-initialization.
+* http2: all received GOAWAY frames emit goaway error and teardown the connection independent of the error code (it was only doing it for `:noerror`, but others may appear).
+* do not check at require time whether the network is multi-homed; instead, defer it to first use and cache (this can break environments which block access to certain syscalls during boot time).
+* options: do not ignore when user sets `:ip_families` in name resolution.

data/vendor/bundle/ruby/3.3.0/gems/httpx-1.7.6/doc/release_notes/1_6_2.md

@@ -0,0 +1,11 @@
+# 1.6.2
+
+## Bugfixes
+
+* revert of behaviour introduced in 1.6.1 around handling of `:ip_families` for name resolution.
+  * when no option is passed, do not assume no IPv6 connectivity if no available non-local IP is found, as the local network may still be reachable under `[::]`.
+* bail out connection if the tcp connection was established but the ssl session failed.
+  * when alpn negotiation succeeded, this could still initialize the HTTP/2 connection and put bytes in the buffer, which would cause a busy loop trying to write to a non-open socket.
+* datadog: fix initialization of spans in non-connection related errors
+  * past code was relying on the error being around DNS, but other errors could pop; the fix was moving the init time setup early to the session, when a request is first passed ot the associated connection.
+  * it can also fail earlier, so provide a workaround for that as well.

data/vendor/bundle/ruby/3.3.0/gems/httpx-1.7.6/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/3.3.0/gems/httpx-1.7.6/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/3.3.0/gems/httpx-1.7.6/doc/release_notes/1_7_1.md

@@ -0,0 +1,21 @@
+# 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/3.3.0/gems/httpx-1.7.6/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.