httpx 0.23.4 → 0.24.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3869ae05ccfa2903477391c3ed918d9022ebd628795a09ad9681511a2d46f77
-  data.tar.gz: c7d296cdbaed94327582b409463677ad549038d5785d8e296e837c243183bf43
+  metadata.gz: 588deec0af9ead32480f7cca9ce8c278b344ccdd2e608cc2a6a8db8c6135647f
+  data.tar.gz: 3b69af49050cd6ba7b0317ddcd2286cbe6a2261add9fd0b9839bb89290e3962a
 SHA512:
-  metadata.gz: 80b74ee360f1db9632a0e1317e3a3ed5ae3ac863e5c6c637e4ba85719027e68bf1e3fcc2103b35b1fc11221bd832af911d985a7dd51eb9030cd9392bf310b591
-  data.tar.gz: b424d2a3e8c796cd04747bd446a06ee690f1fa5965f397b4e7ab98880ca2d34f97d8846ecccf6973b42351b15543d610dac6ca8217ba68fb53388610071e17e1
+  metadata.gz: e630447fb6bc2aabb6efd842fdd322734e78e7859ea03126ab3d45cf4580d91ede945aa4e77700ae6cbe92179cc0a7e96fdc294ccaf729b287c4b4269b9b40b8
+  data.tar.gz: 138310fead4041c202f32b3e53564023472383f5cc251c59cc88b115c8f2947801da8269518d3dce48ff8b53abe3b1350d92b553a9264be8ab052064a135b605

data/doc/release_notes/0_24_0.md

@@ -0,0 +1,48 @@
+# 0.24.0
+
+## Features
+
+### `:oauth` plugin
+
+The `:oauth` plugin manages the handling of a given OAuth session, in that it ships with convenience methods to generate a new access token, which it then injects in all requests.
+
+More info under https://honeyryderchuck.gitlab.io/httpx/wiki/OAuth
+
+### session callbacks
+
+HTTP request/response lifecycle events have now the ability of being intercepted via public API callback methods:
+
+```ruby
+HTTPX.on_request_completed do |request|
+  puts "request to #{request.uri} sent"
+end.get(...)
+```
+
+More info under https://honeyryderchuck.gitlab.io/httpx/wiki/Events to know which events and callback methods are supported.
+
+### `:circuit_breaker` plugin `on_circuit_open` callback
+
+A callback has been introduced for the `:circuit_breaker` plugin, which is triggered when a circuit is opened.
+
+```ruby
+http = HTTPX.plugin(:circuit_breaker).on_circuit_open do |req|
+  puts "circuit opened for #{req.uri}"
+end
+http.get(...)
+```
+
+## Improvements
+
+Several `:response_cache` features have been improved:
+
+* `:response_cache` plugin: response cache store has been made thread-safe.
+* cached response sharing across threads is made safer, as stringio/tempfile instances are copied instead of shared (without copying the underling string/file).
+* stale cached responses are eliminate on cache store lookup/store operations.
+* already closed responses are evicted from the cache store.
+* fallback for lack of compatible response "date" header has been fixed to return a `Time` object.
+
+## Bugfixes
+
+* Ability to recover from errors happening during response chunk processing (required for overriding behaviour and response chunk callbacks); error bubbling up will result in the connection being closed.
+* Happy eyeballs support for multi-homed early-resolved domain names (such as `localhost` under `/etc/hosts`) was broken, as it would try the first given IP; so, if given `::1` and connection would fail, it wouldn't try `127.0.0.1`, which would have succeeded.
+* `:digest_authentication` plugin was removing the "algorithm" header on `-sess` declared algorithms, which is required for HTTP digest auth negotiation.

data/doc/release_notes/0_24_1.md

@@ -0,0 +1,12 @@
+# 0.24.1
+
+## Improvements
+
+* datadog adapter: support `:service_name` configuration option.
+* datadog adapter: set `:distributed_tracing` to `true` by default.
+* `:proxy` plugin: when the proxy uri uses an unsupported scheme (i.e.: "scp://125.24.2.1"), a more user friendly error is raised (instead of the previous broken stacktrace).
+
+## Bugfixes
+
+* datadog adapter: fix tracing enable call, which was wrongly calling `super`.
++ `:proxy` plugin: fix for bug which was turning off plugins overriding `HTTPX::Connection#send` (such as the datadog adapter).

data/lib/httpx/adapters/datadog.rb

@@ -160,7 +160,7 @@ module TRACING_MODULE # rubocop:disable Naming/ClassAndModuleCamelCase
 
         module RequestMethods
           def __datadog_enable_trace!
-            return super if @__datadog_enable_trace
+            return if @__datadog_enable_trace
 
             RequestTracer.new(self).call
             @__datadog_enable_trace = true
@@ -203,6 +203,27 @@ module TRACING_MODULE # rubocop:disable Naming/ClassAndModuleCamelCase
             o.lazy
           end
 
