httpx 0.24.0 → 0.24.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 159ab63d2464f90d5b73651241f85443c6b79d5d4e0e542cbb93a8e876fd9c97
-  data.tar.gz: 43c759345b7c52114bea8066ce7e27dd1b026a85bbdf624d1d81f12ce3314248
+  metadata.gz: 63f31bb23a4d1676f6d537df456a52e4ee5c4f24e39239072d698abf37cf48fd
+  data.tar.gz: b21ec1aeac1a3fdb52be5cccc3e9781bbc8f5e63f81c04a08eb60b89dba00c1b
 SHA512:
-  metadata.gz: 4139bbc4d97e28c7c12dcaa9c3a1b71490c9b870cb60d432fb07c946af6b9346f71c8b7554abd30f584fe67b790c8095fa658571769c6a1f527b451604327354
-  data.tar.gz: 07b636c4eaf69fe3e60c10f4f86a0f8a58e9b1b431d27a9bf7a8b431fba2bdec8f1d4175b5b25de4487d02e90c38b00eaa5b789aacd17b5d3ced34790da55948
+  metadata.gz: f0554a088f8ee971e2ccb6534f4d6ef2e43c95c04e6b3930dbeded34485664f340e8c1109a10608c4706098ad43726f2547905eea641b5a45d148ae1f7829e55
+  data.tar.gz: 92800524ec31ec676ba7e90a0f51a7d0ea8f6e752253c2b31c0805b807fc2f5fcdbb491f74ceb674e72dd691980cca968a945ec81bd2f9f7ff6eb25b5f9e0a2a

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/doc/release_notes/0_24_2.md

@@ -0,0 +1,12 @@
+# 0.24.2
+
+## Improvements
+
+* besides an array, `:resolver_options` can now receive a hash for `:nameserver`, which **must** be indexed by IP family (`Socket::AF_INET6` or `Socket::AF_INET`); each group of nameservers will be used for emitting DNS queries of that iP family.
+* `:authentication` plugin: Added `#bearer_auth` helper, which receives a token, and sets it as `"Bearer $TOKEN` in the `"authorization"` header.
+* `faraday` adapter: now implements `#build_connection` and `#close`, will now interact with `faraday` native timeouts (`:read`, `:write` and `:connect`).
+
+
+## Bugfixes
+
+* fixed native resolver bug when queries involving intermediate alias would be kept after the original query and mess with re-queries.

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/adapters/faraday.rb

@@ -35,8 +35,46 @@ module Faraday
       module RequestMixin
         using ::HTTPX::HashExtensions
 
+        def build_connection(env)
+          return @connection if defined?(@connection)
+
+          @connection = ::HTTPX.plugin(:compression).plugin(:persistent).plugin(ReasonPlugin)
+          @connection = @connection.with(@connection_options) unless @connection_options.empty?
+          @connection = @connection.with(options_from_env(env))
+
+          if (proxy = env.request.proxy)
+            proxy_options = { uri: proxy.uri }
+            proxy_options[:username] = proxy.user if proxy.user
+            proxy_options[:password] = proxy.password if proxy.password
+
+            @connection = @connection.plugin(:proxy).with(proxy: proxy_options)
+          end
+          @connection = @connection.plugin(OnDataPlugin) if env.request.stream_response?
+
+          @connection
+        end
+
+        def close
+          @session.close
+        end
+
         private
 
+        def connect(env, &blk)
+          connection(env, &blk)
+        rescue ::HTTPX::TLSError => e
+          raise SSL_ERROR, e
+        rescue Errno::ECONNABORTED,
+               Errno::ECONNREFUSED,
+               Errno::ECONNRESET,
+               Errno::EHOSTUNREACH,
+               Errno::EINVAL,
+               Errno::ENETUNREACH,
+               Errno::EPIPE,
+               ::HTTPX::ConnectionError => e
+          raise CONNECTION_FAILED_ERROR, e
+        end
+
         def build_request(env)
           meth = env[:method]
 
@@ -48,28 +86,36 @@ module Faraday
         end
 
         def options_from_env(env)
-          timeout_options = {
-            connect_timeout: env.request.open_timeout,
-            operation_timeout: env.request.timeout,
-          }.compact
+          timeout_options = {}
+          if (sec = request_timeout(:read, env))
+            timeout_options[:operation_timeout] = sec
+          end
 
