httpx-patched 1.6.2.1

data/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;
+*

data/doc/release_notes/0_13_0.md

@@ -0,0 +1,58 @@
+# 0.13.0
+
+## Features
+
+### 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/os85/httpx/-/blob/master/test/support/requests/plugins/upgrade.rb))
+
+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:
+
+#### `:h2c`
+
+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://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://os85.gitlab.io/httpx/wiki/Connection-Upgrade#h2
+
+### `:addresses` option
+
+The `:addresses` option is now available. You can use it to pass a list of IPs to connect to:
+
+```ruby
+# will not resolve example.com, and instead connect to one of the IPs passed.
+HTTPX.get("http://example.com", addresses: %w[172.5.3.1 172.5.3.2]))
+```
+
+You should also use it to connect to HTTP servers bound to a UNIX socket, in which case you'll have to provide a path:
+
+```ruby
+HTTPX.get("http://example.com", transport: "unix", addresses: %w[/path/to/usocket]))
+```
+
+The `:transport_options` are therefore deprecated, and will be moved in a major version.
+
+## Improvements
+
+Some internal improvements that allow certain plugins not to "leak" globally, such as the `:compression` plugin, which used to enable compression for all the `httpx` sessions from the same process. It doesn't anymore.
+
+Using exceptionless nonblocking connect calls in the supported rubies.
+
+Removed unneeded APIs around the Options object (`with_` methods, or the defined options list).
+
+## Bugfixes
+
+HTTP/1.1 persistent connections were closing after each request after the max requests was reached. It's fixed, and the new connection will also be persistent.
+
+When passing open IO objects for origins (the `:io` option), `httpx` was still trying to resolve the origin's domain. This not only didn't make sense, it broke if the domain is unresolvable. It has been fixed.
+
+Fixed usage of `:io` option when passed an "authority/io" hash.
+
+Fixing some issues around trying to connnect to the next available IPAddress when the previous one was unreachable or ETIMEDOUT.

data/doc/release_notes/0_13_1.md

@@ -0,0 +1,5 @@
+# 0.13.1
+
+## Bugfixes
+
+Rescue `Errno::EALREADY` on calls to `connect_nonblock(exception: false)` (there are exceptions after all...).

data/doc/release_notes/0_13_2.md

@@ -0,0 +1,9 @@
+# 0.13.2
+
+## Improvements
+
+`UDPSocket#sendmsg_nonblock` is now used in the native resolver.
+
+## Bugfixes
+
+Usage in Windows was buggy, resulting in `Errno::EINVAL` during DNS resolving, when using the native resolver. This was due to a discrepancy between `recvfrom` behaviour in WS Sockets and Linux Sockets. This was fixed by making we the UDP socket never tries to receive before a DNS query has been actually sent.

data/doc/release_notes/0_14_0.md