+          if defined?(TRACING_MODULE::Contrib::SpanAttributeSchema)
+            option :service_name do |o|
+              o.default do
+                TRACING_MODULE::Contrib::SpanAttributeSchema.fetch_service_name(
+                  "DD_TRACE_HTTPX_SERVICE_NAME",
+                  "httpx"
+                )
+              end
+              o.lazy
+            end
+          else
+            option :service_name do |o|
+              o.default do
+                ENV.fetch("DD_TRACE_HTTPX_SERVICE_NAME", "httpx")
+              end
+              o.lazy
+            end
+          end
+
+          option :distributed_tracing, default: true
+
           option :error_handler, default: DEFAULT_ERROR_HANDLER
         end
       end

data/lib/httpx/callbacks.rb

@@ -4,6 +4,7 @@ module HTTPX
   module Callbacks
     def on(type, &action)
       callbacks(type) << action
+      self
     end
 
     def once(type, &block)
@@ -11,6 +12,7 @@ module HTTPX
         block.call(*args, &callback)
         :delete
       end
+      self
     end
 
     def only(type, &block)

data/lib/httpx/chainable.rb

@@ -10,6 +10,19 @@ module HTTPX
       MOD
     end
 
+    %i[
+      connection_opened connection_closed
+      request_error
+      request_started request_body_chunk request_completed
+      response_started response_body_chunk response_completed
+    ].each do |meth|
+      class_eval(<<-MOD, __FILE__, __LINE__ + 1)
+        def on_#{meth}(&blk)   # def on_connection_opened(&blk)
+          on(:#{meth}, &blk)   #   on(:connection_opened, &blk)
+        end                    # end
+      MOD
+    end
+
     def request(*args, **options)
       branch(default_options).request(*args, **options)
     end
@@ -56,6 +69,12 @@ module HTTPX
       branch(default_options.merge(options), &blk)
     end
 
+    protected
+
+    def on(*args, &blk)
+      branch(default_options).on(*args, &blk)
+    end
+
     private
 
     def default_options

data/lib/httpx/connection/http1.rb

@@ -133,33 +133,42 @@ module HTTPX
     end
 
     def on_data(chunk)
-      return unless @request
+      request = @request
+
+      return unless request
 
       log(color: :green) { "-> DATA: #{chunk.bytesize} bytes..." }
       log(level: 2, color: :green) { "-> #{chunk.inspect}" }
-      response = @request.response
+      response = request.response
 
       response << chunk
+    rescue StandardError => e
+      error_response = ErrorResponse.new(request, e, request.options)
+      request.response = error_response
+      dispatch
     end
 
     def on_complete
-      return unless @request
+      request = @request
+
+      return unless request
 
       log(level: 2) { "parsing complete" }
       dispatch
     end
 
     def dispatch
-      if @request.expects?
+      request = @request
+
+      if request.expects?
         @parser.reset!
-        return handle(@request)
+        return handle(request)
       end
 
-      request = @request
       @request = nil
       @requests.shift
       response = request.response
-      response.finish!
+      response.finish! unless response.is_a?(ErrorResponse)
       emit(:response, request, response)
 
       if @parser.upgrade?
@@ -169,7 +178,11 @@ module HTTPX
 
       @parser.reset!
       @max_requests -= 1
-      manage_connection(response)
+      if response.is_a?(ErrorResponse)
+        disable
+      else
+        manage_connection(response)
+      end
 
       send(@pending.shift) unless @pending.empty?
     end

data/lib/httpx/connection/http2.rb

@@ -314,6 +314,7 @@ module HTTPX
         ex = Error.new(stream.id, error)
         ex.set_backtrace(caller)
         response = ErrorResponse.new(request, ex, request.options)
+        request.response = response
         emit(:response, request, response)
       else
         response = request.response

data/lib/httpx/domain_name.rb

@@ -63,7 +63,7 @@ module HTTPX
       # Normalizes a _domain_ using the Punycode algorithm as necessary.
       # The result will be a downcased, ASCII-only string.
       def normalize(domain)
-        domain = domain.ascii_only? ? domain : domain.chomp(DOT).unicode_normalize(:nfc)
+        domain = domain.chomp(DOT).unicode_normalize(:nfc) unless domain.ascii_only?
         Punycode.encode_hostname(domain).downcase
       end
     end

data/lib/httpx/io/tcp.rb

@@ -38,7 +38,10 @@ module HTTPX
         add_addresses(addresses)
       end
       @ip_index = @addresses.size - 1
-      # @io ||= build_socket
+    end
+
+    def socket
+      @io.to_io
     end
 
     def add_addresses(addrs)

data/lib/httpx/plugins/authentication/digest.rb

@@ -45,7 +45,6 @@ module HTTPX
             raise DigestError, "unknown algorithm \"#{alg}\"" unless algorithm
 
             sess = Regexp.last_match(2)
-            params.delete("algorithm")
           else
             algorithm = ::Digest::MD5
           end
@@ -77,11 +76,11 @@ module HTTPX
             %(response="#{algorithm.hexdigest(request_digest)}"),
           ]
           header << %(realm="#{params["realm"]}") if params.key?("realm")
