patient_http 1.4.0 → 1.6.0

data/lib/patient_http/configuration.rb

@@ -15,6 +15,16 @@ module PatientHttp
     # @return [Integer] Maximum number of concurrent connections
     attr_reader :max_connections
 
+    # @return [Integer, nil] Maximum number of connections per host (nil for unlimited)
+    attr_reader :max_connections_per_host
+
+    # @return [Integer] Number of threads that deliver completed results
+    attr_reader :completion_threads
+
+    # @return [Integer] Number of retries when delivering a completed result fails.
+    #   A retry calls the task handler again, so handlers must be idempotent.
+    attr_reader :completion_retries
+
     # @return [Numeric] Default request timeout in seconds
     attr_reader :request_timeout
 
@@ -33,6 +43,15 @@ module PatientHttp
     # @return [Integer] Maximum number of redirects to follow (0 disables redirects)
     attr_reader :max_redirects
 
+    # @return [Boolean] Whether a redirect that requires changing the HTTP method
+    #   (for example POST to GET on a 302) may be followed. When false, such a
+    #   redirect response is returned as the result instead of being followed.
+    attr_reader :follow_method_changing_redirects
+
+    # @return [Array<String>] Lowercase header names that are always stripped from
+    #   redirected requests
+    attr_reader :redirect_strip_headers
+
     # @return [Integer] This is the maximum number of hosts for which connections
     #   will be kept alive for at one time.
     attr_reader :connection_pool_size
@@ -63,11 +82,23 @@ module PatientHttp
     # @param user_agent [String, nil] Default User-Agent header value
     # @param raise_error_responses [Boolean] Whether to raise HttpError for non-2xx responses by default
     # @param max_redirects [Integer] Maximum number of redirects to follow (0 disables redirects)
+    # @param follow_method_changing_redirects [Boolean] Whether to follow a redirect that requires changing the
+    #   HTTP method, such as POST to GET on a 301, 302, or 303 response. When false, requests
+    #   whose method would change do not follow the redirect and receive the redirect response.
+    # @param redirect_strip_headers [String, Array<String>] Header names (case insensitive)
+    #   that are always stripped from redirected requests, so sensitive headers are never
+    #   sent to a redirect target
     # @param connection_pool_size [Integer] Maximum number of host clients to pool
     # @param connection_timeout [Numeric, nil] Connection timeout in seconds
     # @param proxy_url [String, nil] HTTP/HTTPS proxy URL (supports authentication)
     # @param retries [Integer] Number of retries for failed requests
     # @param protocol [Symbol, nil] HTTP protocol to use (:http1 or :http2); nil to negotiate
+    # @param max_connections_per_host [Integer, nil] Maximum number of connections per host (nil for unlimited)
+    # @param completion_threads [Integer] Number of threads that deliver completed results
+    # @param completion_retries [Integer] Number of retries when delivering a completed result fails.
+    #   A retry calls TaskHandler#on_complete or #on_error again, so a handler that raises after
+    #   its side effect delivers the callback more than once unless it is idempotent. Set to 0 to
+    #   report the first failure without retrying.
     def initialize(
       max_connections: 256,
       request_timeout: 60,
@@ -77,12 +108,17 @@ module PatientHttp
       user_agent: "PatientHttp",
       raise_error_responses: false,
       max_redirects: 5,
+      follow_method_changing_redirects: true,
+      redirect_strip_headers: [],
       connection_pool_size: 100,
       connection_timeout: nil,
       proxy_url: nil,
       retries: 3,
       protocol: nil,
-      encryption_key: nil
+      encryption_key: nil,
+      max_connections_per_host: nil,
+      completion_threads: 2,
+      completion_retries: 2
     )
       @mutex = Mutex.new
 
@@ -107,12 +143,17 @@ module PatientHttp
       self.user_agent = user_agent
       self.raise_error_responses = raise_error_responses
       self.max_redirects = max_redirects
+      self.follow_method_changing_redirects = follow_method_changing_redirects
+      self.redirect_strip_headers = redirect_strip_headers
       self.connection_pool_size = connection_pool_size
       self.connection_timeout = connection_timeout
       self.proxy_url = proxy_url
       self.retries = retries
       self.protocol = protocol
       self.encryption_key = encryption_key
+      self.max_connections_per_host = max_connections_per_host
+      self.completion_threads = completion_threads
+      self.completion_retries = completion_retries
     end
 
     # Get the logger to use to report pool events. Default is to log errors to STDERR.
@@ -124,6 +165,26 @@ module PatientHttp
       @max_connections = value
     end
 
+    def max_connections_per_host=(value)
+      if value.nil?
+        @max_connections_per_host = nil
+        return
+      end
+
+      validate_positive_integer(:max_connections_per_host, value)
+      @max_connections_per_host = value
+    end
+
+    def completion_threads=(value)
+      validate_positive_integer(:completion_threads, value)
+      @completion_threads = value
+    end
+
+    def completion_retries=(value)
+      validate_non_negative_integer(:completion_retries, value)
+      @completion_retries = value
+    end
+
     def request_timeout=(value)
       validate_positive(:request_timeout, value)
       @request_timeout = value