-          options = {
-            ssl: {},
+          if (sec = request_timeout(:write, env))
+            timeout_options[:operation_timeout] = sec
+          end
+
+          if (sec = request_timeout(:open, env))
+            timeout_options[:connect_timeout] = sec
+          end
+
+          ssl_options = {}
+
+          ssl_options[:verify_mode] = OpenSSL::SSL::VERIFY_PEER if env.ssl.verify
+          ssl_options[:ca_file] = env.ssl.ca_file if env.ssl.ca_file
+          ssl_options[:ca_path] = env.ssl.ca_path if env.ssl.ca_path
+          ssl_options[:cert_store] = env.ssl.cert_store if env.ssl.cert_store
+          ssl_options[:cert] = env.ssl.client_cert if env.ssl.client_cert
+          ssl_options[:key] = env.ssl.client_key if env.ssl.client_key
+          ssl_options[:ssl_version] = env.ssl.version if env.ssl.version
+          ssl_options[:verify_depth] = env.ssl.verify_depth if env.ssl.verify_depth
+          ssl_options[:min_version] = env.ssl.min_version if env.ssl.min_version
+          ssl_options[:max_version] = env.ssl.max_version if env.ssl.max_version
+
+          {
+            ssl: ssl_options,
             timeout: timeout_options,
           }
-
-          options[:ssl][:verify_mode] = OpenSSL::SSL::VERIFY_PEER if env.ssl.verify
-          options[:ssl][:ca_file] = env.ssl.ca_file if env.ssl.ca_file
-          options[:ssl][:ca_path] = env.ssl.ca_path if env.ssl.ca_path
-          options[:ssl][:cert_store] = env.ssl.cert_store if env.ssl.cert_store
-          options[:ssl][:cert] = env.ssl.client_cert if env.ssl.client_cert
-          options[:ssl][:key] = env.ssl.client_key if env.ssl.client_key
-          options[:ssl][:ssl_version] = env.ssl.version if env.ssl.version
-          options[:ssl][:verify_depth] = env.ssl.verify_depth if env.ssl.verify_depth
-          options[:ssl][:min_version] = env.ssl.min_version if env.ssl.min_version
-          options[:ssl][:max_version] = env.ssl.max_version if env.ssl.max_version
-
-          options
         end
       end
 
@@ -122,10 +168,6 @@ module Faraday
         end
       end
 
-      def self.session
-        @session ||= ::HTTPX.plugin(:compression).plugin(:persistent).plugin(ReasonPlugin)
-      end
-
       class ParallelManager
         class ResponseHandler < SimpleDelegator
           attr_reader :env
@@ -158,8 +200,9 @@ module Faraday
 
         include RequestMixin
 
-        def initialize
+        def initialize(options)
           @handlers = []
+          @connection_options = options
         end
 
         def enqueue(request)
@@ -173,40 +216,52 @@ module Faraday
 
           env = @handlers.last.env
 
-          session = HTTPX.session.with(options_from_env(env))
-          session = session.plugin(:proxy).with(proxy: { uri: env.request.proxy }) if env.request.proxy
-          session = session.plugin(OnDataPlugin) if env.request.stream_response?
+          connect(env) do |session|
+            requests = @handlers.map { |handler| session.build_request(*build_request(handler.env)) }
 
-          requests = @handlers.map { |handler| session.build_request(*build_request(handler.env)) }
+            if env.request.stream_response?
+              requests.each do |request|
+                request.response_on_data = env.request.on_data
+              end
+            end
 
-          if env.request.stream_response?
-            requests.each do |request|
-              request.response_on_data = env.request.on_data
+            responses = session.request(*requests)
+            Array(responses).each_with_index do |response, index|
+              handler = @handlers[index]
+              handler.on_response.call(response)
+              handler.on_complete.call(handler.env)
             end
           end
+        end
 
-          responses = session.request(*requests)
-          Array(responses).each_with_index do |response, index|
-            handler = @handlers[index]
-            handler.on_response.call(response)
-            handler.on_complete.call(handler.env)
+        # from Faraday::Adapter#connection
+        def connection(env)
+          conn = build_connection(env)
+          return conn unless block_given?
+
+          yield conn
+        end
+
+        private
+
+        # from Faraday::Adapter#request_timeout
+        def request_timeout(type, options)
+          key = Faraday::Adapter::TIMEOUT_KEYS.fetch(type) do
+            msg = "Expected :read, :write, :open. Got #{type.inspect} :("
+            raise ArgumentError, msg
           end
+          options[key] || options[:timeout]
         end
       end
 
       self.supports_parallel = true
 
       class << self
-        def setup_parallel_manager
-          ParallelManager.new
+        def setup_parallel_manager(options = {})
+          ParallelManager.new(options)
         end
       end
 
-      def initialize(app, options = {})
-        super(app)
-        @session_options = options
-      end
-
       def call(env)
         super
         if parallel?(env)
@@ -224,38 +279,28 @@ module Faraday
           return handler
         end
 
-        session = HTTPX.session
-        session = session.with(@session_options) unless @session_options.empty?
-        session = session.with(options_from_env(env))
-        session = session.plugin(:proxy).with(proxy: { uri: env.request.proxy }) if env.request.proxy
-        session = session.plugin(OnDataPlugin) if env.request.stream_response?
-
-        request = session.build_request(*build_request(env))
-
-        request.response_on_data = env.request.on_data if env.request.stream_response?
-
-        response = session.request(request)
-        # do not call #raise_for_status for HTTP 4xx or 5xx, as faraday has a middleware for that.
-        response.raise_for_status unless response.is_a?(::HTTPX::Response)
+        response = connect_and_request(env)
         save_response(env, response.status, response.body.to_s, response.headers, response.reason) do |response_headers|
           response_headers.merge!(response.headers)
         end
         @app.call(env)
-      rescue ::HTTPX::TLSError => e
-        raise SSL_ERROR, e
-      rescue Errno::ECONNABORTED,
-             Errno::ECONNREFUSED,
-             Errno::ECONNRESET,
-             Errno::EHOSTUNREACH,
-             Errno::EINVAL,
-             Errno::ENETUNREACH,
-             Errno::EPIPE,
-             ::HTTPX::ConnectionError => e
-        raise CONNECTION_FAILED_ERROR, e
       end
 
       private
 
+      def connect_and_request(env)
+        connect(env) do |session|
+          request = session.build_request(*build_request(env))
+
+          request.response_on_data = env.request.on_data if env.request.stream_response?
+
+          response = session.request(request)
+          # do not call #raise_for_status for HTTP 4xx or 5xx, as faraday has a middleware for that.
+          response.raise_for_status unless response.is_a?(::HTTPX::Response)
+          response
+        end
+      end
+
       def parallel?(env)
         env[:parallel_manager]
       end

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/plugins/authentication.rb

@@ -13,6 +13,10 @@ module HTTPX
         def authentication(token)
           with(headers: { "authorization" => token })
         end
+
+        def bearer_auth(token)
+          authentication("Bearer #{token}")
+        end
       end
     end
     register_plugin :authentication, Authentication

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)
@@ -253,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?
@@ -294,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,6 +1,7 @@
 # frozen_string_literal: true
 
 require "pathname"
