alogram_payrisk 0.2.9

data/vendor/bundle/ruby/3.3.0/gems/httpx-1.7.6/LICENSE.txt

@@ -0,0 +1,191 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        https://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2013-2017 Docker, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       https://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/vendor/bundle/ruby/3.3.0/gems/httpx-1.7.6/README.md

@@ -0,0 +1,164 @@
+# HTTPX: A Ruby HTTP library for tomorrow... and beyond!
+
+[![Gem Version](https://badge.fury.io/rb/httpx.svg)](http://rubygems.org/gems/httpx)
+[![pipeline status](https://gitlab.com/os85/httpx/badges/master/pipeline.svg)](https://gitlab.com/os85/httpx/pipelines?page=1&scope=all&ref=master)
+[![coverage report](https://gitlab.com/os85/httpx/badges/master/coverage.svg?job=coverage)](https://os85.gitlab.io/httpx/coverage/#_AllFiles)
+
+HTTPX is an HTTP client library for the Ruby programming language.
+
+Among its features, it supports:
+
+* HTTP/2 and HTTP/1.x protocol versions
+* Concurrent requests by default
+* Simple and chainable API
+* Proxy Support (HTTP(S), Socks4/4a/5)
+* Simple Timeout System
+* Lightweight by default (require what you need)
+
+And also:
+
+* Compression (gzip, deflate, brotli)
+* Streaming Requests
+* Auth (Basic Auth, Digest Auth, NTLM)
+* Expect 100-continue
+* Multipart Requests
+* Advanced Cookie handling
+* HTTP/2 Server Push
+* HTTP/1.1 Upgrade (support for "h2c", "h2")
+* Automatic follow redirects
+* GRPC
+* WebDAV
+* Circuit Breaker
+* HTTP-based response cache
+* International Domain Names
+
+## How
+
+Here are some simple examples:
+
+```ruby
+HTTPX.get("https://nghttp2.org").to_s #=> "<!DOCT...."
+```
+
+And that's the simplest one there is. But you can also do:
+
+```ruby
+HTTPX.post("http://example.com", form: { user: "john", password: "pass" })
+
+http = HTTPX.with(headers: { "x-my-name" => "joe" })
+File.open("path/to/file") do |file|
+  http.patch("http://example.com/file", body: file) # request body is streamed
+end
+```
+
+If you want to do some more things with the response, you can get an `HTTPX::Response`:
+
+```ruby
+response = HTTPX.get("https://nghttp2.org")
+puts response.status #=> 200
+body = response.body
+puts body #=> #<HTTPX::Response ...
+```
+
+You can also send as many requests as you want simultaneously:
+
+```ruby
+page1, page2, page3 = HTTPX.get("https://news.ycombinator.com/news", "https://news.ycombinator.com/news?p=2", "https://news.ycombinator.com/news?p=3")
+```
+
+## Installation
+
+Add this line to your Gemfile:
+
+```ruby
+gem "httpx"
+```
+
+or install it in your system:
+
+```
+> gem install httpx
+```
+
+and then just require it in your program:
+
+```ruby
+require "httpx"
+```
+
+## What makes it the best ruby HTTP client
+
+
+### Concurrency, HTTP/2 support
+
+`httpx` supports HTTP/2 (for "https" requests, it'll automatically do ALPN negotiation). However if the server supports HTTP/1.1, it will use HTTP pipelining, falling back to 1 request at a time if the server doesn't support it either (and it'll use Keep-Alive connections, unless the server does not support).
+
+If you passed multiple URIs, it'll perform all of the requests concurrently, by mulitplexing on the necessary sockets (and it'll batch requests to the same socket when the origin is the same):
+
+```ruby
+HTTPX.get(
+  "https://news.ycombinator.com/news",
+  "https://news.ycombinator.com/news?p=2",
+  "https://google.com/q=me"
+) # first two requests will be multiplexed on the same socket.
+```
+
+### Clean API
+
+`httpx` builds all functions around the `HTTPX` module, so that all calls can compose of each other. Here are a few examples:
+
+```ruby
+response = HTTPX.get("https://www.google.com", params: { q: "me" })
+response = HTTPX.post("https://www.nghttp2.org/httpbin/post", form: { name: "John", age: "22" })
+response = HTTPX.plugin(:basic_auth)
+                .basic_auth("user", "pass")
+                .get("https://www.google.com")
+
+# more complex client objects can be cached, and are thread-safe
+http = HTTPX.plugin(:expect).with(headers: { "x-pvt-token" => "TOKEN" })
+http.get("https://example.com") # the above options will apply
+http.post("https://example2.com", form: { name: "John", age: "22" }) # same, plus the form POST body
+```
+
+### Lightweight
+
+It ships with most features published as a plugin, making vanilla `httpx` lightweight and dependency-free, while allowing you to "pay for what you use"
+
+The plugin system is similar to the ones used by [sequel](https://github.com/jeremyevans/sequel), [roda](https://github.com/jeremyevans/roda) or [shrine](https://github.com/shrinerb/shrine).
+
+### Advanced DNS features
+
+`HTTPX` ships with custom DNS resolver implementations, including a native Happy Eyeballs resolver implementation, and a DNS-over-HTTPS resolver.
+
+## User-driven test suite
+
+The test suite runs against [httpbin proxied over nghttp2](https://nghttp2.org/httpbin/), so actual requests are performed during tests.
+
+## Supported Rubies
+
+All Rubies greater or equal to 2.7, and always latest JRuby and Truffleruby.
+
+**Note**: This gem is tested against all latest patch versions, i.e. if you're using 3.3.0 and you experience some issue, please test it against 3.3.$latest before creating an issue.
+
+## Resources
+|               |                                                        |
+| ------------- | ------------------------------------------------------ |
+| Website       | https://honeyryderchuck.gitlab.io/httpx/               |
+| Documentation | https://honeyryderchuck.gitlab.io/httpx/rdoc/          |
+| Wiki          | https://honeyryderchuck.gitlab.io/httpx/wiki/home.html |
+| CI            | https://gitlab.com/os85/httpx/pipelines                |
+| Rubygems      | https://rubygems.org/gems/httpx                        |
+
+## Caveats
+
+## Versioning Policy
+
+`httpx` follows Semantic Versioning.
+
+## Contributing
+
+* Discuss your contribution in an issue
+* Fork it
+* Make your changes, add some tests (follow the instructions from [here](test/README.md))
+* Open a Merge Request (that's Pull Request in Github-ish)
+* Wait for feedback

data/vendor/bundle/ruby/3.3.0/gems/httpx-1.7.6/doc/release_notes/0_0_1.md

@@ -0,0 +1,7 @@
+# Genesis Release
+
+This is the first release of `httpx`.
+
+It accomplishes all the API and feature goals necessary to its first use, which is testing server implementations.
+
+From here on, the sky is the limit. 

data/vendor/bundle/ruby/3.3.0/gems/httpx-1.7.6/doc/release_notes/0_0_2.md

@@ -0,0 +1,9 @@
+# 0.0.2
+
+* Hot-Fixed a flaw from the first version which was breaking https calls (SNI was broken).
+
+* Added a few test hackernews scraping scripts, which will be used for trouble-shooting/benchmarking.
+
+* Refactored/Fixed closing connections (HTTP/2 connections were buffering but not sending the GOAWAY frame)
+
+

data/vendor/bundle/ruby/3.3.0/gems/httpx-1.7.6/doc/release_notes/0_0_3.md

@@ -0,0 +1,9 @@
+# 0.0.3
+
+* Added `HTTPX::Response#raise_for_status`. If there was an error response, it will raise it's exception. If the HTTP response has a 4xx or 5xx error, it will raise an `HTTPX::HTTPError` exception (this feature was inspired by a similar feature in python requests library).
+
+* Added `HTTPX::Client#wrap`, which allows to use the client inside a block and keep connections open, without resorting to the initializer only.
+
+* TCP connection establishment errors are now wrapped in error responses, like other possible errors.
+
+* SSL non-blocking connection API is now in use (it was previously using the blocking connect API, and was breaking the hackernews script from time to time. Now I'm looking at you, DNS).

data/vendor/bundle/ruby/3.3.0/gems/httpx-1.7.6/doc/release_notes/0_0_4.md

@@ -0,0 +1,7 @@
+# 0.0.4
+
+* Added ANSI coloring to the debugging output (when in TTY mode).
+
+* `HTTPX::HTTPError` exceptions now carry the full response object, instead of just the status (so the user can inspect the body and headers if it so desires).
+
+* Fixed a bug related with HTTP/1 multiple requests on a domain which closed connections not being able to open a new socket to the domain.

data/vendor/bundle/ruby/3.3.0/gems/httpx-1.7.6/doc/release_notes/0_0_5.md

@@ -0,0 +1,5 @@
+# 0.0.5
+
+* Fixed HTTP/1 pipelining (it's working again).
+
+* Fixed multiple requests to the same domain over https (SSL sockets weren't being properly reopened).

data/vendor/bundle/ruby/3.3.0/gems/httpx-1.7.6/doc/release_notes/0_10_0.md

@@ -0,0 +1,66 @@
+# 0.10.0
+
+## Features
+
+### Streaming Requests
+
+The `stream` plugin adds functionality to handle long-lived stream responses, such as the Twitter Streaming API:
+
+```ruby
+http = HTTPX.plugin(:stream)
+
+http.get(stream_api_endpoint, stream: true).each_line do |line|
+  payload = JSON.parse(line)
+  # do smth with this
+end
+```
+
+https://gitlab.com/os85/httpx/-/wikis/Stream
+
+### Rate Limiter
+
+The `rate_limiter` plugin adds functionality for automatically hooking into rate-limiting responses coming from the server, and waits-and-retries them according to what the server advertises.
+
+```ruby
+HTTPX.plugin(:rate_limiter).get(rate_limited_api_endpoint)
+# => 429 Too Many Requests .... Retry-After: 3
+# waits 3 seconds before retrying
+```
+
+https://gitlab.com/os85/httpx/-/wikis/Rate-Limiter
+
+### Ruby 3
+
+This release is the first testing against and targeting Ruby 3 and some of the new features.
+
+It ships with RBS signatures for all of the client-facing APIs. There's non 100% typinng coverage yet, but I'm gradually (pun intended) working on it.
+
+
+## Improvements
+
+### IDN support
+
+Requests where the domains are formed by non-ASCII characters, are now supported (if you're using ruby 2.3 or more recent).
+
+```ruby
+HTTPX.get("http://bücher.ch") # it works!
+```
+
+### cookies plugin full implementation
+
+
+The `cookies` plugin is now independent of 3rd-party gems. The motivation for this was that `http-cookie` was dependent of both `domain_name` and `unf` gems, which are currently unusable in ruby 3, and haven't received any update in the last 3 years.
+
+The implementation is still compliant with RFC6265, and all of the features provided in earlier versions were ported, exceptwhen loading the cookie jar stored in a Netscape-format file or Mozilla sqlite database, which were not documented for `httpx` anyway, and I considered too niche to backport. If you feel `httpx` should support those, do let me know.
+
+Some code from these gems, including the ruby punycode implementation, is now part of the source tree, along with its licenses and attribution mentions.
+
+## Bugfixes
+
+
+Several edge-case bugs have been fixed solely by the integration of RBS runtime type checking, including some bugs around closing a connection pool that can cause loops.
+
+
+## Regressions
+
+`HTTPX::ErrorResponse`'s methods `#headers` and `#reason` were removed, as they didn't provide much value. Consider calling `#raise_for_status` or checking the API (`is_a?(HTTPX::ErrorResponse)` or `respond_to?(:error)` are strategies for this).

data/vendor/bundle/ruby/3.3.0/gems/httpx-1.7.6/doc/release_notes/0_10_1.md

@@ -0,0 +1,37 @@
+# 0.10.1
+
+## Improvements
+
+### URL-encoded nested params
+
+url encoder now supports nested params, which is a standard of rack-based frameworks:
+
+```ruby
+HTTPX.post("https://httpbin.org/post", form: { a: { b: 1 }, c: [2, 3] })
+# a[b]=1&c[]=2&c[]=3
+```
+
+This encoding scheme is now the standard for URL-encoded request bodies, query params, and `:multipart` plugin requests.
+
+### Socks4 IPv6 addresses
+
+HTTPX supports IPv6 Socks4 proxies now. This support is restricted to rubies where `IPAddr#hton` is implemented though, so you are encouraged to upgrade.
+
+## More verbose HTTP Errors
+
+`HTTPX::Response#raise_for_status` was raising exceptions for client/server HTTP errors codes (4xx/5xx). However, only the status code was part of the message.
+
+From now on, both headers and the responnse payload will also appear, so expected more verbosity, but also more meaningful information.
+
+## Bugfixes
+
+* HTTP/2 and HTTP/1.1 exhausted connections now get properly migrated into a new connection;
+* HTTP/2 421 responses will now correctly migrate the connection and pending requests to HTTP/1.1 (a hanging loop was being caused);
+* HTTP/2 connection failed with a GOAWAY settings timeout will now return error responses (instead of hanging indefinitely);
+* Non-IP proxy name-resolving errors will now move on to the next available proxy in the list (instead of hanging indefinitely);
+* Non-IP DNS resolve errors for `native` and `https` variants will now return the appropriate error response (instead of hanging indefinitely);
+
+## Chore
+
+* `HTTPX.plugins` is now officially deprecated (use `HTTPX.plugin` instead);
+

data/vendor/bundle/ruby/3.3.0/gems/httpx-1.7.6/doc/release_notes/0_10_2.md

@@ -0,0 +1,5 @@
+# 0.10.2
+
+## Bugfixes
+
+Support for nested params in multipart forms introduced a bug where top-level params weren't being spread out correctly in the request body.

data/vendor/bundle/ruby/3.3.0/gems/httpx-1.7.6/doc/release_notes/0_11_0.md

@@ -0,0 +1,74 @@
+# 0.11.0
+
+## Features
+
+### Webmock Adapter
+
+`httpx` can now be integrated with `webmock`, a popular HTTP requests stubbing library.
+
+```ruby
+# minitest
+require "webmock/minitest"
+require "httpx/adapters/webmock"
+
+# in rspec
+require "webmock/rspec"
+require "httpx/adapters/webmock"
+
+# and now you're free for mocking
+WebMock.enable!
+stub_http_request(:get, "https://www.google.com").and_return(status: 200, body: "here's google")
+
+```
+
+Read more about it in the [webmock integration documentation](https://honeyryderchuck.gitlab.io/httpx/wiki/Webmock-Adapter).
+
+### Datadog Adapter
+
+`httpx` ships with integration for [ddtrace, datadog's official tracing client](https://github.com/DataDog/dd-trace-rb). You just need to initialize it the following way:
+
+```ruby
+require "ddtrace"
+require "httpx/adapters/datadog"
+
+Datadog.configure do |c|
+  c.use :httpx
+end
+```
+
+A trace will be emitted for every request, so this should be an interesting visualization if concurrent requests are sent.
+
+Customization options and traces are similar to what [the net-http adapter provides](https://docs.datadoghq.com/tracing/setup_overview/setup/ruby/#nethttp).
+
+Read more about it in the [datadog integration documentation](https://honeyryderchuck.gitlab.io/httpx/wiki/Datadog-Adapter).
+
+## Improvements
+
+### Own multipart request encoder
+
+`httpx` now ships with its own multipart formdata encoder, and does not rely on `http-form_data` anymore:
+
+```ruby
+HTTPX.plugin(:multipart).post(uri, form: {file: File.new("path/to/file")})
+```
+
+Read more about it in the [multipart plugin documentation](https://honeyryderchuck.gitlab.io/httpx/wiki/Multipart-Uploads), including also about why this was made.
+
+### Expect Plugin
+
+The `:expect` plugin now works reliably when the server does not support the `expect: 100-continue` header, i.e. it'll upload the body after a certain timeout. Building onn that, two behaviours are now implemented:
+
+* A cache of domains which did not respond to the `expect` header is now kept, so that subsequent requests can skip the timeout and immediately upload the payload.
+* If the "100 Continue" response arrives **after** the timeout expired and the body has been uploaded, the domain is removed from the cache, and subsequent requests will send the `expect` header.
+
+### SNI/Host options
+
+Some extension of the API was applied in order to support custom TLS negotiation parameters. You can now pass `:hostname` under the `:ssl` options, and this will be used for the SNI part of the TLS negotiation. This is useful in scenarios where a proxy certificate doesn't apply for the host one wants to send the request to:
+
+```ruby
+response = session.get(proxy_ip, headers: { "host" => upstream_hostname }, ssl: { hostname: sni_hostname }
+```
+
+## Bugfixes
+
+A default 5 second timeout is in-place when using the DNS `:system` resolver, as it was found out that. when using the `resolv` library, the DNS query will not be retried otherwise. You can change this setting py passing `resolver_options: { timeouts: ANOTHER_TIMEOUT}`. In the future, this may become another timeout option, however.

data/vendor/bundle/ruby/3.3.0/gems/httpx-1.7.6/doc/release_notes/0_11_1.md

@@ -0,0 +1,5 @@
+# 0.11.1
+
+## Bugfixes
+
+Fixed a bug related to the `:compression` plugin trying to process a last empty DATA frame from an HTTP/2 response, after it had been closed.

data/vendor/bundle/ruby/3.3.0/gems/httpx-1.7.6/doc/release_notes/0_11_2.md

@@ -0,0 +1,5 @@
+# 0.11.2
+
+## Bugfixes
+
+The `:cookies` plugin wasn't able to parse `Expires` values, as it was using `Time.httpdate` to parse timestamps, which is RFC 2616-compliant, whereas cookies datetime values need to be RFC 6265-compliant.

data/vendor/bundle/ruby/3.3.0/gems/httpx-1.7.6/doc/release_notes/0_11_3.md

@@ -0,0 +1,5 @@
+# 0.11.3
+
+## Bugfixes
+
+`EOFError` was being thrown when HTTP/1.1 non-chunked responses which don't contain a "content-length" header. The RFC mandates that the socket should be consumed until the server closes it, so a patch was implemented, to return the available response in such cases.

data/vendor/bundle/ruby/3.3.0/gems/httpx-1.7.6/doc/release_notes/0_12_0.md

@@ -0,0 +1,55 @@
+# 0.12.0
+
+## Features
+
+### AWS Sigv4 Authentication Plugin
+
+A new plugin, `:aws_sigv4`, is now shipped with `httpx`. It implements the [AWS Signature Version 4 request signing process](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html), a well documented way of authenticating requests to AWS services, which has since been adopted by other cloud providers, such as Google Cloud Storage.
+
+See how to use it here: https://gitlab.com/os85/httpx/-/wikis/AWS-Sigv4#sessionaws_sigv4_authentication
+
+For convenience, there's a derivative plugin, `:aws_sdk_authentication`, which builds on top of `:aws_sigv4`, and integrates with the `aws-sdk-core` gem, maintained by AWS, to resolve the authentication credentials (p.ex. if you support ephemeral access keys).
+
+See how to use it here: https://gitlab.com/os85/httpx/-/wikis/AWS-Sigv4#sessionaws_sdk_authentication
+
+Other FAQ: https://gitlab.com/os85/httpx/-/wikis/AWS-Sigv4#faqs
+
+### HTTP/2 support for JRuby
+
+`jruby-openssl` doesn't support ALPN protocol negotiation, nor are there plans to implement, which limited the seamless HTTP/2 usage in `httpx`. A new connection adapter was therefore added specifically for JRuby, where ssl/tls connections will be handled using ffi-based openssl bindings, provided you bundle `ffi-compiler` and `concurrent-ruby`, and install a TLS/1.2-compatible `openssl` package.
+
+See how to use it here: https://gitlab.com/os85/httpx/-/wikis/JRuby-Truffleruby-Other-Rubies#http2
+
+## Improvements
+
+
+### truffleruby support
+
+`httpx` supports and tests against `truffleruby` (known to run tests since v20.3, passing all tests since v21).
+
+### Performance
+
+Several optimizations were introduced:
+
+* Reduction in read/write system calls;
+* more usage of `String#byteslice` in parsing (instead of string mutation);
+* Avoid selection on connections with no outstanding requests;
+
+They all contributed to a massive performance improvement, itself reflected in test runs, which need half the time they used to to complete.
+
+### APIs
+
+* `HTTPX::ErrorResponse#to_s` now uses the exception full message, instead of just the backtrace.
+
+## Bugfixes
+
+* HTTP/2 stream protocol errors do not cause the process to hang (instead, error responnses are yielded);
+* Fixed body stream bugs on retries when error causing retry would happen mid-transfer;
+* Fixed `:multipart` plugin body rewind on retries to start the transfer from the beginning;
+* Fixed auto-load of  `:proxy` plugin when `HTTPS_PROXY` or `HTTP_PROXY` is set;
+* Errno::EPIPE errors mid transfer now cause `httpx` to read from the server and get the appropriate HTTP error response;
+* Make sure that all requests have an error responnse if the error happens early;
+* Fixed TCP handshake Errno::INPROGRESS handling inside TLS connnections, which was causing the process to hang in a high handshake contention scenario;
+* Do not call the event loop if there's nothing to listen on (the DoH resolver was being listened on even if there was nothing to be request);
+* Fixed double event registry for DoH resolvers;
+*