@@ -144,6 +205,18 @@ module PatientHttp
       @max_redirects = value
     end
 
+    def follow_method_changing_redirects=(value)
+      unless value == true || value == false
+        raise ArgumentError.new("follow_method_changing_redirects must be true or false, got: #{value.inspect}")
+      end
+
+      @follow_method_changing_redirects = value
+    end
+
+    def redirect_strip_headers=(value)
+      @redirect_strip_headers = RedirectHelper.normalize_header_names(value)
+    end
+
     def connection_pool_size=(value)
       validate_positive_integer(:connection_pool_size, value)
       @connection_pool_size = value
@@ -383,11 +456,16 @@ module PatientHttp
         "user_agent" => user_agent,
         "raise_error_responses" => raise_error_responses,
         "max_redirects" => max_redirects,
+        "follow_method_changing_redirects" => follow_method_changing_redirects,
+        "redirect_strip_headers" => redirect_strip_headers,
         "connection_pool_size" => connection_pool_size,
         "connection_timeout" => connection_timeout,
         "proxy_url" => proxy_url,
         "retries" => retries,
         "protocol" => protocol,
+        "max_connections_per_host" => max_connections_per_host,
+        "completion_threads" => completion_threads,
+        "completion_retries" => completion_retries,
         "payload_stores" => payload_stores.keys,
         "default_payload_store" => default_payload_store_name,
         "secrets" => @mutex.synchronize { @secrets.keys },

data/lib/patient_http/outgoing_request.rb

@@ -12,7 +12,7 @@ module PatientHttp
   #
   # @see Configuration#register_preprocessor
   class OutgoingRequest
-    # @return [Symbol] HTTP method (:get, :post, :put, :patch, :delete)
+    # @return [Symbol] HTTP method (:get, :head, :post, :put, :patch, :delete, :query)
     attr_reader :http_method
 
     # @return [String] the request URL with any secret query params already resolved

data/lib/patient_http/payload.rb

@@ -29,7 +29,9 @@ module PatientHttp
       # Encodes a value based on its MIME type.
       #
       # For text-based content types, applies gzip compression if beneficial.
-      # For binary content, uses Base64 encoding.
+      # For binary content, uses Base64 encoding. A value that a text MIME type
+      # claims is text but that does not hold text is encoded as binary as
+      # well, because the serialized form must survive JSON encoding.
       #
       # @param value [String] the value to encode
       # @param mimetype [String, nil] the MIME type of the content
@@ -38,21 +40,11 @@ module PatientHttp
         return nil if value.nil?
 
         if is_text_mimetype?(mimetype)
-          value = text_value(value, charset(mimetype))
-
-          if value.bytesize < 4096
-            [:text, value, value.encoding.name]
-          else
-            gzipped = Zlib.gzip(value)
-            if gzipped.bytesize < value.bytesize
-              [:gzipped, [gzipped].pack("m0"), value.encoding.name]
-            else
-              [:text, value, value.encoding.name]
-            end
-          end
-        else
-          [:binary, [value].pack("m0"), Encoding::BINARY.name]
+          text = text_value(value, charset(mimetype))
+          return encode_text(text) if text?(text)
         end
+
+        [:binary, [value].pack("m0"), Encoding::BINARY.name]
       end
 
       # Decodes an encoded value based on its encoding type.
@@ -78,6 +70,36 @@ module PatientHttp
 
       private
 
+      # Encode a text value, compressing it when that makes it smaller.
+      #
+      # @param value [String] the text to encode
+      # @return [Array(Symbol, String, String)] [encoding, encoded_value, charset]
+      def encode_text(value)
+        return [:text, value, value.encoding.name] if value.bytesize < 4096
+
+        gzipped = Zlib.gzip(value)
+        if gzipped.bytesize < value.bytesize
+          [:gzipped, [gzipped].pack("m0"), value.encoding.name]
+        else
+          [:text, value, value.encoding.name]
+        end
+      end
+
+      # Whether a value can be serialized as text. JSON encoding converts a
+      # string to UTF-8, so the value must either be valid text in its own
+      # encoding or hold bytes that are already valid UTF-8. A body still
+      # carrying a content encoding the reader could not decode holds neither,
+      # even though its MIME type names a text type.
+      #
+      # @param value [String] the value to check
+      # @return [Boolean]
+      def text?(value)
+        return value.valid_encoding? unless value.encoding == Encoding::BINARY
+        return true if value.ascii_only?
+
+        value.dup.force_encoding(Encoding::UTF_8).valid_encoding?
+      end
+
       def is_text_mimetype?(mimetype)
         mimetype&.match?(/\Atext\/|application\/(?:json|xml|javascript)/)
       end