-          header << %(algorithm=#{params["algorithm"]}") if params.key?("algorithm")
-          header << %(opaque="#{params["opaque"]}") if params.key?("opaque")
+          header << %(algorithm=#{params["algorithm"]}) if params.key?("algorithm")
           header << %(cnonce="#{cnonce}") if cnonce
           header << %(nc=#{nc})
           header << %(qop=#{qop}) if qop
+          header << %(opaque="#{params["opaque"]}") if params.key?("opaque")
           header.join ", "
         end
 

data/lib/httpx/plugins/circuit_breaker.rb

@@ -31,6 +31,16 @@ module HTTPX
           @circuit_store = orig.instance_variable_get(:@circuit_store).dup
         end
 
+        %i[circuit_open].each do |meth|
+          class_eval(<<-MOD, __FILE__, __LINE__ + 1)
+        def on_#{meth}(&blk)   # def on_circuit_open(&blk)
+          on(:#{meth}, &blk)   #   on(:circuit_open, &blk)
+        end                    # end
+          MOD
+        end
+
+        private
+
         def send_requests(*requests)
           # @type var short_circuit_responses: Array[response]
           short_circuit_responses = []
@@ -59,6 +69,12 @@ module HTTPX
         end
 
         def on_response(request, response)
+          emit(:circuit_open, request) if try_circuit_open(request, response)
+
+          super
+        end
+
+        def try_circuit_open(request, response)
           if response.is_a?(ErrorResponse)
             case response.error
             when RequestTimeoutError
@@ -69,8 +85,6 @@ module HTTPX
           elsif (break_on = request.options.circuit_breaker_break_on) && break_on.call(response)
             @circuit_store.try_open(request.uri, response)
           end
-
-          super
         end
       end
 

data/lib/httpx/plugins/digest_authentication.rb

@@ -22,7 +22,7 @@ module HTTPX
 
       module OptionsMethods
         def option_digest(value)
-          raise TypeError, ":digest must be a Digest" unless value.is_a?(Authentication::Digest)
+          raise TypeError, ":digest must be a #{Authentication::Digest}" unless value.is_a?(Authentication::Digest)
 
           value
         end

data/lib/httpx/plugins/oauth.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # https://gitlab.com/os85/httpx/wikis/OAuth
+    #
+    module OAuth
+      class << self
+        def load_dependencies(_klass)
+          require_relative "authentication/basic"
+        end
+      end
+
+      SUPPORTED_GRANT_TYPES = %w[client_credentials refresh_token].freeze
+      SUPPORTED_AUTH_METHODS = %w[client_secret_basic client_secret_post].freeze
+
+      class OAuthSession
+        attr_reader :token_endpoint_auth_method, :grant_type, :client_id, :client_secret, :access_token, :refresh_token, :scope
+
+        def initialize(
+          issuer:,
+          client_id:,
+          client_secret:,
+          access_token: nil,
+          refresh_token: nil,
+          scope: nil,
+          token_endpoint: nil,
+          response_type: nil,
+          grant_type: nil,
+          token_endpoint_auth_method: "client_secret_basic"
+        )
+          @issuer = URI(issuer)
+          @client_id = client_id
+          @client_secret = client_secret
+          @token_endpoint = URI(token_endpoint) if token_endpoint
+          @response_type = response_type
+          @scope = case scope
+                   when String
+                     scope.split
+                   when Array
+                     scope
+          end
+          @access_token = access_token
+          @refresh_token = refresh_token
+          @token_endpoint_auth_method = String(token_endpoint_auth_method)
+          @grant_type = grant_type || (@refresh_token ? "refresh_token" : "client_credentials")
+
+          unless SUPPORTED_AUTH_METHODS.include?(@token_endpoint_auth_method)
+            raise Error, "#{@token_endpoint_auth_method} is not a supported auth method"
+          end
+
+          return if SUPPORTED_GRANT_TYPES.include?(@grant_type)
+
+          raise Error, "#{@grant_type} is not a supported grant type"
+        end
+
+        def token_endpoint
+          @token_endpoint || "#{@issuer}/token"
+        end
+
+        def load(http)
+          return unless @token_endpoint && @token_endpoint_auth_method && @grant_type && @scope
+
+          metadata = http.get("#{issuer}/.well-known/oauth-authorization-server").raise_for_status.json
+
+          @token_endpoint = metadata["token_endpoint"]
+          @scope = metadata["scopes_supported"]
+          @grant_type = Array(metadata["grant_types_supported"]).find { |gr| SUPPORTED_GRANT_TYPES.include?(gr) }
+          @token_endpoint_auth_method = Array(metadata["token_endpoint_auth_methods_supported"]).find do |am|
+            SUPPORTED_AUTH_METHODS.include?(am)
+          end
+        end
+
+        def merge(other)
+          obj = dup
+
+          case other
+          when OAuthSession
+            other.instance_variables.each do |ivar|
+              val = other.instance_variable_get(ivar)
+              next unless val
+
+              obj.instance_variable_set(ivar, val)
+            end
+          when Hash
+            other.each do |k, v|
+              obj.instance_variable_set(:"@#{k}", v) if obj.instance_variable_defined?(:"@#{k}")
+            end
+          end
+          obj
+        end
+      end
+
+      module OptionsMethods
+        def option_oauth_session(value)
+          case value
+          when Hash
+            OAuthSession.new(**value)
+          when OAuthSession
+            value
+          else
+            raise TypeError, ":oauth_session must be a #{OAuthSession}"
+          end
+        end
+      end
+
+      module InstanceMethods
+        def oauth_authentication(**args)
+          with(oauth_session: OAuthSession.new(**args))
+        end
+
+        def with_access_token
+          oauth_session = @options.oauth_session
+
+          oauth_session.load(self)
+
+          grant_type = oauth_session.grant_type
+
+          headers = {}
+          form_post = { "grant_type" => grant_type, "scope" => Array(oauth_session.scope).join(" ") }.compact
+
+          # auth
+          case oauth_session.token_endpoint_auth_method
+          when "client_secret_basic"
+            headers["authorization"] = Authentication::Basic.new(oauth_session.client_id, oauth_session.client_secret).authenticate
+          when "client_secret_post"
+            form_post["client_id"] = oauth_session.client_id
+            form_post["client_secret"] = oauth_session.client_secret
+          end
+
+          case grant_type
+          when "client_credentials"
+            # do nothing
+          when "refresh_token"
+            form_post["refresh_token"] = oauth_session.refresh_token
+          end
+
+          token_request = build_request("POST", oauth_session.token_endpoint, headers: headers, form: form_post)
+          token_request.headers.delete("authorization") unless oauth_session.token_endpoint_auth_method == "client_secret_basic"
+
+          token_response = request(token_request)
+          token_response.raise_for_status
+
+          payload = token_response.json
+
+          access_token = payload["access_token"]
+          refresh_token = payload["refresh_token"]
+
+          with(oauth_session: oauth_session.merge(access_token: access_token, refresh_token: refresh_token))
+        end
+
+        def build_request(*, _)
+          request = super
+
+          return request if request.headers.key?("authorization")
+
+          oauth_session = @options.oauth_session
+
+          return request unless oauth_session && oauth_session.access_token
+
+          request.headers["authorization"] = "Bearer #{oauth_session.access_token}"
+
+          request
+        end
+      end
+    end
+    register_plugin :oauth, OAuth
+  end
+end

data/lib/httpx/plugins/proxy/http.rb

@@ -6,6 +6,12 @@ module HTTPX
   module Plugins
     module Proxy
       module HTTP
+        class << self
+          def extra_options(options)
+            options.merge(supported_proxy_protocols: options.supported_proxy_protocols + %w[http])
+          end
+        end
+
         module InstanceMethods
           def with_proxy_basic_auth(opts)
             with(proxy: opts.merge(scheme: "basic"))

data/lib/httpx/plugins/proxy/socks4.rb

@@ -16,6 +16,12 @@ module HTTPX
 
         Error = Socks4Error
 
+        class << self
+          def extra_options(options)
+            options.merge(supported_proxy_protocols: options.supported_proxy_protocols + PROTOCOLS)
+          end
+        end
+
         module ConnectionMethods
           def interests
             if @state == :connecting

data/lib/httpx/plugins/proxy/socks5.rb

@@ -18,8 +18,14 @@ module HTTPX
 
         Error = Socks5Error
 
-        def self.load_dependencies(*)
-          require_relative "../authentication/socks5"
+        class << self
+          def load_dependencies(*)
+            require_relative "../authentication/socks5"
+          end
+
+          def extra_options(options)
+            options.merge(supported_proxy_protocols: options.supported_proxy_protocols + %w[socks5])
+          end
         end
 
         module ConnectionMethods

data/lib/httpx/plugins/proxy.rb

@@ -25,6 +25,10 @@ module HTTPX
           klass.plugin(:"proxy/socks5")
         end
 
+        def extra_options(options)
+          options.merge(supported_proxy_protocols: [])
+        end
+
         if URI::Generic.methods.include?(:use_proxy?)
           def use_proxy?(*args)
             URI::Generic.use_proxy?(*args)
@@ -118,6 +122,12 @@ module HTTPX
         def option_proxy(value)
           value.is_a?(Parameters) ? value : Hash[value]
         end
+
+        def option_supported_proxy_protocols(value)
+          raise TypeError, ":supported_proxy_protocols must be an Array" unless value.is_a?(Array)
+
+          value.map(&:to_s)
+        end
       end
 
       module InstanceMethods
@@ -142,8 +152,12 @@ module HTTPX
             next_proxy = @_proxy_uris.first
             raise Error, "Failed to connect to proxy" unless next_proxy
 
+            next_proxy = URI(next_proxy)
+
+            raise Error,
+                  "#{next_proxy.scheme}: unsupported proxy protocol" unless options.supported_proxy_protocols.include?(next_proxy.scheme)
+
             if proxy.key?(:no_proxy)
-              next_proxy = URI(next_proxy)
 
               no_proxy = proxy[:no_proxy]
               no_proxy = no_proxy.join(",") if no_proxy.is_a?(Array)
@@ -170,11 +184,7 @@ module HTTPX
           proxy = options.proxy
           return super unless proxy
 
-          connection = options.connection_class.new("tcp", uri, options)
-          catch(:coalesced) do
-            pool.init_connection(connection, options)
-            connection
-          end
+          init_connection("tcp", uri, options)
         end
 
         def fetch_response(request, connections, options)
@@ -257,10 +267,11 @@ module HTTPX
         end
 
         def send(request)
-          return super unless @options.proxy
-          return super unless connecting?
+          return super unless (
+            @options.proxy && @state != :idle && connecting?
+          )
 
-          @pending << request
+          (@proxy_pending ||= []) << request
         end
 
         def connecting?
@@ -298,6 +309,12 @@ module HTTPX
           when :idle
             transition(:connecting)
           when :connected
+            if @proxy_pending
+              while (req = @proxy_pendind.shift)
+                send(req)
+              end
+            end
+
             transition(:open)
           end
         end

data/lib/httpx/plugins/response_cache/file_store.rb

@@ -1,34 +1,39 @@
-# # frozen_string_literal: true
-
-# require "mutex_m"
-# require "forwardable"
-
-# module HTTPX::Plugins
-#   module ResponseCache
-#     class FileStore < Store
-#       def initialize(dir = Dir.tmpdir)
-#         @dir = Pathname.new(dir)
-#         @store = {}
-#         @hash_store.extend(Mutex_m)
-#       end
-
-#       def clear
-#         @store.synchronize { @store.clear }
-#       end
-
-#       def _get(request)
-#         return unless File.exist?(@dir.join(request.response_cache_key))
-
-#         @store.synchronize { @store[key] }
-#       end
-
-#       def set(key)
-#         @store.synchronize do
-#           resps = (@store[key] ||= [])
-
-#           yield resps
-#         end
-#       end
-#     end
-#   end
-# end
+# frozen_string_literal: true
+
+require "pathname"
+
+module HTTPX::Plugins
+  module ResponseCache
+    class FileStore < Store
+      def initialize(dir = Dir.tmpdir)
+        @dir = Pathname.new(dir)
+      end
+
+      def clear
+        # delete all files
+      end
+
+      def cached?(request)
+        file_path = @dir.join(request.response_cache_key)
+
+        exist?(file_path)
+      end
+
+      private
+
+      def _get(request)
+        return unless cached?(request)
+
+        File.open(@dir.join(request.response_cache_key))
+      end
+
+      def _set(request, response)
+        file_path = @dir.join(request.response_cache_key)
+
+        response.copy_to(file_path)
+
+        response.body.rewind
+      end
+    end
+  end
+end

data/lib/httpx/plugins/response_cache/store.rb

@@ -1,28 +1,25 @@
 # frozen_string_literal: true
 
-require "forwardable"
+require "mutex_m"
 
 module HTTPX::Plugins
   module ResponseCache
     class Store
-      extend Forwardable
-
-      def_delegator :@store, :clear
-
       def initialize
         @store = {}
+        @store.extend(Mutex_m)
+      end
+
+      def clear
+        @store.synchronize { @store.clear }
       end
 
       def lookup(request)
-        responses = @store[request.response_cache_key]
+        responses = _get(request)
 
         return unless responses
 
-        response = responses.find(&method(:match_by_vary?).curry(2)[request])
-
-        return unless response && response.fresh?
-
-        response
+        responses.find(&method(:match_by_vary?).curry(2)[request])
       end
 
       def cached?(request)
@@ -32,11 +29,7 @@ module HTTPX::Plugins
       def cache(request, response)
         return unless ResponseCache.cacheable_request?(request) && ResponseCache.cacheable_response?(response)
 
-        responses = (@store[request.response_cache_key] ||= [])
-
-        responses.reject!(&method(:match_by_vary?).curry(2)[request])
-
-        responses << response
+        _set(request, response)
       end
 
       def prepare(request)
@@ -71,6 +64,32 @@ module HTTPX::Plugins
           !original_request.headers.key?(cache_field) || request.headers[cache_field] == original_request.headers[cache_field]
         end
       end
+
+      def _get(request)
+        @store.synchronize do
+          responses = @store[request.response_cache_key]
+
+          return unless responses
+
+          responses.select! do |res|
+            !res.body.closed? && res.fresh?
+          end
+
+          responses
+        end
+      end
+
+      def _set(request, response)
+        @store.synchronize do
+          responses = (@store[request.response_cache_key] ||= [])
+
+          responses.reject! do |res|
+            res.body.closed? || !res.fresh? || match_by_vary?(request, res)
+          end
+
+          responses << response
+        end
+      end
     end
   end
 end

data/lib/httpx/plugins/response_cache.rb

@@ -102,9 +102,9 @@ module HTTPX
 
       module ResponseMethods
         def copy_from_cached(other)
-          @body = other.body
+          @body = other.body.dup
 
-          @body.__send__(:rewind)
+          @body.rewind
         end
 
         # A response is fresh if its age has not yet exceeded its freshness lifetime.
@@ -169,7 +169,7 @@ module HTTPX
         def date
           @date ||= Time.httpdate(@headers["date"])
         rescue NoMethodError, ArgumentError
-          Time.now.httpdate
+          Time.now
         end
       end
     end

data/lib/httpx/request.rb

@@ -95,6 +95,8 @@ module HTTPX
         return
       end
       @response = response
+
+      emit(:response_started, response)
     end
 
     def path
@@ -130,8 +132,10 @@ module HTTPX
       return nil if @body.nil?
 
       @drainer ||= @body.each
-      chunk = @drainer.next
-      chunk.dup
+      chunk = @drainer.next.dup
+
+      emit(:body_chunk, chunk)
+      chunk
     rescue StopIteration
       nil
     rescue StandardError => e

data/lib/httpx/resolver/multi.rb

@@ -53,7 +53,7 @@ module HTTPX
 
         next if !addrs || addrs.empty?
 
-        resolver.emit_addresses(connection, resolver.family, addrs)
+        resolver.emit_addresses(connection, resolver.family, addrs, true)
       end
     end
 

data/lib/httpx/resolver/resolver.rb

@@ -46,13 +46,13 @@ module HTTPX
       true
     end
 
-    def emit_addresses(connection, family, addresses)
+    def emit_addresses(connection, family, addresses, early_resolve = false)
       addresses.map! do |address|
         address.is_a?(IPAddr) ? address : IPAddr.new(address.to_s)
       end
 
-      # double emission check
-      return if connection.addresses && !addresses.intersect?(connection.addresses)
+      # double emission check, but allow early resolution to work
+      return if !early_resolve && connection.addresses && !addresses.intersect?(connection.addresses)
 
       log { "resolver: answer #{FAMILY_TYPES[RECORD_TYPES[family]]} #{connection.origin.host}: #{addresses.inspect}" }
       if @pool && # if triggered by early resolve, pool may not be here yet
@@ -87,7 +87,7 @@ module HTTPX
 
       return if addresses.empty?
 
-      emit_addresses(connection, @family, addresses)
+      emit_addresses(connection, @family, addresses, true)
     end
 
     def emit_resolve_error(connection, hostname = connection.origin.host, ex = nil)

data/lib/httpx/response.rb

@@ -9,6 +9,7 @@ require "forwardable"
 module HTTPX
   class Response
     extend Forwardable
+    include Callbacks
 
     attr_reader :status, :headers, :body, :version
 
@@ -139,6 +140,12 @@ module HTTPX
         @state = :idle
       end
 
+      def initialize_dup(other)
+        super
+
+        @buffer = other.instance_variable_get(:@buffer).dup
+      end
+
       def closed?
         @state == :closed
       end
@@ -146,9 +153,13 @@ module HTTPX
       def write(chunk)
         return if @state == :closed
 
-        @length += chunk.bytesize
+        size = chunk.bytesize
+        @length += size
         transition
         @buffer.write(chunk)
+
+        @response.emit(:chunk_received, chunk)
+        size
       end
 
       def read(*args)

data/lib/httpx/session.rb

@@ -4,6 +4,7 @@ module HTTPX
   class Session
     include Loggable
     include Chainable
+    include Callbacks
 
     EMPTY_HASH = {}.freeze
 
@@ -45,6 +46,31 @@ module HTTPX
       request = rklass.new(verb, uri, options.merge(persistent: @persistent))
       request.on(:response, &method(:on_response).curry(2)[request])
       request.on(:promise, &method(:on_promise))
+
+      request.on(:headers) do
+        emit(:request_started, request)
+      end
+      request.on(:body_chunk) do |chunk|
+        emit(:request_body_chunk, request, chunk)
+      end
+      request.on(:done) do
+        emit(:request_completed, request)
+      end
+
+      request.on(:response_started) do |res|
+        if res.is_a?(Response)
+          emit(:response_started, request, res)
+          res.on(:chunk_received) do |chunk|
+            emit(:response_body_chunk, request, res, chunk)
+          end
+        else
+          emit(:request_error, request, res.error)
+        end
+      end
+      request.on(:response) do |res|
+        emit(:response_completed, request, res)
+      end
+
       request
     end
 
@@ -174,7 +200,16 @@ module HTTPX
           raise UnsupportedSchemeError, "#{uri}: #{uri.scheme}: unsupported URI scheme"
         end
       end
+      init_connection(type, uri, options)
+    end
+
+    def init_connection(type, uri, options)
       connection = options.connection_class.new(type, uri, options)
+      connection.on(:open) do
+        emit(:connection_opened, connection.origin, connection.io.socket)
+        # only run close callback if it opened
+        connection.on(:close) { emit(:connection_closed, connection.origin, connection.io.socket) }
+      end
       catch(:coalesced) do
         pool.init_connection(connection, options)
         connection
@@ -252,6 +287,7 @@ module HTTPX
         super
         klass.instance_variable_set(:@default_options, @default_options)
         klass.instance_variable_set(:@plugins, @plugins.dup)
+        klass.instance_variable_set(:@callbacks, @callbacks.dup)
       end
 
       def plugin(pl, options = nil, &block)

data/lib/httpx/session_extensions.rb

@@ -9,10 +9,13 @@ module HTTPX
     # redefine the default options static var, which needs to
     # refresh options_class
     options = proxy_session.class.default_options.to_hash
-    options.freeze
     original_verbosity = $VERBOSE
     $VERBOSE = nil
+    const_set(:Options, proxy_session.class.default_options.options_class)
+    options[:options_class] = Class.new(options[:options_class])
+    options.freeze
     Options.send(:const_set, :DEFAULT_OPTIONS, options)
+    Session.instance_variable_set(:@default_options, Options.new(options))
     $VERBOSE = original_verbosity
   end
 

data/lib/httpx/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HTTPX
-  VERSION = "0.23.4"
+  VERSION = "0.24.1"
 end

data/sig/callbacks.rbs

@@ -4,9 +4,9 @@ module HTTPX
   end
 
   module Callbacks
-    def on: (Symbol) { (*untyped) -> void } -> void
-    def once: (Symbol) { (*untyped) -> void } -> void
-    def only: (Symbol) { (*untyped) -> void } -> void
+    def on: (Symbol) { (*untyped) -> void } -> self
+    def once: (Symbol) { (*untyped) -> void } -> self
+    def only: (Symbol) { (*untyped) -> void } -> self
     def emit: (Symbol, *untyped) -> void
 
     def callbacks_for?: (Symbol) -> bool

data/sig/chainable.rbs

@@ -34,6 +34,7 @@ module HTTPX
               | (:grpc, ?options) -> Plugins::grpcSession
               | (:response_cache, ?options) -> Plugins::sessionResponseCache
               | (:circuit_breaker, ?options) -> Plugins::sessionCircuitBreaker
+              | (:oauth, ?options) -> Plugins::sessionOAuth
               | (Symbol | Module, ?options) { (Class) -> void } -> Session
               | (Symbol | Module, ?options) -> Session
 

data/sig/plugins/circuit_breaker.rbs

@@ -5,7 +5,7 @@ module HTTPX
       class CircuitStore
         @circuits: Hash[String, Circuit]
 
-        def try_open: (generic_uri uri, response response) -> void
+        def try_open: (generic_uri uri, response response) -> response?
 
         def try_respond: (Request request) -> response?
 
@@ -30,7 +30,7 @@ module HTTPX
 
         def respond: () -> response?
 
-        def try_open: (response) -> void
+        def try_open: (response) -> response?
 
         def try_close: () -> void
 
@@ -52,6 +52,10 @@ module HTTPX
 
       module InstanceMethods
         @circuit_store: CircuitStore
+
+        private
+
+        def try_circuit_open: (Request request, response response) -> response?
       end
 
     end

data/sig/plugins/oauth.rbs

@@ -0,0 +1,54 @@
+module HTTPX
+  module Plugins
+    #
+    # https://gitlab.com/os85/httpx/wikis/OAuth
+    #
+    module OAuth
+      def self.load_dependencies: (singleton(Session) klass) -> void
+
+      type grant_type = "client_credentials" | "refresh_token"
+
+      type token_auth_method = "client_secret_basic" | "client_secret_post"
+
+      SUPPORTED_GRANT_TYPES: ::Array[grant_type]
+
+      SUPPORTED_AUTH_METHODS: ::Array[token_auth_method]
+
+      class OAuthSession
+        attr_reader token_endpoint_auth_method: token_auth_method
+
+        attr_reader grant_type: grant_type
+
+        attr_reader client_id: String
+
+        attr_reader client_secret: String
+
+        attr_reader access_token: String?
+
+        attr_reader refresh_token: String?
+
+        attr_reader scope: Array[String]?
+
+        def initialize: (issuer: uri, client_id: String, client_secret: String, ?access_token: String?, ?refresh_token: String?, ?scope: (Array[String] | String)?, ?token_endpoint: String?, ?response_type: String?, ?grant_type: String?, ?token_endpoint_auth_method: ::String) -> void
+
+        def token_endpoint: () -> String
+
+        def load: (Session http) -> void
+
+        def merge: (instance | Hash[untyped, untyped] other) -> instance
+      end
+
+      interface _AwsSdkOptions
+        def oauth_session: () -> OAuthSession?
+      end
+
+      module InstanceMethods
+        def oauth_authentication: (**untyped args) -> instance
+
+        def with_access_token: () -> instance
+      end
+    end
+
+    type sessionOAuth = Session & OAuth::InstanceMethods
+  end
+end

data/sig/plugins/response_cache.rbs

@@ -8,7 +8,7 @@ module HTTPX
       def self?.cached_response?: (response response) -> bool
 
       class Store
-        @store: Hash[String, Array[Response]]
+        @store: Hash[String, Array[Response]] & Mutex_m
 
         def lookup: (Request request) -> Response?
 
@@ -21,6 +21,10 @@ module HTTPX
         private
 
         def match_by_vary?: (Request request, Response response) -> bool
+
+        def _get: (Request request) -> Array[Response]?
+
+        def _set: (Request request, Response response) -> void
       end
 
       module InstanceMethods

data/sig/resolver/resolver.rbs

@@ -18,7 +18,7 @@ module HTTPX
 
       def empty?: () -> bool
 
-      def emit_addresses: (Connection connection, ip_family family, Array[IPAddr]) -> void
+      def emit_addresses: (Connection connection, ip_family family, Array[IPAddr], ?bool early_resolve) -> void
 
       private
 

data/sig/response.rbs

@@ -9,6 +9,7 @@ module HTTPX
 
   class Response
     extend Forwardable
+    include Callbacks
 
     include _Response
     include _ToS

data/sig/session.rbs

@@ -27,9 +27,9 @@ module HTTPX
     def on_promise: (untyped, untyped) -> void
     def fetch_response: (Request request, Array[Connection] connections, untyped options) -> response?
 
-    def find_connection: (Request, Array[Connection] connections, Options options) -> Connection
+    def find_connection: (Request request, Array[Connection] connections, Options options) -> Connection
 
-    def set_connection_callbacks: (Connection, Array[Connection], Options) -> void
+    def set_connection_callbacks: (Connection connection, Array[Connection] connections, Options options) -> void
 
     def build_altsvc_connection: (Connection existing_connection, Array[Connection] connections, URI::Generic alt_origin, String origin, Hash[String, String] alt_params, Options options) -> Connection?
 
@@ -39,13 +39,15 @@ module HTTPX
                       | (verb, _Each[[uri, options]], Options) -> Array[Request]
                       | (verb, _Each[uri], options) -> Array[Request]
 
-    def build_connection: (URI::HTTP | URI::HTTPS uri, Options options) -> Connection
+    def build_connection: (URI::HTTP | URI::HTTP uri, Options options) -> Connection
+
+    def init_connection: (String type, URI::HTTP | URI::HTTP uri, Options options) -> Connection
 
     def send_requests: (*Request) -> Array[response]
 
-    def _send_requests: (Array[Request]) -> Array[Connection]
+    def _send_requests: (Array[Request] requests) -> Array[Connection]
 
-    def receive_requests: (Array[Request], Array[Connection]) -> Array[response]
+    def receive_requests: (Array[Request] requests, Array[Connection] connections) -> Array[response]
 
     attr_reader self.default_options: Options
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: httpx
 version: !ruby/object:Gem::Version
-  version: 0.23.4
+  version: 0.24.1
 platform: ruby
 authors:
 - Tiago Cardoso
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-06-08 00:00:00.000000000 Z
+date: 2023-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http-2-next
@@ -99,6 +99,8 @@ extra_rdoc_files:
 - doc/release_notes/0_23_2.md
 - doc/release_notes/0_23_3.md
 - doc/release_notes/0_23_4.md
+- doc/release_notes/0_24_0.md
+- doc/release_notes/0_24_1.md
 - doc/release_notes/0_2_0.md
 - doc/release_notes/0_2_1.md
 - doc/release_notes/0_3_0.md
@@ -190,6 +192,8 @@ files:
 - doc/release_notes/0_23_2.md
 - doc/release_notes/0_23_3.md
 - doc/release_notes/0_23_4.md
+- doc/release_notes/0_24_0.md
+- doc/release_notes/0_24_1.md
 - doc/release_notes/0_2_0.md
 - doc/release_notes/0_2_1.md
 - doc/release_notes/0_3_0.md
@@ -268,6 +272,7 @@ files:
 - lib/httpx/plugins/multipart/mime_type_detector.rb
 - lib/httpx/plugins/multipart/part.rb
 - lib/httpx/plugins/ntlm_authentication.rb
+- lib/httpx/plugins/oauth.rb
 - lib/httpx/plugins/persistent.rb
 - lib/httpx/plugins/proxy.rb
 - lib/httpx/plugins/proxy/http.rb
@@ -349,6 +354,7 @@ files:
 - sig/plugins/h2c.rbs
 - sig/plugins/multipart.rbs
 - sig/plugins/ntlm_authentication.rbs
+- sig/plugins/oauth.rbs
 - sig/plugins/persistent.rbs
 - sig/plugins/proxy.rbs
 - sig/plugins/proxy/http.rbs
@@ -388,7 +394,7 @@ metadata:
   changelog_uri: https://os85.gitlab.io/httpx/#release-notes
   documentation_uri: https://os85.gitlab.io/httpx/rdoc/
   source_code_uri: https://gitlab.com/os85/httpx
-  homepage_uri: https://os85.gitlab.io/httpx/
+  homepage_uri: https://honeyryderchuck.gitlab.io/httpx/
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
@@ -405,7 +411,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.6
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: HTTPX, to the future, and beyond