httpx 0.11.3 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e1612c9f4696a7a6ae0508ea66f864654e28470e742b91b57cd14ab5b43adad2
-  data.tar.gz: 791569d7282f7cb3e451d245e332871c170e4571ca5e10ead757f93afffe3d78
+  metadata.gz: abbeaccc55115244f08e7b39aaad174a34dd2e7aeb10b32cdc0563fbefe1b953
+  data.tar.gz: a39fc4e5644b21c1265840011e969c36904756573584cba0f805d568a549ec94
 SHA512:
-  metadata.gz: 96e8bc5d07f59b21ccdbc54bb11bce9b1deb53eb128c4d6c2652a0dfca6c925cbe084e82f352857004420cc5753fbacc3a68e2bc4d885937a2afbfa5c6138836
-  data.tar.gz: b74cbac2346d110a97e6ab9a13f2a62db7ed23ce1454df510f9c8cb6ea58314edff2724b9cc269cdf8d5fdf00e9ce6c5c28eff864605f6ce01a9e2f4b9078911
+  metadata.gz: 82fa475dcd9ef05ebe90f0b3c742c17c33185410a70eb5af730fce393681b7f9f346decf78349614f77b76257550c0e3056e61f3b5d6cd5efdba0149eff235f6
+  data.tar.gz: 64ceb596415b440c99c9df31569fa0ee2f7c94e51787d5e0d84141f1ade0be92e23e2d7011a361c1366b43c4f159525599367009bd4021c358537f11c4605cac

data/README.md

@@ -113,7 +113,7 @@ The test suite runs against [httpbin proxied over nghttp2](https://nghttp2.org/h
 
 ## Supported Rubies
 
-All Rubies greater or equal to 2.1, and always latest JRuby.
+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.
 
@@ -133,7 +133,7 @@ All Rubies greater or equal to 2.1, and always latest JRuby.
 
 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).
 
-JRuby's `openssl` is based on Bouncy Castle, which is massively outdated and still doesn't implement ALPN. So HTTP/2 over TLS/ALPN negotiation is off until JRuby figures this out.
+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.
 
 ### Known bugs
 

data/doc/release_notes/0_10_1.md

@@ -26,7 +26,7 @@ From now on, both headers and the responnse payload will also appear, so expecte
 ## 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 pendign requests to HTTP/1.1 (a hanging loop was being caused);
+* 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);

data/doc/release_notes/0_11_1.md

@@ -1 +1,5 @@
-0_11_1.md
+# 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/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/honeyryderchuck/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
+
+Other FAQ: https://gitlab.com/honeyryderchuck/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
+
+## 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/honeyryderchuck/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).
+
+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://honeyryderchuck.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
+
+### `: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", 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.1
+
+## 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://honeyryderchuck.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/lib/httpx.rb

@@ -12,14 +12,12 @@ require "httpx/callbacks"
 require "httpx/loggable"
 require "httpx/registry"
 require "httpx/transcoder"
-require "httpx/options"
-require "httpx/timeout"
 require "httpx/pool"
 require "httpx/headers"
 require "httpx/request"
 require "httpx/response"
+require "httpx/options"
 require "httpx/chainable"
-require "httpx/session"
 
 # Top-Level Namespace
 #
@@ -59,3 +57,5 @@ module HTTPX
 
   extend Chainable
 end
+
+require "httpx/session"

data/lib/httpx/adapters/faraday.rb

@@ -123,11 +123,9 @@ module Faraday
           end
 
           def method_missing(meth, *args, &blk)
-            if @env && @env.respond_to?(meth)
-              @env.__send__(meth, *args, &blk)
-            else
-              super
-            end
+            return super unless @env && @env.respond_to?(meth)
+
+            @env.__send__(meth, *args, &blk)
           end
         end
 
@@ -197,7 +195,7 @@ module Faraday
           response_headers.merge!(response.headers)
         end
         @app.call(env)
-      rescue OpenSSL::SSL::SSLError => e
+      rescue ::HTTPX::TLSError => e
         raise SSL_ERROR, e
       rescue Errno::ECONNABORTED,
              Errno::ECONNREFUSED,

data/lib/httpx/altsvc.rb

@@ -37,6 +37,7 @@ module HTTPX
     end
 
     def emit(request, response)
+      return unless response.respond_to?(:headers)
       # Alt-Svc
       return unless response.headers.key?("alt-svc")
 

data/lib/httpx/callbacks.rb

@@ -6,19 +6,28 @@ module HTTPX
       callbacks(type) << action
     end
 
-    def once(event, &block)
-      on(event) do |*args, &callback|
+    def once(type, &block)
+      on(type) do |*args, &callback|
         block.call(*args, &callback)
         :delete
       end
     end
 