@@ -0,0 +1,79 @@
+# 0.14.0
+
+## Features
+
+### GRPC plugin
+
+A new plugin, `:grpc`, is now available. This plugin provides a simple DSL to build GRPC services and performing calls using `httpx` under the hood.
+
+Example:
+
+```ruby
+require "httpx"
+
+grpc = HTTPX.plugin(:grpc)
+helloworld_stub = grpc.build_stub("localhost:4545")
+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://os85.gitlab.io/httpx/wiki/GRPC).
+
+### :origin
+
+A new `:origin` option is available. You can use it for setting a base URL for subsequent relative paths on that session:
+
+```ruby
+HTTPX.get("/httpbin/get") #=> HTTPX::Error: invalid URI: /httpbin/get
+
+httpbin = HTTPX.with(origin: "https://nghttp2.org")
+httpbin.get("/httpbin/get") #=> #<Response:5420 HTTP/2.0 @status=200 ....
+```
+
+**Note!** The origin is **not** for setting base paths, i.e. if you pass it a relative path, it'll be filtered out in subsequent requests (`HTTPX.with(origin: "https://nghttp2.org/httpbin")` will still use only `"https://nghttp2.org"`).
+
+## Improvements
+
+* setting an unexpected option will now raise an `HTTPX::Error` with an helpful message, instead of a confusing `NoMethodError`:
+
+```ruby
+HTTPX.with(foo: "bar")
+# before
+#=> NoMethodError
+# after
+#=> HTTPX::Error: unknown option: foo
+
+```
+
+* `HTTPX::Options#def_option` (which can be used for setting custom plugin options) can now be passed a full body string (where the argument is `value`), although it still support the block form. This is the recommended approach, as the block form is based on `define_method`, which would make clients unusable inside ractors.
+
+* Added support for `:wait_for_handshake` under the `http2_settings` option (`false` by default). HTTP/2 connections complete the protocol handshake before requests are sent. When this option is `true`, requests get send in the initial payload, before the HTTP/2 connection is fully acknowledged.
+
+*  441716a5ac0f7707211ebe0048f568cf0b759c3f: The `:stream` plugin has been improved to start streaming the real response as methods are called (instead of a completely separate synchronous one, which is definitely not good):
+
+```ruby
+session = HTTPX.plugin(:stream)
+response = session.get(build_uri("/stream/3"), stream: true)
+
+# before
+response.status # this could block indefinitely, if the request truly streams infinitely.
+
+# after
+response.status # sends the request, and starts streaming the response until status is available.
+response.each {|chunk|...} # and now you can start yielding the chunks...
+```
+
+
+## Bugfixes
+
+* fixed usage of the `:multipart` if `pathname` isn't loaded.
+* fixed HTTP/2 trailers.
+* fixed connection merges with the same origin, which was causing them to be duplicated and breaking further usage. (#125)
+* fixed repeated session callbacks on a connection, by ensure they're set only once.
+* fixed calculation of `content-length` for streaming or chunked compressed requests.
+
+
+## Chore
+
+* using ruby base container images in CI instead.
+* using truffleruby official container image.

data/doc/release_notes/0_14_1.md

@@ -0,0 +1,7 @@
+# 0.14.1
+
+
+## Bugfixes
+
+* fixed: HTTP/2-specific headers were being reused on insecure redirects, thereby creating an invalid request (#128);
+* fixed: multipart request parts weren't using explicity set `:content_type`, instead using file mime type or "text/plain";

data/doc/release_notes/0_14_2.md

@@ -0,0 +1,6 @@
+# 0.14.2
+
+
+## Bugfixes
+
+* fixed: multipart request parts weren't using explicity set `:filename`.

data/doc/release_notes/0_14_3.md

@@ -0,0 +1,5 @@
+# 0.14.3
+
+## Bugfixes
+
+* fixed: HTTP/1 "connection: close" header was "leaking" into subsequent redirect follow, including HTTP/2 requests which would fail due to the invalid header.

data/doc/release_notes/0_14_4.md

@@ -0,0 +1,5 @@
+# 0.14.4
+
+## Bugfixes
+
+* The HTTP/1 handler was miscalculating the last request for a given connection, and potentially freezing it.

data/doc/release_notes/0_14_5.md

@@ -0,0 +1,11 @@
+# 0.14.5
+
+## Bugfixes
+
+* After a connection had been initiated, sending multiple concurrent requests (ex: `open_httpx.request(req1, req2, req3)`) could freeze; this happened when the first request would fill the write buffer (like a file upload request), and the subsequent requests would never be buffered afterwards; this was fixed by making pending requests flushing a part of a connection's consumption loop.
+* Fixing v0.14.1's fixed bug again; The HTTP/1 "Connection: close" header was not being set in the last possible request on a connection, due to ann off-by-one error on connection bookkeeping;
+* HTTP/1 connections didn't respect a server-set max nunmber of requests after a reconnect; Fixed by making this accounting part of the reset process;
+
+## Chore
+
+* Added regression test suite, which reproduce reported bugs before the fix (backported all 0.14.x releases here)

data/doc/release_notes/0_15_0.md

@@ -0,0 +1,53 @@
+# 0.15.0
+
+## Features
+
+### HTTP response pattern-matching (ruby 3 only)
+
+You can now apply pattern matching in responses:
+
+```ruby
+case response = HTTPX.get("https://google.com")
+in { status: 200..399, headers: [*, ["x-special-token", token], *], body: }
+  puts "success: #{body.to_s}"
+in { status: 400..499, body: }
+  puts "client error: #{body.to_s}"
+in { status: 500.., body: }
+  puts "server error: #{body.to_s}"
+in { error: error }
+  puts "error: #{error.message}"
+else
+  raise "unexpected: #{response}"
+end
+```
+
+### NTLM Authentication
+
+A new plugin, `:ntml_authentication`, is now available. Like the name suggests, it allows authenticating requests via [NTLM](https://docs.microsoft.com/en-us/windows-server/security/kerberos/ntlm-overview).
+
+```ruby
+ntlm_http = HTTPX.plugin(:ntlm_authentication)
+
+ntlm.ntlm_authentication("user", "password").get("http://protected-area-requiring-ntlm.net")
+# or for a specific domain
+ntlm.ntlm_authentication("user", "password", "Domain\\User").get("http://protected-area-requiring-ntlm.net")
+```
+
+## Improvemennts
+
+A new timeout option, `settings_timeout`, is supported for the HTTP/2 handshake; after the TCP and TLS handshakes are complete, and initiating the HTTP/2 handshake, the client terminates the connection with SETTINGS_TIMEOUT error code, if it doesn't receive the server settings for the amount of seconds set in `settings_timeout` (by default, 10 seconds).
+
+```ruby
+# if you want to change
+HTTPX.with(timeout: {settings_timeout: 5})....
+
+```
+
+IDNA 2008 support is now possibly, by integrating [idnx](https://github.com/HoneyryderChuck/idnx) into your dependencies:
+
+
+```ruby
+# in Gemfile
+gem "httpx"
+gem "idnx"
+```

data/doc/release_notes/0_15_1.md

@@ -0,0 +1,8 @@
+# 0.15.1
+
+## Bugfixes
+
+Fixed HTTP/1 connection accounting on requests:
+
+* when persistent, Connection: close will be set based on the request position on the batch against the allowed requests on the open connection.
+* when not persistent, Connnection: close will be set on the last request of the batch, being the batch a subset based on allowed requests, or the whole of it.

data/doc/release_notes/0_15_2.md

@@ -0,0 +1,9 @@
+# 0.15.2
+
+## Bugfixes
+
+* Fixed cookie management for same-keys: before the fix, cookies with same-key, same-domain and same-path were all being sent in subsequent requests, which violates  RFC 6265 - 5.4 . As of now, only the last valid cookie for a given key/domain/path will be kept, evicting the others.
+
+## Chore
+
+* debug logs were inserting ASCII code string wrappers, even when no color was set. It nonw only sends the plain string.

data/doc/release_notes/0_15_3.md

@@ -0,0 +1,5 @@
+# 0.15.3
+
+## Bugfixes
+
+* Fixed connection management, where selectables could end up with "arrays of IO objects" as elements, instead of just IO objects. This caused bugs when connecting and performing concurrent requests on multiple hosts (#138).

data/doc/release_notes/0_15_4.md

@@ -0,0 +1,5 @@
+# 0.15.4
+
+## Bugfixes
+
+* Fixed `grpc` plugin, where `.marshal` was being called on the encoding protobuf object, instead of the coorrect "marshal method", which is `.encode`.

data/doc/release_notes/0_16_0.md

@@ -0,0 +1,93 @@
+# 0.16.0
+
+## Features
+
+### Response::Body#to_s does not clear the internal buffer
+
+It's well documented that the response body should be treated as a file, and that calling `.to_s` on a response should be done only once, and the user should not expect the same call to return the same response body again, while suggesting that the first call should be cached in a variable in case it's needed:
+
+```ruby
+response = HTTPX.get("https://google.com")
+body = response.body.to_s #=> "<html ...."
+response.body.to_s #=> ""
+
+# thankfully,it's cached in the body var there.
+```
+
+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/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!
+
+```ruby
+response = HTTPX.get("https://google.com")
+body = response.body.to_s #=> "<html ...."
+response.body.to_s #=> "<html ....", still here!
+```
+
+Some optimizations were done around how the body is carried forward, and bodies buffered in files will now get properly garbage collected and not leak descriptors behind when users forget to call `.close`.
+
+### grpc plugin improvements
+
+##### build fully-enabled stub from grpc service
+
+The `:grpc` plugin can now build fully-loaded stubs from existing GRPC generic services.
+
+GRPC stubs could be a bit tedious to write when compared to what the `grpc` gem offers, which is, auto-generation from ruby service stubs from protobuf definitions:
+
+```ruby
+# service generated from the command:
+#
+# > grpc_tools_ruby_protoc -I ../../protos --ruby_out=../lib --grpc_out=../lib ../../protos/route_guide.proto
+#
+require "route_guide_services_pb.rb"
+
+# with httpx, before 0.16
+stub = HTTPX.plugin(:grpc).build_stub("localhost:#{server_port}", service: "RouteGuide")
+                          .rpc(:GetFeature, Point, Feature)
+                          .rpc(:ListFeatures, # ... and so on, all hand stitched
+
+stub.get_feature(# ...
+
+# with httpx 0.16
+stub = HTTPX.plugin(:grpc).build_stub("localhost:#{server_port}", service: RouteGuide)
+# that's it!
+stub.get_feature(# ...
+```
+
+#### no google/protobuf direct dependency
+
+`"google/protobuf"` is no longer assumed when using the plugin, i.e. you can use other protobuf serializers, such as https://github.com/ruby-protobuf/protobuf , which supports `jruby` (unlike the former).
+
+### OptionsMethods for 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):
+
+```ruby
+module CustomPlugin
+  module OptionsMethods
+    def option_bar(x) ; x; end
+  end
+end
+
+HTTPX.plugin(CustomPlugin).with(bar: 2)
+```
+
+### cookies plugin: improved jar management
+
+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/os85/httpx/-/blob/master/test/support/requests/plugins/cookies.rb .
+
+## Bugfixes
+
+* Cookies sorting in the `:cookies` plugin jar was fixed for truffleruby;
+
+## Chore
+
+* errors when setting options nnow raise `TypeError` instead of `HTTPX::Error`.
+* options are now internally frozen by default, which should protect the internals against accidentally updating them;
+* Fixed optimization around options initialization, to prevent needless allocations;

data/doc/release_notes/0_16_1.md

@@ -0,0 +1,5 @@
+# 0.16.1
+
+## Bugfixes
+
+* fixed native resolver hanging when dealing with FQDN end names (#145).

data/doc/release_notes/0_17_0.md

@@ -0,0 +1,49 @@
+# 0.17.0
+
+## Features
+
+### Response mime type decoders (#json, #form)
+
+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.
+
+```ruby
+# after HTTPX.get("https://api.smth/endpoint-returning-json")
+response.json # same as JSON.dump(response.to_s)
+```
+
+Although not yet documented, integrating custom decoders is also possible (i.e. parsing HTML with `nokogiri` or something similar).
+
+## Improvements
+
+### Connection: reduce interest calculations
+
+Due to it being an intensive task, internal interest calculation in connections was reduce to the bare minimum.
+
+### Immutable Options, internal recycling of instances, improves memory usage in the happy path
+
+A lot of effort went into avoiding generating options objects internally whenever necessary. This means, when sending several requests with the same set of options (the most common case in `httpx` usage), internally only one object is passed around. For that, the following improvements were done:
+
+* `Options#merge` returns the same options the the options being merged are a subset of the current set of options (b126938a6547e09b726dd64298fb488891d938e9).
+* `Session#build_request` bypasses instantiation of options if it receives an `Options` object (which happens internally in the happy path, if users don't call `#build_request` directly) (3d549817cb41d4b904102fdc61afe3ecd9170893).
+* Improving internal `Session` APIs to not pass around options, and instead rely on accessing request options.
+* `Options#to_hash` does not build internal garbage arrays anymore (cc02679b804f63798f5d2136a039be1624e96ab6).
+
+### Reduce regexp operations in the HTTP/1 parser
+
+Some code paths in the HTTP/1 parser still using regular expressions were replaced by string operations accomplishing the same.
+
+### HTTP/1 improvements on the complexity of connection accounting calculations
+
+Managing open HTTP/1 connections relies on operations calculating whether there are requests waiting for completion. This relied on traversing all requests for that connectionn (O(n)); it now only checks the completion state of the first and last request of that connection, given that all requests in HTTP/1 are sequential (O(1)); this optimization brings a big improvement to persistent and pipelined requests (65261217b1270913e4bb93717e8b8dcfa775565a).
+
+## Bugfixes
+
+* fixing HTTP/1 protocol uncompliant exposing multiple values for the "Host" header (e435dd0534314508262184fb03d83124d89d2079).
+
+* Custom response finalizer introduced in 0.16.0 has been reverted. It was brought to my attention that `Tempfile` implementation already takes care of the file on GC (and `httpx` was duplicating), and the approach taken in `httpx` was buggy in several ways (not tolerant to forks, never recycled finalizers...) (aa3be21c890f92a41afcc7931f01dd24cc801f7c).
+
+## Chore
+
+RBS Typing improvements based on latest stdlib signatures additions, such as `openssl`, `digest`, `socket` and others.

data/doc/release_notes/0_18_0.md

@@ -0,0 +1,69 @@
+# 0.18.0
+
+## Features
+
+### 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.
+
+```ruby
+client = HTTPX.plugin(:response_cache)
+r1 = client.get("https://nghttp2.org/httpbin/cache")
+r2 = client.get("https://nghttp2.org/httpbin/cache")
+
+r1.status #=> 200
+r2.status #=> 304
+r1.body == r2.body #=> true
+```
+
+### jitter on "retry-after"
+
+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/os85/httpx/-/wikis/Retries#retry_jitter) option:
+
+```ruby
+HTTPX.plugin(:retries, retry_after: 2, retry_jitter: ->(interval) { interval + rand }) # interval is 3
+```
+
+You can opt out of this by setting `HTTPX_NO_JITTER=1` environment variable.
+
+### Response#error
+
+`HTTPX::Response#error` was added, to match `HTTPX::Response#error`. It returns an exception for 4xx/5xx responses (`HTTPX::HTTPError`), `nil` otherwise. It allows for end users to write such code:
+
+```ruby
+if (response = HTTPX.get(uri)).error
+  # success
+else
+  #error
+end
+```
+
+## Improvements
+
+* `webmock` adapter: added support for "stub_http_request#to_timeout" (https://gitlab.com/os85/httpx/-/merge_requests/165).
+
+## timers not a dependency
+
+The functionality provided by the `timers` gem was replaced by a simpler custom implementation. Although powerful, its complexity was somewhat unnecessary for `httpx`'s simpler event loop, where user-defined timeouts are usually the same for a given batch of requests. The removal of `timers` reduces the number of dependencies to 1, which is `http-2-next` and is maintained by me.
+
+## AWS plugins
+
+* `aws_sdk_authentication` plugin: removed implementation relying on  `aws-sdk-s3`, replacing it with an `aws-sdk-core` relying implementation, which only uses credentials strategies and region discovery (the whole point of this SDK is to use a minimal subset of AWS SDK).
+
+
+## Bugfixes
+
+* 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.
+* Fixed issue where HTTP/2 streams were being closed twice (and signaling it also twice), messing connection accounting in the pool.
+* DoH resolver was always subscribed to the default thread "connection pool", which broke scenarios were session was patched to use its custom pool; it now ensures that it subscribes to the pool it was created in.
+* `:aws_sigv4` plugin: removed require of `aws-sdk-s3`, left there by mistake (the whole point of the plugin is to run without the AWS SDK).
+## Chore
+
+* `HTTPX::ErrorResponse#status` is now deprecated.

data/doc/release_notes/0_18_1.md

@@ -0,0 +1,12 @@
+# 0.18.1
+
+## Bugfixes
+
+* HTTP/1.1 pipelining logs were logging the previously-buffered requests all together for each triggered request, which created some confusion for users when reporting errors. This has been fixed.
+* HTTP/2 coalescing is now skipped when performing TLS connections with VERIFY_NONE.
+* HTTP/2 peer GOAWAY frames will now result in a (retryable) connection error, instead of being ignored and leaving a "ghost" connection behind.
+* fixed total timeout call which was not raising the exception.
+
+## Chore
+
+This gem now requires MFA-based gem releases.

data/doc/release_notes/0_18_2.md

@@ -0,0 +1,10 @@
+# 0.18.2
+
+## Bugfixes
+
+* A bug was reported and fixed, whereby a persistent connection with a `:total_timeout` set was triggering the timeout and leaving the process looping indefinitely.
+
+
+## Chore
+
+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_18_3.md

@@ -0,0 +1,7 @@
+# 0.18.3
+
+## Bugfixes
+
+* request bodies eager-loaded from enumerables yield duped partial chunks.
+
+An error was observed while looking at webmock integration, where requests formed via the multipart plugin were returning an empty string as body. The issue was caused by an optimization on multipart encoder, which reuses the same buffer when reading chunks. Unfortunately, these cannot be yielded the same way via IO.copy_stream, as the same (cleared) buffer will be used to generate the eager-loaded body chunks.

data/doc/release_notes/0_18_4.md

@@ -0,0 +1,14 @@
+# 0.18.4
+
+## Improvements
+
+* faraday adapter: added support for `#on_data` callback in order to support [faraday streaming](https://lostisland.github.io/faraday/usage/streaming).
+
+* multipart plugin: removed support for file mime type detection using `mime-types`. The reasoning behind it was that `mime-types` uses the filename, which is a very inaccurate detection strategy (ex: an mp4 video will be identified as `application/mp4`, instead of the correct `video/mp4`).
+* multipart plugin: supported for file mime type detection using `marcel` and `filemagic` was added. Both use the magic header bytes, which is a more accurate strategy for file type detection.
+
+## Bugfixes
+
+* webmock adapter has been reimplemented to work with `httpx` plugins (such as the `:retries` plugin). Some other fixes were applied to make it work better under `vcr` (a common `webmock` extension).
+
+* fixed the URI-related bug which was making requests stall under ruby 3.1 (still not officially testing against it).

data/doc/release_notes/0_18_5.md

@@ -0,0 +1,10 @@
+# 0.18.5
+
+## Improvements
+
+* ruby 3.1 is now officially supported.
+* when a user sets a `Host` header for an HTTP/2 request, this will be used in the `:authority` HTTP/2 pseudo-header, instead of silently ignored (mimicking what "curl" does).
+
+## Bugfixes
+
+* fixed "throw outside of catch block" error happening when pipelining requests on an HTTP/1 connection and resulting in a timeout.

data/doc/release_notes/0_18_6.md

@@ -0,0 +1,5 @@
+# 0.18.6
+
+## Bugfixes
+
+* multipart plugin: fixed missing constant in `filemagic` integration.

data/doc/release_notes/0_18_7.md

@@ -0,0 +1,5 @@
+# 0.18.6
+
+## Bugfixes
+
+* multipart plugin: fixed `filemagic` integration by rewinding the file after mime-type detection.