+require_relative "store"
 
 module HTTPX::Plugins
   module ResponseCache

data/lib/httpx/resolver/native.rb

@@ -29,12 +29,15 @@ module HTTPX
 
     attr_reader :state
 
-    def initialize(_, options)
+    def initialize(family, options)
       super
       @ns_index = 0
       @resolver_options = DEFAULTS.merge(@options.resolver_options)
       @socket_type = @resolver_options.fetch(:socket_type, :udp)
-      @nameserver = Array(@resolver_options[:nameserver]) if @resolver_options[:nameserver]
+      @nameserver = if (nameserver = @resolver_options[:nameserver])
+        nameserver = nameserver[family] if nameserver.is_a?(Hash)
+        Array(nameserver)
+      end
       @ndots = @resolver_options[:ndots]
       @search = Array(@resolver_options[:search]).map { |srch| srch.scan(/[^.]+/) }
       @_timeouts = Array(@resolver_options[:timeouts])
@@ -318,7 +321,7 @@ module HTTPX
             return
           end
         else
-          @timeouts.delete(name)
+          reset_hostname(name, connection: connection)
           @timeouts.delete(connection.origin.host)
           @connections.delete(connection)
           Resolver.cached_lookup_set(connection.origin.host, @family, addresses) if @resolver_options[:cache]
@@ -429,9 +432,8 @@ module HTTPX
       end
     end
 
-    def reset_hostname(hostname, reset_candidates: true)
+    def reset_hostname(hostname, connection: @queries.delete(hostname), reset_candidates: true)
       @timeouts.delete(hostname)
-      connection = @queries.delete(hostname)
       @timeouts.delete(hostname)
 
       return unless connection && reset_candidates

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.24.0"
+  VERSION = "0.24.2"
 end

data/sig/plugins/authentication.rbs

@@ -3,6 +3,8 @@ module HTTPX
     module Authentication
       module InstanceMethods
         def authentication: (string token) -> instance
+
+        def bearer_auth: (string token) -> instance
       end
     end
 

data/sig/resolver/native.rbs

@@ -63,7 +63,7 @@ module HTTPX
 
       def handle_error: (NativeResolveError | StandardError) -> void
 
-      def reset_hostname: (String hostname, ?reset_candidates: bool) -> void
+      def reset_hostname: (String hostname, ?connection: Connection, ?reset_candidates: bool) -> void
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: httpx
 version: !ruby/object:Gem::Version
-  version: 0.24.0
+  version: 0.24.2
 platform: ruby
 authors:
 - Tiago Cardoso
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-06-15 00:00:00.000000000 Z
+date: 2023-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http-2-next
@@ -100,6 +100,8 @@ extra_rdoc_files:
 - 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_24_2.md
 - doc/release_notes/0_2_0.md
 - doc/release_notes/0_2_1.md
 - doc/release_notes/0_3_0.md
@@ -192,6 +194,8 @@ files:
 - 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_24_2.md
 - doc/release_notes/0_2_0.md
 - doc/release_notes/0_2_1.md
 - doc/release_notes/0_3_0.md
@@ -392,7 +396,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: []
@@ -409,7 +413,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