+    def only(type, &block)
+      callbacks(type).clear
+      on(type, &block)
+    end
+
     def emit(type, *args)
-      callbacks(type).delete_if { |pr| pr[*args] == :delete }
+      callbacks(type).delete_if { |pr| :delete == pr[*args] } # rubocop:disable Style/YodaCondition
     end
 
     protected
 
+    def callbacks_for?(type)
+      @callbacks.key?(type) && !@callbacks[type].empty?
+    end
+
     def callbacks(type = nil)
       return @callbacks unless type
 

data/lib/httpx/chainable.rb

@@ -17,12 +17,12 @@ module HTTPX
     # :nocov:
     def timeout(**args)
       warn ":#{__method__} is deprecated, use :with_timeout instead"
-      branch(default_options.with(timeout: args))
+      with(timeout: args)
     end
 
     def headers(headers)
       warn ":#{__method__} is deprecated, use :with_headers instead"
-      branch(default_options.with(headers: headers))
+      with(headers: headers)
     end
     # :nocov:
 

data/lib/httpx/connection.rb

@@ -69,8 +69,10 @@ module HTTPX
       end
 
       @inflight = 0
-      @keep_alive_timeout = options.timeout.keep_alive_timeout
+      @keep_alive_timeout = options.timeout[:keep_alive_timeout]
       @keep_alive_timer = nil
+
+      self.addresses = options.addresses if options.addresses
     end
 
     # this is a semi-private method, to be used by the resolver
@@ -105,6 +107,8 @@ module HTTPX
 
       return false if exhausted?
 
+      return false unless connection.addresses
+
       !(@io.addresses & connection.addresses).empty? && @options == connection.options
     end
 
@@ -125,7 +129,7 @@ module HTTPX
     end
 
     def merge(connection)
-      @origins += connection.instance_variable_get(:@origins)
+      @origins |= connection.instance_variable_get(:@origins)
       connection.purge_pending do |req|
         send(req)
       end
@@ -170,7 +174,7 @@ module HTTPX
       end
 
       # if the write buffer is full, we drain it
-      return :w if @write_buffer.full?
+      return :w unless @write_buffer.empty?
 
       return @parser.interests if @parser
 
@@ -234,9 +238,9 @@ module HTTPX
     def timeout
       return @timeout if defined?(@timeout)
 
-      return @options.timeout.connect_timeout if @state == :idle
+      return @options.timeout[:connect_timeout] if @state == :idle
 
-      @options.timeout.operation_timeout
+      @options.timeout[:operation_timeout]
     end
 
     private
@@ -251,11 +255,18 @@ module HTTPX
 
     def consume
       catch(:called) do
+        epiped = false
         loop do
           parser.consume
 
-          # we exit if there's no more data to process
-          if @pending.size.zero? && @inflight.zero?
+          # we exit if there's no more requests to process
+          #
+          # this condition takes into account:
+          #
+          # * the number of inflight requests
+          # * the number of pending requests
+          # * whether the write buffer has bytes (i.e. for close handshake)
+          if @pending.size.zero? && @inflight.zero? && @write_buffer.empty?
             log(level: 3) { "NO MORE REQUESTS..." }
             return
           end
@@ -265,9 +276,17 @@ module HTTPX
           read_drained = false
           write_drained = nil
 
-          # dread
+          #
+          # tight read loop.
+          #
+          # read as much of the socket as possible.
+          #
+          # this tight loop reads all the data it can from the socket and pipes it to
+          # its parser.
+          #
           loop do
             siz = @io.read(@window_size, @read_buffer)
+            log(level: 3, color: :cyan) { "IO READ: #{siz} bytes..." }
             unless siz
               ex = EOFError.new("descriptor closed")
               ex.set_backtrace(caller)
@@ -275,27 +294,53 @@ module HTTPX
               return
             end
 
+            # socket has been drained. mark and exit the read loop.
             if siz.zero?
               read_drained = @read_buffer.empty?
+              epiped = false
               break
             end
 
             parser << @read_buffer.to_s
 
+            # continue reading if possible.
+            break if interests == :w && !epiped
+
+            # exit the read loop if connection is preparing to be closed
             break if @state == :closing || @state == :closed
 
-            # for HTTP/2, we just want to write goaway frame
-          end unless @state == :closing
+            # exit #consume altogether if all outstanding requests have been dealt with
+            return if @pending.size.zero? && @inflight.zero?
+          end unless (interests == :w || @state == :closing) && !epiped
 
-          # dwrite
+          #
+          # tight write loop.
+          #
+          # flush as many bytes as the sockets allow.
+          #
           loop do
+            # buffer has been drainned, mark and exit the write loop.
             if @write_buffer.empty?
               # we only mark as drained on the first loop
               write_drained = write_drained.nil? && @inflight.positive?
+
               break
             end
 
