httpx 0.21.0 → 0.22.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c62cb1d027ee7e62770de459b00411614372578117ea56354df0d9114cf4397b
-  data.tar.gz: 18275725fc8adeac596f02f83f034dfcfe24a7e4c96ec34bc11400e8ca0e9567
+  metadata.gz: 4d5e3e33caae5726e0c7630721296abac27073ed1fc071a7bb8c9467a2b1b2e0
+  data.tar.gz: f4344aee8002ecbe64d6e3321e1ca9f18507e2fd70223890211e05ab15967479
 SHA512:
-  metadata.gz: 840bf59a4cbbb45d26a836ccd4060007470d380314b4aedea58e49cb434b050a8252f7db3823daf9c2dfdb5d54075215e4ee1216c80852afbb7abfd57e1dfea2
-  data.tar.gz: 35a666b92236240e8ccd09b1dc29a2ccf83061222b0511d35eee6fb7f3794dc737ca86ac9ca7d87ba01e03d8e648b07e6e52290b02b25674bd783b7f9d2cfbce
+  metadata.gz: 9c42940a7467f91f66779bdf26b83043fb99b17033d69cee7d7656946abc03a064f1b9952889b3c783b757429d5cc6d476575ff9ab347524738152f846c3ea91
+  data.tar.gz: 6199caed20de123a10af893a85c2657cc4b4bfb6645592a5155743e74a37ff754d3fcf404c8bb28582bead974b35c6f872d40d8b5ac77806bdc4b34992847e7a

data/README.md

@@ -1,8 +1,8 @@
 # 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/honeyryderchuck/httpx/badges/master/pipeline.svg)](https://gitlab.com/honeyryderchuck/httpx/pipelines?page=1&scope=all&ref=master)
