httpx 1.8.1 → 1.8.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eece37bd091a7fea17ccc62eca63acaee714c08658d081a938fc38495a4c8813
-  data.tar.gz: 72dcd038803106f08a0317c8d7bc97d22d6cdf5c469ba8f8f9d380d00e8f5ea7
+  metadata.gz: daca70f040a0f0afcc413a6eb3b2e586ae56a5405477c0045cf226aaddf5b49c
+  data.tar.gz: 53910e19b4bf264a2d3cf4aed4298de57c4c6373f868e3d9e187140c15f2ed63
 SHA512:
-  metadata.gz: 5af43571f7da30f709883474fb61ef3661b31fa836d249c423726f4815fb7b2bf5c1281e22ca7ad15c00ed26b2ffc950d521b14a9f5c02e7d95d4198b4b986d0
-  data.tar.gz: bd73537be9a610b590d7897cd96f7b6213ece24ea7079ce995a3e05cbee363dcf0f575405ea8d2e612a64737e3bbc70dbdc25ab9a24f5b7e154b9a5187974ffe
+  metadata.gz: 8b19e3219fb672bfbb45c4e5427c68b9f7ba715003f5b39796a2314bd8b991b58c5bc185767e303557159f04d61d84c19523f25b953b604a74753e55859defb8
+  data.tar.gz: 844bf656335bdbc5599003d6ee9724ff54b05478bfa9de37d5e251acff788154d4d7cea4b866b56c7d4c42d07b1afa8ece6982b02c5236d981843f092ee25ceb

data/doc/release_notes/1_8_2.md