-            siz = @io.write(@write_buffer)
+            begin
+              siz = @io.write(@write_buffer)
+            rescue Errno::EPIPE
+              # this can happen if we still have bytes in the buffer to send to the server, but
+              # the server wants to respond immediately with some message, or an error. An example is
+              # when one's uploading a big file to an unintended endpoint, and the server stops the
+              # consumption, and responds immediately with an authorization of even method not allowed error.
+              # at this point, we have to let the connection switch to read-mode.
+              log(level: 2) { "pipe broken, could not flush buffer..." }
+              epiped = true
+              read_drained = false
+              break
+            end
+            log(level: 3, color: :cyan) { "IO WRITE: #{siz} bytes..." }
             unless siz
               ex = EOFError.new("descriptor closed")
               ex.set_backtrace(caller)
@@ -303,21 +348,28 @@ module HTTPX
               return
             end
 
+            # socket closed for writing. mark and exit the write loop.
             if siz.zero?
               write_drained = !@write_buffer.empty?
               break
             end
 
-            break if @state == :closing || @state == :closed
+            # exit write loop if marked to consume from peer, or is closing.
+            break if interests == :r || @state == :closing || @state == :closed
 
             write_drained = false
-          end
+          end unless interests == :r
 
           # return if socket is drained
-          if read_drained && write_drained
-            log(level: 3) { "WAITING FOR EVENTS..." }
-            return
-          end
+          next unless (interests != :r || read_drained) &&
+                      (interests != :w || write_drained)
+
+          # gotta go back to the event loop. It happens when:
+          #
+          # * the socket is drained of bytes or it's not the interest of the conn to read;
+          # * theres nothing more to write, or it's not in the interest of the conn to write;
+          log(level: 3) { "(#{interests}): WAITING FOR EVENTS..." }
+          return
         end
       end
     end
@@ -361,7 +413,7 @@ module HTTPX
         emit(:exhausted)
       end
       parser.on(:origin) do |origin|
-        @origins << origin
+        @origins |= [origin]
       end
       parser.on(:close) do |force|
         transition(:closing)
@@ -391,6 +443,7 @@ module HTTPX
           emit(:misdirected, request)
         else
           response = ErrorResponse.new(request, ex, @options)
+          request.response = response
           request.emit(:response, response)
         end
       end
@@ -399,7 +452,7 @@ module HTTPX
     def transition(nextstate)
       case nextstate
       when :idle
-        @timeout = @current_timeout = @options.timeout.connect_timeout
+        @timeout = @current_timeout = @options.timeout[:connect_timeout]
 
       when :open
         return if @state == :closed
@@ -411,7 +464,7 @@ module HTTPX
 
         send_pending
 
-        @timeout = @current_timeout = @options.timeout.operation_timeout
+        @timeout = @current_timeout = @options.timeout[:operation_timeout]
         emit(:open)
       when :closing
         return unless @state == :open
@@ -424,33 +477,33 @@ module HTTPX
           remove_instance_variable(:@total_timeout)
         end
 
-        @io.close if @io
-        @read_buffer.clear
-        if @keep_alive_timer
-          @keep_alive_timer.cancel
-          remove_instance_variable(:@keep_alive_timer)
-        end
-
-        remove_instance_variable(:@timeout) if defined?(@timeout)
+        purge_after_closed
       when :already_open
         nextstate = :open
         send_pending
       end
       @state = nextstate
-    rescue Errno::EHOSTUNREACH
-      # at this point, all addresses from the IO object have failed
-      reset
-      emit(:unreachable)
-      throw(:jump_tick)
     rescue Errno::ECONNREFUSED,
            Errno::EADDRNOTAVAIL,
-           OpenSSL::SSL::SSLError => e
+           Errno::EHOSTUNREACH,
+           TLSError => e
       # connect errors, exit gracefully
       handle_error(e)
       @state = :closed
       emit(:close)
     end
 
+    def purge_after_closed
+      @io.close if @io
+      @read_buffer.clear
+      if @keep_alive_timer
+        @keep_alive_timer.cancel
+        remove_instance_variable(:@keep_alive_timer)
+      end
+
+      remove_instance_variable(:@timeout) if defined?(@timeout)
+    end
+
     def handle_response
       @inflight -= 1
       return unless @inflight.zero?
@@ -490,12 +543,14 @@ module HTTPX
     def handle_error(error)
       parser.handle_error(error) if @parser && parser.respond_to?(:handle_error)
       while (request = @pending.shift)
-        request.emit(:response, ErrorResponse.new(request, error, @options))
+        response = ErrorResponse.new(request, error, @options)
+        request.response = response
+        request.emit(:response, response)
       end
     end
 
     def total_timeout
-      total = @options.timeout.total_timeout
+      total = @options.timeout[:total_timeout]
 
       return unless total