-[![coverage report](https://gitlab.com/honeyryderchuck/httpx/badges/master/coverage.svg?job=coverage)](https://honeyryderchuck.gitlab.io/httpx/coverage/#_AllFiles)
+[![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.
 
@@ -19,13 +19,17 @@ And also:
 
 * Compression (gzip, deflate, brotli)
 * Streaming Requests
-* Authentication (Basic Auth, Digest Auth)
+* Authentication (Basic Auth, Digest Auth, NTLM)
 * Expect 100-continue
 * Multipart Requests
-* Cookies
+* Advanced Cookie handling
 * HTTP/2 Server Push
-* H2C Upgrade
+* HTTP/1.1 Upgrade (support for "h2c", "h2")
 * Automatic follow redirects
+* GRPC
+* WebDAV
+* Circuit Breaker
+* HTTP-based response cache
 * International Domain Names
 
 ## How
@@ -36,7 +40,14 @@ Here are some simple examples:
 HTTPX.get("https://nghttp2.org").to_s #=> "<!DOCT...."
 ```
 
-And that's the simplest one there is.
+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" })
+http.patch(("http://example.com/file", body: File.open("path/to/file")) # request body is streamed
+```
 
 If you want to do some more things with the response, you can get an `HTTPX::Response`:
 
@@ -50,7 +61,7 @@ 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")
+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
@@ -73,43 +84,53 @@ and then just require it in your program:
 require "httpx"
 ```
 
-## Why Should I care?
+## What makes it the best ruby HTTP client
 
-In Ruby, HTTP client implementations are a known cheap commodity. Why this one?
 
-### Concurrency
+### Concurrency, HTTP/2 support
 
-This library supports HTTP/2 seamlessly (which means, if the request is secure, and the server support ALPN negotiation AND HTTP/2, the request will be made through HTTP/2). If you pass multiple URIs, and they can utilize the same connection, they will run concurrently in it.
+`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).
 
-However if the server supports HTTP/1.1, it will try to use HTTP pipelining, falling back to 1 request at a time if the server doesn't support it (if the server support Keep-Alive connections, it will reuse the same connection).
+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")
-response = HTTPX.post("https://www.nghttp2.org/httpbin/post", params: {name: "John", age: "22"})
+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_authentication)
                 .basic_authentication("user", "pass")
                 .get("https://www.google.com")
+
+# more complex client objects can be cached, and are thread-safe
+http = HTTPX.plugin(:compression).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 a plugin system similar to the ones used by [sequel](https://github.com/jeremyevans/sequel), [roda](https://github.com/jeremyevans/roda) or [shrine](https://github.com/janko-m/shrine).
-
-It means that it loads the bare minimum to perform requests, and the user has to explicitly load the plugins, in order to get the features he/she needs.
+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"
 
-It also means that it ships with the minimum amount of dependencies.
+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/janko-m/shrine).
 
-### DNS-over-HTTPS
+### Advanced DNS features
 
-`HTTPX` ships with custom DNS resolver implementations, including a DNS-over-HTTPS resolver.
+`HTTPX` ships with custom DNS resolver implementations, including a native Happy Eyeballs resolver immplementation, and a DNS-over-HTTPS resolver.
 
-## Easy to test
+## User-driven test suite
 
-The test suite runs against [httpbin proxied over nghttp2](https://nghttp2.org/httpbin/), so there are no mocking/stubbing false positives. The test suite uses [minitest](https://github.com/seattlerb/minitest), but its matchers usage is (almost) limited to `#assert` (`assert` is all you need).
+The test suite runs against [httpbin proxied over nghttp2](https://nghttp2.org/httpbin/), so actual requests are performed during tests.
 
 ## Supported Rubies
 
@@ -118,27 +139,24 @@ All Rubies greater or equal to 2.1, and always latest JRuby and Truffleruby.
 **Note**: This gem is tested against all latest patch versions, i.e. if you're using 2.2.0 and you experience some issue, please test it against 2.2.10 (latest patch version of 2.2) before creating an issue.
 
 ## Resources
-|               |                                                     |
-| ------------- | --------------------------------------------------- |
-| Website       | https://honeyryderchuck.gitlab.io/httpx/            |
-| Documentation | https://honeyryderchuck.gitlab.io/httpx/rdoc/       |
-| Wiki          | https://gitlab.com/honeyryderchuck/httpx/wikis/home |
-| CI            | https://gitlab.com/honeyryderchuck/httpx/pipelines  |
+|               |                                                        |
+| ------------- | ------------------------------------------------------ |
+| 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
 
 ### ALPN support
 
-`HTTPS` TLS backend is ruby's own `openssl` gem.
-
-If your requirement is to run requests over HTTP/2 and TLS, make sure you run a version of the gem which compiles OpenSSL 1.0.2 (Ruby 2.3 and higher are guaranteed to).
-
-In order to use HTTP/2 under JRuby, [check this link](https://gitlab.com/honeyryderchuck/httpx/-/wikis/JRuby-Truffleruby-Other-Rubies) to know what to do.
+ALPN negotiation is required for "auto" HTTP/2 "https" requests. This is available in ruby since version 2.3 .
 
 ### Known bugs
 
-* Doesn't work with ruby 2.4.0 for Windows (see [#36](https://gitlab.com/honeyryderchuck/httpx/issues/36)).
-* Using `total_timeout` along with the `:persistent` plugin [does not work as you might expect](https://gitlab.com/honeyryderchuck/httpx/-/wikis/Timeouts#total_timeout).
+* Doesn't work with ruby 2.4.0 for Windows (see [#36](https://gitlab.com/os85/httpx/issues/36)).
+* Using `total_timeout` along with the `:persistent` plugin [does not work as you might expect](https://gitlab.com/os85/httpx/-/wikis/Timeouts#total_timeout).
 
 ## Versioning Policy
 

data/doc/release_notes/0_10_0.md

@@ -15,7 +15,7 @@ http.get(stream_api_endpoint, stream: true).each_line do |line|
 end
 ```
 
-https://gitlab.com/honeyryderchuck/httpx/-/wikis/Stream
+https://gitlab.com/os85/httpx/-/wikis/Stream
 
 ### Rate Limiter
 
@@ -27,7 +27,7 @@ HTTPX.plugin(:rate_limiter).get(rate_limited_api_endpoint)
 # waits 3 seconds before retrying
 ```
 
-https://gitlab.com/honeyryderchuck/httpx/-/wikis/Rate-Limiter
+https://gitlab.com/os85/httpx/-/wikis/Rate-Limiter
 
 ### Ruby 3
 

data/doc/release_notes/0_11_0.md

@@ -21,7 +21,7 @@ stub_http_request(:get, "https://www.google.com").and_return(status: 200, body:
 
 ```
 
-Read more about it in the [webmock integration documentation](https://honeyryderchuck.gitlab.io/httpx/wiki/Webmock-Adapter).
+Read more about it in the [webmock integration documentation](https://os85.gitlab.io/httpx/wiki/Webmock-Adapter).
 
 ### Datadog Adapter
 
@@ -40,7 +40,7 @@ A trace will be emitted for every request, so this should be an interesting visu
 
 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).
+Read more about it in the [datadog integration documentation](https://os85.gitlab.io/httpx/wiki/Datadog-Adapter).
 
 ## Improvements
 
@@ -52,7 +52,7 @@ Read more about it in the [datadog integration documentation](https://honeyryder
 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.
+Read more about it in the [multipart plugin documentation](https://os85.gitlab.io/httpx/wiki/Multipart-Uploads), including also about why this was made.
 
 ### Expect Plugin
 
@@ -72,5 +72,3 @@ response = session.get(proxy_ip, headers: { "host" => upstream_hostname }, ssl:
 ## 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/doc/release_notes/0_12_0.md

@@ -6,19 +6,19 @@
 
 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/honeyryderchuck/httpx/-/wikis/AWS-Sigv4#sessionaws_sigv4_authentication
+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/honeyryderchuck/httpx/-/wikis/AWS-Sigv4#sessionaws_sdk_authentication
+See how to use it here: https://gitlab.com/os85/httpx/-/wikis/AWS-Sigv4#sessionaws_sdk_authentication
 
-Other FAQ: https://gitlab.com/honeyryderchuck/httpx/-/wikis/AWS-Sigv4#faqs
+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/honeyryderchuck/httpx/-/wikis/JRuby-Truffleruby-Other-Rubies#http2
+See how to use it here: https://gitlab.com/os85/httpx/-/wikis/JRuby-Truffleruby-Other-Rubies#http2
 
 ## Improvements
 
@@ -52,4 +52,4 @@ They all contributed to a massive performance improvement, itself reflected in t
 * 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;
-* 
+*

data/doc/release_notes/0_13_0.md

@@ -4,9 +4,9 @@
 
 ### Upgrade plugin
 
-A new plugin, `:upgrade`, is now available. This plugin allows one to "hook" on HTTP/1.1's protocol upgrade mechanism (see: https://developer.mozilla.org/en-US/docs/Web/HTTP/Protocol_upgrade_mechanism), which is the mechanism that browsers use to initiate websockets (there is an example of how to use `httpx` to start a websocket client connection [in the tests](https://gitlab.com/honeyryderchuck/httpx/-/blob/master/test/support/requests/plugins/upgrade.rb))
+A new plugin, `:upgrade`, is now available. This plugin allows one to "hook" on HTTP/1.1's protocol upgrade mechanism (see: https://developer.mozilla.org/en-US/docs/Web/HTTP/Protocol_upgrade_mechanism), which is the mechanism that browsers use to initiate websockets (there is an example of how to use `httpx` to start a websocket client connection [in the tests](https://gitlab.com/os85/httpx/-/blob/master/test/support/requests/plugins/upgrade.rb))
 
-You can read more about the `:upgrade` plugin in the [wiki](https://honeyryderchuck.gitlab.io/httpx/wiki/Connection-Upgrade).
+You can read more about the `:upgrade` plugin in the [wiki](https://os85.gitlab.io/httpx/wiki/Connection-Upgrade).
 
 It's the basis of two plugins:
 
@@ -14,13 +14,13 @@ It's the basis of two plugins:
 
 This plugin was been rewritten on top of the `:upgrade` plugin, and handles upgrading a plaintext (non-"https") HTTP/1.1 connection, into an HTTP/2 connection.
 
-https://honeyryderchuck.gitlab.io/httpx/wiki/Connection-Upgrade#h2c
+https://os85.gitlab.io/httpx/wiki/Connection-Upgrade#h2c
 
 #### `:upgrade/h2`
 
 This plugin handles when a server responds to a request with an `Upgrade: h2` header, does the following requests to the same origin via HTTP/2 prior knowledge (bypassing the necessity for ALPN negotiation, which is the whole point of the feature).
 
-https://honeyryderchuck.gitlab.io/httpx/wiki/Connection-Upgrade#h2
+https://os85.gitlab.io/httpx/wiki/Connection-Upgrade#h2
 
 ### `:addresses` option
 

data/doc/release_notes/0_14_0.md

@@ -17,7 +17,7 @@ helloworld_svc = helloworld_stub.rpc(:SayHello, HelloRequest, HelloReply)
 result = helloworld_svc.say_hello(HelloRequest.new(name: "Jack")) #=> HelloReply: "Hello Jack"
 ```
 
-You can read more about the `:grpc` plugin in the [wiki](https://honeyryderchuck.gitlab.io/httpx/wiki/GRPC).
+You can read more about the `:grpc` plugin in the [wiki](https://os85.gitlab.io/httpx/wiki/GRPC).
 
 ### :origin
 
@@ -37,7 +37,7 @@ httpbin.get("/httpbin/get") #=> #<Response:5420 HTTP/2.0 @status=200 ....
 * setting an unexpected option will now raise an `HTTPX::Error` with an helpful message, instead of a confusing `NoMethodError`:
 
 ```ruby
-HTTPX.with(foo: "bar") 
+HTTPX.with(foo: "bar")
 # before
 #=> NoMethodError
 # after

data/doc/release_notes/0_16_0.md

@@ -16,7 +16,7 @@ response.body.to_s #=> ""
 
 The justification for this behaviour probably had to do with avoiding keeping huge payloads around, but it got a bit lost in git history. It became a feature, not a bug.
 
-However, I got an [issue report](https://gitlab.com/honeyryderchuck/httpx/-/issues/143) that made me change my mind about this behaviour (tl;dr: it broke pattern matching when matching against response bodies more than once).
+However, I got an [issue report](https://gitlab.com/os85/httpx/-/issues/143) that made me change my mind about this behaviour (tl;dr: it broke pattern matching when matching against response bodies more than once).
 
 So now, you can call `.to_s` how many times you want!
 
@@ -62,7 +62,7 @@ stub.get_feature(# ...
 
 ### OptionsMethods for plugins
 
-https://gitlab.com/honeyryderchuck/httpx/-/wikis/Custom-Plugins
+https://gitlab.com/os85/httpx/-/wikis/Custom-Plugins
 
 You can now define an `OptionsMethods` module under your custom plugin to define your own methods. The tl;dr is, that, given the following module below, a new `:bar` option will be available (and the method will be used to set it):
 
@@ -80,7 +80,7 @@ HTTPX.plugin(CustomPlugin).with(bar: 2)
 
 The behaviour of the cookies jar from the `:cookies` plugin was a bit unpredictable in certain conditions, for instance if a "Cookie" header would be passed directly via `.with(headers: {"Cookie" => "a=1"})` and there'd be a value for it already (in same cases, it'd be fully ignored). This would even get worse, if the session had a jar, and a specific set of cookies would be passed to a request(i.e.: `session_with_cookies.get("http://url.get", headers: {"Cookies" => "..."}`).
 
-The behaviour was fixed, and is now specced under https://gitlab.com/honeyryderchuck/httpx/-/blob/master/test/support/requests/plugins/cookies.rb .
+The behaviour was fixed, and is now specced under https://gitlab.com/os85/httpx/-/blob/master/test/support/requests/plugins/cookies.rb .
 
 ## Bugfixes
 

data/doc/release_notes/0_17_0.md

@@ -4,7 +4,7 @@
 
 ### Response mime type decoders (#json, #form)
 
-https://gitlab.com/honeyryderchuck/httpx/-/wikis/Response-Handling#response-decoding
+https://gitlab.com/os85/httpx/-/wikis/Response-Handling#response-decoding
 
 Two new methods, `#json` and `#form`, were added to `HTTPX::Response`. As the name implies, they'll decode the raw payload into ruby objects you can work with.
 

data/doc/release_notes/0_18_0.md

@@ -4,7 +4,7 @@
 
 ### Response Cache
 
-https://gitlab.com/honeyryderchuck/httpx/-/wikis/Response-Cache
+https://gitlab.com/os85/httpx/-/wikis/Response-Cache
 
 The `:response_cache` plugin handles transparent usage of HTTP caching and conditional requests to improve performance and bandwidth usage.
 
@@ -22,7 +22,7 @@ r1.body == r2.body #=> true
 
 On the `:retries` plugin, jitter calculation is now applied to the value in seconds defined by user after which a request should be retried (i.e. if `:retry_after` option is set to `2`, the retry interval may be `1.5422312` seconds, for example). This is important to avoid cases of synchronized "thundering herd", where server rejects requests, but they all get retried at the same time because the retry interval is exactly the same.
 
-You can override the jitter calculation function by using the [:retry_jitter](https://gitlab.com/honeyryderchuck/httpx/-/wikis/Retries#retry_jitter) option:
+You can override the jitter calculation function by using the [:retry_jitter](https://gitlab.com/os85/httpx/-/wikis/Retries#retry_jitter) option:
 
 ```ruby
 HTTPX.plugin(:retries, retry_after: 2, retry_jitter: ->(interval) { interval + rand }) # interval is 3
@@ -44,7 +44,7 @@ end
 
 ## Improvements
 
-* `webmock` adapter: added support for "stub_http_request#to_timeout" (https://gitlab.com/honeyryderchuck/httpx/-/merge_requests/165).
+* `webmock` adapter: added support for "stub_http_request#to_timeout" (https://gitlab.com/os85/httpx/-/merge_requests/165).
 
 ## timers not a dependency
 
@@ -57,7 +57,7 @@ The functionality provided by the `timers` gem was replaced by a simpler custom
 
 ## Bugfixes
 
-* Fixed Error class declaration on response decoders when mime type is invalid (https://gitlab.com/honeyryderchuck/httpx/-/merge_requests/166).
+* Fixed Error class declaration on response decoders when mime type is invalid (https://gitlab.com/os85/httpx/-/merge_requests/166).
 * `ErrorResponse#to_s` now removes ANSI escape sequences from error backtraces.
 * Persistent connections were kept around both in the pool and in the selector; the first is necessary, but the second caused busy loop scenarios all over; they are now removed when no requests are being handled.
 * Connections which failed connection handshake were removed from the pool, but not from the selector list, causing busy loop scenarios in a few cases; this has been fixed.

data/doc/release_notes/0_18_2.md

@@ -7,4 +7,4 @@
 
 ## Chore
 
-The quirk of using the `:persistent` plugin with `:total_timeout` has been documented: https://gitlab.com/honeyryderchuck/httpx/-/wikis/Timeouts#total_timeout.
+The quirk of using the `:persistent` plugin with `:total_timeout` has been documented: https://gitlab.com/os85/httpx/-/wikis/Timeouts#total_timeout.

data/doc/release_notes/0_19_0.md

@@ -28,7 +28,7 @@ Connection coalescing has also been enabled for proxied connections (also `CONNE
 
 ### curl-to-httpx
 
-widget in [project website](https://honeyryderchuck.gitlab.io/httpx/) to turn curl commands into the equivalent `httpx` code.
+widget in [project website](https://os85.gitlab.io/httpx/) to turn curl commands into the equivalent `httpx` code.
 
 ## Bugfixes
 

data/doc/release_notes/0_20_0.md

@@ -4,7 +4,7 @@
 
 ### Sentry integration
 
-Documentation: https://gitlab.com/honeyryderchuck/httpx/-/wikis/Sentry-Adapter
+Documentation: https://gitlab.com/os85/httpx/-/wikis/Sentry-Adapter
 
 `httpx` ships with integration for `sentry-ruby` to provide HTTP request specific breadcrumbs and tracing. It can be enabled via:
 

data/doc/release_notes/0_21_0.md

@@ -4,12 +4,12 @@
 
 ### `:write_timeout`, `:read_timeout` and `:request_timeout`
 
-https://gitlab.com/honeyryderchuck/httpx/-/wikis/Timeouts
+https://gitlab.com/os85/httpx/-/wikis/Timeouts
 
 The following timeouts are now supported:
 
 * `:write_timeout`: total time (in seconds) to write a request to the server;
-* `:read_timeout`: total time (in seconds) to read aa response from the server;
+* `:read_timeout`: total time (in seconds) to read a response from the server;
 * `:request_timeout`: tracks both of the above (time to write the request and read a response);
 
 ```ruby
@@ -22,10 +22,12 @@ None of them has a default value, in order not to break integrations, but that'l
 
 ### Circuit Breaker plugin
 
-https://gitlab.com/honeyryderchuck/httpx/-/wikis/Circuit-Breaker
+https://gitlab.com/os85/httpx/-/wikis/Circuit-Breaker
 
 The `:circuit_breaker` plugin wraps around errors happening when performing HTTP requests, and support options for setting maximum number of attempts before circuit opens (`:circuit_breaker_max_attempts`), period after which attempts should be reset (`:circuit_breaker_reset_attempts_in`), timespan until circuit half-opens (`circuit_breaker_break_in`), respective half-open drip rate (`:circuit_breaker_half_open_drip_rate`), and a callback to do your own check on whether a response has failed, in case you want HTTP level errors to be marked as failed attempts (`:circuit_breaker_break_on`).
 
+Read the wiki for more info about the defaults.
+
 ```ruby
 http = HTTPX.plugin(:circuit_breaker)
 # that's it!
@@ -34,7 +36,7 @@ http.get(...
 
 ### WebDAV plugin
 
-https://gitlab.com/honeyryderchuck/httpx/-/wikis/WebDav
+https://gitlab.com/os85/httpx/-/wikis/WebDav
 
 The `:webdav` introduces some "convenience" methods to perform common WebDAV operations.
 
@@ -49,7 +51,7 @@ res = webdav.copy("/file.html", "/newdir/copy.html")
 
 ### XML transcoder, `:xml` option and `response.xml`
 
-A new transcoder was added fot the XML mime type, which requires `"nokogiri"` to be installed; it can both serialize Nokogiri nodes in a request, and parse response content into nokogiri nodes:
+A new transcoder was added fot the XML mime type, which requires `"nokogiri"` to be installed. It can both serialize Nokogiri nodes in a request, and parse response content into nokogiri nodes:
 
 ```ruby
 response = HTTPX.post("https://xml-server.com", xml: Nokogiri::XML("<xml ..."))

data/doc/release_notes/0_21_1.md

@@ -0,0 +1,12 @@
+# 0.21.1
+
+## Bugfixes
+
+* fix: protecting tcp connect phase against low-level syscall errors
+  * such as network unreachable, which can happen if connectivity is lost meanwhile.
+* native resolver: fix for nameserver switch not happening in case of DNS timeout.
+  * when more than a nameserver was advertised by the system.
+
+## Chore
+
+* Removing usage of deprecated `Random::DEFAULT.rand` (using `Random.rand` instead)-

data/doc/release_notes/0_22_0.md

@@ -0,0 +1,13 @@
+# 0.22.0
+
+## Improvements
+
+### Happy Eyeballs v2 finalized
+
+Until now, httpx was issuing concurrent DNS requests, but it'd only start connecting to the first, and then on the following by the right order, but sequentially.
+
+`httpx` will now establish connections concurrently to both IPv6 and IPv4 addresses of a given domain; the first one to succeed terminates the other. Successful connection means completion of both TCP and TLS (when applicable) handshakes.
+
+### HTTPX::Response::Body#encoding
+
+A new method, `#encoding`, can be called on response bodies. It'll return the encoding of the response payload.

data/doc/release_notes/0_22_1.md

@@ -0,0 +1,11 @@
+# 0.22.1
+
+## Bugfixes
+
+* `:retries` plugin: fix `HTTPX::Response#response to point to last possible response in the redirection chain.
+* `:stream` plugin: Make `HTTPX::Session#request` public (as it is inn the main class) .
+* return 100 responses if the request didn't specifically ask for "100-continue" negotiation (via the "expect" header).
+
+## Improvements
+
+Wrap low-level socket errors in a `HTTPX::ConnectionError` exception.

data/doc/release_notes/0_22_2.md

@@ -0,0 +1,5 @@
+# 0.22.2
+
+## Chore
+
+Checking response class before calling `.status`, as this was being called in some places on error responses, thereby triggering the deprecation warning.

data/doc/release_notes/0_22_3.md

@@ -0,0 +1,55 @@
+# 0.22.3
+
+## Features
+
+### HTTPX::Response::Body#filename
+
+A new method, `.filename` can be called on response bodies, to get the filename referenced by the server for the received payload (usually in the "Content-Disposition" header).
+
+```ruby
+response = HTTPX.get(url)
+response.raise_for_status
+filename = response.body.filename
+# you can do, for example:
+response.body.copy_to("/home/files/#{filename}")
+```
+
+## Improvements
+
+### Loading integrations by default
+
+Integrations will be loaded by default, as long as the dependency being integrated is already available:
+
+```ruby
+require "ddtrace"
+require "httpx"
+
+HTTPX.get(... # request will be traced via the datadog integration
+```
+
+### Faraday: better error handling
+
+The `faraday` adapter will not raise errors anymore, when used in parallel mode. This fixes the difference in behaviour with the equivalent `typhoeus` parallel adapter, which does not raise errors in such cases as well. This behaviour will exclude 4xx and 5xx HTTP responses, which will not be considered errors in the `faraday` adapter.
+
+If errors occur in parallel mode, these'll be available in `env[:error]`. Users can check it in two ways:
+
+```ruby
+response.status == 0
+# or
+!response.env[:error].nil?
+```
+
+## Bugfixes
+
+* unix socket: handle the error when the path for the unix sock is invalid, which was causing an endless loop.
+
+### IPv6 / Happy eyeballs v2
+
+* the `native` resolver will now use IPv6 nameservers with zone identifier to perform DNS queries. This bug was being ignored prior to ruby 3.1 due to some pre-filtering on the nameservere which were covering misuse of the `uri` dependency for this use case.
+* Happy Eyeballs v2 handshake error on connection establishment for the first IP will now ignore it, in case an ongoing connecting for the second IP is happening. This fixes a case where both IPv4 and IPv6 addresses are served for a given domain, but only one of them can be connected to (i.e. if connection via IPv6 fails, the IPv4 one should still proceed to completion).
+* the `native` resolver won't try querying DNS name candidates, if the resolver sends an empty answer with an error code different from "domain not found".
+* fix error of Happy Eyeballs v2 handshake, where the resulting connection would coalesce with an already open one for the same IP **before** requests were merged to the coalesced connection, resulting in no requests being sent and the client hanging.
+
+## Chore
+
+* fixed error message on wrong type of parameter for the `compression_threshold_size` option from the `:compression` plugin.

data/doc/release_notes/0_22_4.md

@@ -0,0 +1,6 @@
+# 0.22.4
+
+## Bugfixes
+
+* fix happy eyeballs v2 bug where, once the first connection would be established, the remaining one would still end up in the coalescing loop, thereby closing itself via the `:tcp_open` callback.
+* fix for faraday plugin parallel mode, where it'd hang if no requests would be made in the parallel block (@catlee)

data/lib/httpx/adapters/datadog.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-if defined?(::DDTrace) && ::DDTrace::VERSION::STRING >= "1.0.0"
+if defined?(DDTrace) && DDTrace::VERSION::STRING >= "1.0.0"
   require "datadog/tracing/contrib/integration"
   require "datadog/tracing/contrib/configuration/settings"
   require "datadog/tracing/contrib/patcher"

data/lib/httpx/adapters/faraday.rb

@@ -169,6 +169,8 @@ module Faraday
         end
 
         def run
+          return unless @handlers.last
+
           env = @handlers.last.env
 
           session = HTTPX.session.with(options_from_env(env))
@@ -210,9 +212,13 @@ module Faraday
         if parallel?(env)
           handler = env[:parallel_manager].enqueue(env)
           handler.on_response do |response|
-            response.raise_for_status
-            save_response(env, response.status, response.body.to_s, response.headers, response.reason) do |response_headers|
-              response_headers.merge!(response.headers)
+            if response.is_a?(::HTTPX::Response)
+              save_response(env, response.status, response.body.to_s, response.headers, response.reason) do |response_headers|
+                response_headers.merge!(response.headers)
+              end
+            else
+              env[:error] = response.error
+              save_response(env, 0, "", {}, nil)
             end
           end
           return handler
@@ -229,6 +235,7 @@ module Faraday
         request.response_on_data = env.request.on_data if env.request.stream_response?
 
         response = session.request(request)
+        # do not call #raise_for_status for HTTP 4xx or 5xx, as faraday has a middleware for that.
         response.raise_for_status unless response.is_a?(::HTTPX::Response)
         save_response(env, response.status, response.body.to_s, response.headers, response.reason) do |response_headers|
           response_headers.merge!(response.headers)
@@ -242,7 +249,8 @@ module Faraday
              Errno::EHOSTUNREACH,
              Errno::EINVAL,
              Errno::ENETUNREACH,
-             Errno::EPIPE => e
+             Errno::EPIPE,
+             ::HTTPX::ConnectionError => e
         raise CONNECTION_FAILED_ERROR, e
       end