@@ -0,0 +1,30 @@
+# 1.8.2
+
+## Improvements
+
+* `:proxy` plugin: allow setting `:no_proxy` option to `"*"` (or `["*"]`) to allow bypassing proxy for all requests.
+* Extending sessions with unknown options will now raise an error, instead of silently ignoring them (consistent with the initialization case now):
+
+```ruby
+session = HTTPX.with(unknown_option: 1) # will raise a HTTPX::Error: unknown option: unknown_option
+```
+
+* Use `HTTP2::Connection#closed?` internally (instead of `#state`) to check for connection state; this will, in a future release of `http-2`, seamlessly support the new `:closing` state.
+* Add missing `response` attribute reader to `HTTPX::RequestTimeoutError`.
+* Improve correctness of calling `#dup` on requests and connections.
+
+## Bugfixes
+
+* `:auth` plugin: generate token first, then set the "expires_at" timestamp (bearer tokens, specially if JWT, may carry information about when it expires).
+* `:auth` plugin: do not check for token freshness on a retry, instead force token regeneration.
+* `:retries` plugin: do not apply "retry after" delay after a ping timeout error (the ping timeout already implies a delay, so retry on a new connection should be immediate).
+* `:retries` plugin: do not retry on any HTTP/2 frame error (only on GOAWAY or PING frame errors).
+* `:persistent` plugin: do not decrement request remaining retries on ping or GOAWAY frame errors.
+* `:tracing` plugin: set connection initialization time to nil no termination (so that it doesn't get reused on persistent connections after reuse).
+* `:follow_redirects` plugin: fixed issue when a timeout error would be raised but only bubble up to the root request, not properly closing the in-flight follow up request, and leaving the request handling phase in a broken state.
+* datadog adapter: the connection initialization time is now set only on connect or first request received, the reason, making it more accurate.
+* webmock adapter: `.to_timeout` helper will make the request raise a `HTTPX::RequestTimeoutError` instead of a plain `TimeoutError` (otherwise, if using persistent sessions, it'd trigger a retry instead and mess with webmock request count bookkeeping).
+* native resolver: do not transition to `:open` if the socket was closed during resolution (which happens when an error is raised while the query bytes are buffered).
+* fix for when setting a new session callback on an ssl context object which has been frozen after the first connection attempt (done by binding the ssl context callback to an internal ivar which can be changed).
+* connection: protect against `Errno::ETIMEDOUT` errors on socket close by forcing transition to closed.
+* do not set a ping timer for HTTP/1.1 on keep alive flow, as there's no ping and the connection is reestablished.

data/doc/release_notes/1_8_3.md

@@ -0,0 +1,9 @@
+# 1.8.3
+
+## Bugfixes
+
+options print a  warning instead of raising an error on unknown option
+
+the approach introduced in the previous version, of erroring on something people have been accidentally relying on, is too strict in hindsight for a patch version. This was reverted, and instead, a deprecation warning will be printed, to give time for folks to migrate.
+
+the format of options messages (exceptions and warnings) also slightly changes to wrap the option in quotes, for proper highlighting.

data/doc/release_notes/1_8_4.md

@@ -0,0 +1,13 @@
+# 1.8.4
+
+## Improvements
+
+* send requests which were not sent, or were not processed by the server, when the server sends back a GOAWAY frame (which is deemed recoverable, like when there's no error), after forcing a reconnection (instead of bubbling up the GOAWAY error for all of them).
+
+## Bugfixes
+
+* `:retries` plugin: also retry requests which failed due to a RST_STREAM frame with REFUSED_STREAM error code.
+* `:retries` plugin: resend requests which were piped to a closed connection internally.
+* `:proxy` plugin: fix issue related with reconnecting inactive connections shut down by the peer, when used with the `:persistent` plugin, where the CONNECT request wasn't being sent to establish the tunnel.
+* fixed compatibility issue starting with the `json` gem 3.0.0, when calling `HTTPX::Response#json`.
+* avoid bookkepping issue in session, where the `on_response_arrived` on a request may be called more than once (which it can happen in the `:follow_redirects` plugin, where a request may have completed due to an error, while the request is waiting to be resent due to `retry-after`).

data/lib/httpx/adapters/webmock.rb

@@ -34,7 +34,8 @@ module WebMock
         end
 
         def build_from_webmock_response(request, webmock_response)
-          return build_error_response(request, HTTPX::TimeoutError.new(1, "Timed out")) if webmock_response.should_timeout
+          return build_error_response(request,
+                                      HTTPX::RequestTimeoutError.new(request, webmock_response, 1)) if webmock_response.should_timeout
 
           return build_error_response(request, webmock_response.exception) if webmock_response.exception
 

data/lib/httpx/buffer.rb

@@ -46,6 +46,11 @@ module HTTPX
       def_delegator :@buffer, :<<
     end
 
+    def initialize_dup(other)
+      super
+      @buffer = other.instance_variable_get(:@buffer).dup
+    end
+
     def full?
       @buffer.bytesize >= @limit
     end

data/lib/httpx/callbacks.rb

@@ -14,9 +14,9 @@ module HTTPX
       end
     end
 
-    def emit(type, *args)
+    def emit(type, ...)
       log { "emit #{type.inspect} callbacks" } if respond_to?(:log)
-      callbacks(type).delete_if { |pr| :delete == pr.call(*args) } # rubocop:disable Style/YodaCondition
+      callbacks(type).delete_if { |pr| :delete == pr.call(...) } # rubocop:disable Style/YodaCondition
     end
 
     def callbacks_for?(type)

data/lib/httpx/chainable.rb

@@ -13,8 +13,8 @@ module HTTPX
     end
 
     # delegates to the default session (see HTTPX::Session#request).
-    def request(*args, **options)
-      branch(default_options).request(*args, **options)
+    def request(...)
+      branch(default_options).request(...)
     end
 
     def accept(type)

data/lib/httpx/connection/http1.rb

@@ -29,7 +29,7 @@ module HTTPX
       @version = [1, 1]
       @pending = []
       @requests = []
-      @request = nil
+      @callbacks = @request = nil
       @handshake_completed = @pipelining = false
     end
 

data/lib/httpx/connection/http2.rb

@@ -23,14 +23,35 @@ module HTTPX
     end
 
     class GoawayError < Error
-      def initialize(code = :no_error)
+      UNRECOVERABLE_ERRORS = %i[settings_timeout inadequate_security].freeze
+
+      def initialize(code, last_stream_id)
+        @code = code
+        @last_stream_id = last_stream_id
         super(0, code)
       end
+
+      def last_stream_id
+        return Float::INFINITY if unrecoverable?
+
+        @last_stream_id
+      end
+
+      def unrecoverable?
+        UNRECOVERABLE_ERRORS.include?(@code)
+      end
+    end
+
+    class RstStreamError < Error
+    end
+
+    class RefusedStreamError < RstStreamError
     end
 
     attr_reader :streams, :pending
 
     def initialize(buffer, options)
+      @callbacks = nil
       @options = options
       @settings = @options.http2_settings
       @pending = []
@@ -53,7 +74,7 @@ module HTTPX
     end
 
     def interests
-      if @connection.state == :closed
+      if @connection.closed?
         return unless @handshake_completed
 
         return if @buffer.empty?
@@ -94,7 +115,7 @@ module HTTPX
     end
 
     def close
-      unless @connection.state == :closed
+      unless @connection.closed?
         @connection.goaway
         emit(:timeout, @options.timeout[:close_handshake_timeout])
       end
@@ -102,7 +123,7 @@ module HTTPX
     end
 
     def empty?
-      @connection.state == :closed || @streams.empty?
+      @connection.closed? || @streams.empty?
     end
 
     def exhausted?
@@ -148,18 +169,43 @@ module HTTPX
     end
 
     def handle_error(ex, request = nil)
-      if ex.is_a?(OperationTimeoutError) && !@handshake_completed && @connection.state != :closed
-        @connection.goaway(:settings_timeout, "closing due to settings timeout")
-        emit(:close_handshake)
-        settings_ex = SettingsTimeoutError.new(ex.timeout, ex.message)
-        settings_ex.set_backtrace(ex.backtrace)
-        ex = settings_ex
-      end
-      while (req, _ = @streams.shift)
+      last_stream_id = Float::INFINITY
+      case ex
+      when OperationTimeoutError
+        if !@handshake_completed && @connection.state != :closed
+          @connection.goaway(:settings_timeout, "closing due to settings timeout")
+          emit(:close_handshake)
+          settings_ex = SettingsTimeoutError.new(ex.timeout, ex.message)
+          settings_ex.set_backtrace(ex.backtrace)
+          ex = settings_ex
+        end
+      when GoawayError
+        last_stream_id = ex.last_stream_id
+      end
+
+      inflight_unprocessed_requests = [] #: Array[Request]
+
+      while (req, stream = @streams.shift)
         next if request && request == req
 
+        if stream.id > last_stream_id
+          req.transition(:idle)
+          # unprocessed request
+          inflight_unprocessed_requests << req
+
+          next
+        end
+
         emit(:error, req, ex)
       end
+
+      if ex.is_a?(GoawayError) && !ex.unrecoverable?
+        # resend unprocessed requests on a different connection
+        @pending.unshift(*inflight_unprocessed_requests) if inflight_unprocessed_requests.any?
+        emit(:exhausted, ex) if @pending.any?
+        return
+      end
+
       while (req = @pending.shift)
         next if request && request == req
 
@@ -394,7 +440,14 @@ module HTTPX
         when :http_1_1_required
           emit(:error, request, error)
         else
-          ex = Error.new(stream.id, error)
+          ex =
+            case error
+            when :refused_stream
+              RefusedStreamError.new(stream.id, error)
+            else
+              RstStreamError.new(stream.id, error)
+            end
+
           ex.set_backtrace(caller)
           response = ErrorResponse.new(request, ex)
           request.response = response
@@ -431,8 +484,8 @@ module HTTPX
       send_pending
     end
 
-    def on_close(_last_frame, error, _payload)
-      is_connection_closed = @connection.state == :closed
+    def on_close(last_stream_id, error, _payload)
+      is_connection_closed = @connection.closed?
       if error
         @buffer.clear if is_connection_closed
         case error
@@ -441,12 +494,11 @@ module HTTPX
             emit(:error, request, error)
           end
         else
-          ex = GoawayError.new(error)
+          ex = GoawayError.new(error, last_stream_id)
           ex.set_backtrace(caller)
 
           handle_error(ex)
           teardown
-
         end
       end
       return unless is_connection_closed && @streams.empty?

data/lib/httpx/connection.rb

@@ -36,21 +36,25 @@ module HTTPX
 
     def_delegator :@write_buffer, :empty?
 
-    attr_reader :type, :io, :origin, :origins, :state, :pending, :options, :ssl_session, :sibling
+    attr_reader :type, :io, :origin, :origins, :state, :pending, :options, :ssl_session, :sibling,
+                :read_buffer, :write_buffer
 
     attr_writer :current_selector
 
     attr_accessor :current_session, :family
 
-    protected :ssl_session, :sibling
+    protected :ssl_session, :sibling, :read_buffer, :write_buffer
 
     def initialize(uri, options)
       @current_session = @current_selector = @max_concurrent_requests =
                            @parser = @sibling = @coalesced_connection = @altsvc_connection =
-                                                  @ping_timer = @family = @io = @ssl_session =
-                                                                            @timeout = @connected_at = @response_received_at = nil
+                                                  @callbacks = @ping_timer = @family =
+                                                                 @io = @ssl_session = @timeout = @connected_at = @response_received_at = nil
 
-      @exhausted = @cloned = @main_sibling = false
+      @exhausted = @cloned = @main_sibling =
+                     # variable used to gate against a potential endless loop where the peer continuously closes the connection with
+                     # GOAWAY frames without ever processing a request.
+                     @previously_exhausted_with_error = false
 
       @options = Options.new(options)
       @type = initialize_type(uri, @options)
@@ -76,6 +80,29 @@ module HTTPX
       self.addresses = @options.addresses if @options.addresses
     end
 
+    # dupped initialization
+    def initialize_dup(orig)
+      super
+      @callbacks = @parser = @sibling = @coalesced_connection = @altsvc_connection = nil
+      @origins = orig.origins.dup
+      @read_buffer = orig.read_buffer.dup
+      @write_buffer = orig.write_buffer.dup
+      @inflight = 0
+      @pending = []
+      transition(:idle)
+
+      if @io
+        # initialize new IO object with the same set of addresses
+        addresses = @io.addresses
+        @io = nil
+        self.addresses = addresses
+      end
+
+      return unless @current_session && @current_selector
+
+      @current_session.pin(self, @current_selector)
+    end
+
     def peer
       @origin
     end
@@ -148,11 +175,11 @@ module HTTPX
 
     def merge(connection)
       @origins |= connection.instance_variable_get(:@origins)
-      if @ssl_session.nil? && connection.ssl_session
-        @ssl_session = connection.ssl_session
-        @io.session_new_cb do |sess|
-          @ssl_session = sess
-        end if @io
+      if @ssl_session.nil? && (ssl_session = connection.ssl_session)
+        @ssl_session = ssl_session
+        # the socket only needs the merged session if it can still resume it,
+        # i.e. if TLS hasn't been negotiated yet.
+        @io.ssl_session = ssl_session if @io.is_a?(SSL) && !@io.connected?
       end
       connection.purge_pending do |req|
         req.transition(:idle)
@@ -341,7 +368,6 @@ module HTTPX
       end
 
       transition(:closing)
-
       transition(:closed)
     end
 
@@ -688,6 +714,7 @@ module HTTPX
         AltSvc.emit(request, response) do |alt_origin, origin, alt_params|
           build_altsvc_connection(alt_origin, origin, alt_params)
         end
+        @previously_exhausted_with_error = false
         @response_received_at = Utils.now
         @no_more_requests_counter = 0
         @inflight -= 1
@@ -703,9 +730,19 @@ module HTTPX
       parser.on(:promise) do |request, stream|
         request.emit(:promise, parser, stream)
       end
-      parser.on(:exhausted) do
+      parser.on(:exhausted) do |error|
         enqueue_pending_requests_from_parser(parser)
 
+        if error
+          if @previously_exhausted_with_error
+            @previously_exhausted_with_error = false
+            on_error(error)
+            next
+          else
+            @previously_exhausted_with_error = true
+          end
+        end
+
         @exhausted = true
         parser.close
 
@@ -775,14 +812,19 @@ module HTTPX
            Errno::ECONNRESET,
            Errno::EADDRNOTAVAIL,
            Errno::EHOSTUNREACH,
-           Errno::EINVAL,
            Errno::ENETUNREACH,
+           Errno::EHOSTDOWN,
+           Errno::ENETDOWN,
+           Errno::EINVAL,
            Errno::EPIPE,
            Errno::ENOENT,
            SocketError,
            IOError => e
       on_connect_error(e)
-    rescue TLSError, ::HTTP2::Error::ProtocolError, ::HTTP2::Error::HandshakeError => e
+    rescue TLSError,
+           Errno::ETIMEDOUT,
+           ::HTTP2::Error::ProtocolError,
+           ::HTTP2::Error::HandshakeError => e
       # connect errors, exit gracefully
       handle_error(e)
       handle_connect_error(e) if connecting?
@@ -979,6 +1021,8 @@ module HTTPX
 
       parser.ping
 
+      return unless parser.waiting_for_ping?
+
       ping_timeout = @options.timeout[:ping_timeout]
 
       @ping_timer = @current_selector.after(ping_timeout) do

data/lib/httpx/errors.rb

@@ -43,6 +43,9 @@ module HTTPX
     # The HTTPX::Request request object this exception refers to.
     attr_reader :request
 
+    # The response object this exception refers to.
+    attr_reader :response
+
     # initializes the exception with the +request+ and +response+ it refers to, and the
     # +timeout+ causing the error, and the
     def initialize(request, response, timeout)

data/lib/httpx/io/ssl.rb

@@ -6,20 +6,19 @@ module HTTPX
   TLSError = OpenSSL::SSL::SSLError
 
   class SSL < TCP
-    # rubocop:disable Style/MutableConstant
-    TLS_OPTIONS = { alpn_protocols: %w[h2 http/1.1].freeze }
-    # https://github.com/jruby/jruby-openssl/issues/284
+    tls_options = { alpn_protocols: %w[h2 http/1.1].freeze }
     # TODO: remove when dropping support for jruby-openssl < 0.15.4
-    TLS_OPTIONS[:verify_hostname] = true if RUBY_ENGINE == "jruby" && JOpenSSL::VERSION < "0.15.4"
-    # rubocop:enable Style/MutableConstant
-    TLS_OPTIONS.freeze
+    # https://github.com/jruby/jruby-openssl/issues/284
+    tls_options[:verify_hostname] = true if RUBY_ENGINE == "jruby" && JOpenSSL::VERSION < "0.15.4"
+    TLS_OPTIONS = tls_options.freeze
 
     attr_writer :ssl_session
 
     def initialize(_, _, options)
       super
 
-      @ssl_session = nil
+      @ssl_session = @session_new_cb = nil
+
       ctx_options = TLS_OPTIONS
       ctx_options = ctx_options.merge(options.ssl) if options.ssl && !options.ssl.empty?
       @sni_hostname = (ctx_options.delete(:hostname) if ctx_options.key?(:hostname)) || @hostname
@@ -35,6 +34,7 @@ module HTTPX
           @ctx.session_cache_mode =
             OpenSSL::SSL::SSLContext::SESSION_CACHE_CLIENT | OpenSSL::SSL::SSLContext::SESSION_CACHE_NO_INTERNAL_STORE
         end
+        init_session_new_cb
 
         yield(self) if block_given?
       end
@@ -43,14 +43,24 @@ module HTTPX
     end
 
     if OpenSSL::SSL::SSLContext.method_defined?(:session_new_cb=)
+      # sets the ssl session callback to be picked up by the ssl context.
       def session_new_cb(&pr)
-        @ctx.session_new_cb = proc { |_, sess| pr.call(sess) }
+        @session_new_cb = pr
+      end
+
+      # sets the ssl context's new session callback, which points at @session_new_cb when available.
+      def init_session_new_cb
+        @ctx.session_new_cb = proc { |_, sess| @session_new_cb&.call(sess) }
       end
     else
       # session_new_cb not implemented under JRuby
       def session_new_cb; end
+
+      def init_session_new_cb; end
     end
 
+    private :init_session_new_cb
+
     def protocol
       return super unless @io.is_a?(OpenSSL::SSL::SSLSocket)
 

data/lib/httpx/options.rb

@@ -133,12 +133,12 @@ module HTTPX
         when Options
           unknown_options = options.class.options_names - options_names
 
-          raise Error, "unknown option: #{unknown_options.first}" unless unknown_options.empty?
+          raise Error, "unknown option: `:#{unknown_options.first}`" unless unknown_options.empty?
 
           DEFAULT_OPTIONS.merge(options)
         else
           options.each_key do |k|
-            raise Error, "unknown option: #{k}" unless options_names.include?(k)
+            raise Error, "unknown option: `:#{k}`" unless options_names.include?(k)
           end
 
           options.empty? ? DEFAULT_OPTIONS : DEFAULT_OPTIONS.merge(options)
@@ -184,7 +184,7 @@ module HTTPX
                cache_type.respond_to?(:get) &&
                cache_type.respond_to?(:set) &&
                cache_type.respond_to?(:evict)
-          raise TypeError, ":resolver_cache must be a compatible resolver cache and implement #get, #set and #evict"
+          raise TypeError, "`:resolver_cache` must be a compatible resolver cache and implement `#get`, `#set` and `#evict`"
         end
 
         cache_type #: Object & Resolver::_Cache
@@ -257,12 +257,21 @@ module HTTPX
 
         other_opts = opts_names
       else
-        other_opts = other # : Hash[Symbol, untyped]
+        other_opts = other #: Hash[Symbol, untyped]
         other_opts = Hash[other] unless other.is_a?(Hash)
 
         return self if other_opts.empty?
 
-        return self if other_opts.all? { |opt, v| !respond_to?(opt) || public_send(opt) == v }
+        return self if other_opts.all? do |opt, v|
+          unless respond_to?(opt)
+            # TODO: do this instead in a major or minor version bump
+            # raise Error, "unknown option: #{opt}" unless respond_to?(opt)
+            warn "DEPRECATION WARNING: unknown option: `:#{opt}`. an exception will be raised in a future version."
+            next(true)
+          end
+
+          !respond_to?(opt) || public_send(opt) == v
+        end
       end
 
       opts = dup
@@ -400,7 +409,7 @@ module HTTPX
         # converts +v+ into an Integer before setting the +#{option}+ option.
         private def option_#{option}(value)                                             # private def option_max_requests(v)
           value = Integer(value) unless value.respond_to?(:infinite?) && value.infinite?
-          raise TypeError, ":#{option} must be positive" unless value.positive? # raise TypeError, ":max_requests must be positive" unless value.positive?
+          raise TypeError, "`:#{option}` must be positive" unless value.positive? # raise TypeError, ":max_requests must be positive" unless value.positive?
 
           value
         end
@@ -452,11 +461,11 @@ module HTTPX
 
       # Validate keys and values
       timeout_hash.each do |key, val|
-        raise TypeError, "invalid timeout: :#{key}" unless default_timeouts.key?(key)
+        raise TypeError, "invalid timeout: `:#{key}`" unless default_timeouts.key?(key)
 
         next if val.nil?
 
-        raise TypeError, ":#{key} must be numeric" unless val.is_a?(Numeric)
+        raise TypeError, "`:#{key}` must be numeric" unless val.is_a?(Numeric)
       end
 
       timeout_hash
@@ -486,15 +495,15 @@ module HTTPX
       when Symbol
         meth = :"resolver_#{resolver_type}_class"
 
-        raise TypeError, ":resolver_class must be a supported type" unless respond_to?(meth)
+        raise TypeError, "`:resolver_class` must be a supported type" unless respond_to?(meth)
 
         resolver_type
       when Class
-        raise TypeError, ":resolver_class must be a subclass of `#{Resolver::Resolver}`" unless resolver_type < Resolver::Resolver
+        raise TypeError, "`:resolver_class` must be a subclass of `#{Resolver::Resolver}`" unless resolver_type < Resolver::Resolver
 
         resolver_type
       else
-        raise TypeError, ":resolver_class must be a supported type"
+        raise TypeError, "`:resolver_class` must be a supported type"
       end
     end
 
@@ -509,7 +518,7 @@ module HTTPX
                cache_type.respond_to?(:get) &&
                cache_type.respond_to?(:set) &&
                cache_type.respond_to?(:evict)
-          raise TypeError, ":resolver_cache must be a compatible resolver cache and implement #resolve, #get, #set and #evict"
+          raise TypeError, "`:resolver_cache` must be a compatible resolver cache and implement `#resolve`, `#get`, `#set` and `#evict`"
         end
       end
 

data/lib/httpx/plugins/auth.rb

@@ -19,6 +19,8 @@ module HTTPX
       # adds support for the following options:
       #
       # :auth_header_value :: the token to use as a string, or a callable which returns a string when called.
+      #                       the callable is called a request, and a boolean: when true, the user must regenerate a token, otherwise it
+      #                       may probe for token freshness and return the same token.
       # :auth_header_type :: the authentication type to use in the "authorization" header value (i.e. "Bearer", "Digest"...)
       # :auth_header_expires_at :: timestamp at which the auth header will be discarded. should be a callable (like a proc)
       #                            receiving the request as an argument, and should return either a Time object, or an integer (UNIX time).
@@ -96,9 +98,8 @@ module HTTPX
           auth_header_value = @auth_header_value_mtx.synchronize do
             try_invalidate_auth_header_value
 
-            @auth_header_value ||= begin
+            @auth_header_value ||= generate_auth_token(request, false).tap do
               set_auth_header_expires_at(request)
-              generate_auth_token
             end
           end
 
@@ -115,10 +116,10 @@ module HTTPX
           @auth_header_value = @auth_header_expires_at = nil
         end
 
-        def generate_auth_token
+        def generate_auth_token(request, should_regenerate)
           return unless (auth_value = @options.auth_header_value)
 
-          auth_value = auth_value.call(self) if dynamic_auth_token?(auth_value)
+          auth_value = auth_value.call(request, should_regenerate) if dynamic_auth_token?(auth_value)
 
           auth_value
         end
@@ -196,7 +197,7 @@ module HTTPX
             # use whatever was generated for it.
             @auth_header_value_mtx.synchronize do
               if request.auth_token_value == @auth_header_value
-                @auth_header_value = generate_auth_token
+                @auth_header_value = generate_auth_token(request, true)
                 set_auth_header_expires_at(request)
               end
             end

data/lib/httpx/plugins/cookies/cookie.rb

@@ -68,7 +68,7 @@ module HTTPX
       end
 
       class << self
-        def new(cookie, *args)
+        def new(cookie, *)
           case cookie
           when self
             cookie

data/lib/httpx/plugins/cookies.rb

@@ -46,8 +46,8 @@ module HTTPX
 
         # factory method to return a Jar to the user, which can then manipulate
         # externally to the session.
-        def make_jar(*args)
-          Jar.new(*args)
+        def make_jar(...)
+          Jar.new(...)
         end
 
         private