httpx-patched 1.6.2.1

data/lib/httpx/adapters/sentry.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "sentry-ruby"
+
+module HTTPX::Plugins
+  module Sentry
+    module Tracer
+      module_function
+
+      def call(request)
+        sentry_span = start_sentry_span
+
+        return unless sentry_span
+
+        set_sentry_trace_header(request, sentry_span)
+
+        request.on(:response, &method(:finish_sentry_span).curry(3)[sentry_span, request])
+      end
+
+      def start_sentry_span
+        return unless ::Sentry.initialized? && (span = ::Sentry.get_current_scope.get_span)
+        return if span.sampled == false
+
+        span.start_child(op: "httpx.client", start_timestamp: ::Sentry.utc_now.to_f)
+      end
+
+      def set_sentry_trace_header(request, sentry_span)
+        return unless sentry_span
+
+        config = ::Sentry.configuration
+        url = request.uri.to_s
+
+        return unless config.propagate_traces && config.trace_propagation_targets.any? { |target| url.match?(target) }
+
+        trace = ::Sentry.get_current_client.generate_sentry_trace(sentry_span)
+        request.headers[::Sentry::SENTRY_TRACE_HEADER_NAME] = trace if trace
+      end
+
+      def finish_sentry_span(span, request, response)
+        return unless ::Sentry.initialized?
+
+        record_sentry_breadcrumb(request, response)
+        record_sentry_span(request, response, span)
+      end
+
+      def record_sentry_breadcrumb(req, res)
+        return unless ::Sentry.configuration.breadcrumbs_logger.include?(:http_logger)
+
+        request_info = extract_request_info(req)
+
+        data = if res.is_a?(HTTPX::ErrorResponse)
+          { error: res.error.message, **request_info }
+        else
+          { status: res.status, **request_info }
+        end
+
+        crumb = ::Sentry::Breadcrumb.new(
+          level: :info,
+          category: "httpx",
+          type: :info,
+          data: data
+        )
+        ::Sentry.add_breadcrumb(crumb)
+      end
+
+      def record_sentry_span(req, res, sentry_span)
+        return unless sentry_span
+
+        request_info = extract_request_info(req)
+        sentry_span.set_description("#{request_info[:method]} #{request_info[:url]}")
+        if res.is_a?(HTTPX::ErrorResponse)
+          sentry_span.set_data(:error, res.error.message)
+        else
+          sentry_span.set_data(:status, res.status)
+        end
+        sentry_span.set_timestamp(::Sentry.utc_now.to_f)
+      end
+
+      def extract_request_info(req)
+        uri = req.uri
+
+        result = {
+          method: req.verb,
+        }
+
+        if ::Sentry.configuration.send_default_pii
+          uri += "?#{req.query}" unless req.query.empty?
+          result[:body] = req.body.to_s unless req.body.empty? || req.body.unbounded_body?
+        end
+
+        result[:url] = uri.to_s
+
+        result
+      end
+    end
+
+    module RequestMethods
+      def __sentry_enable_trace!
+        return if @__sentry_enable_trace
+
+        Tracer.call(self)
+        @__sentry_enable_trace = true
+      end
+    end
+
+    module ConnectionMethods
+      def send(request)
+        request.__sentry_enable_trace!
+
+        super
+      end
+    end
+  end
+end
+
+Sentry.register_patch(:httpx) do
+  sentry_session = HTTPX.plugin(HTTPX::Plugins::Sentry)
+
+  HTTPX.send(:remove_const, :Session)
+  HTTPX.send(:const_set, :Session, sentry_session.class)
+end

data/lib/httpx/adapters/webmock.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module WebMock
+  module HttpLibAdapters
+    require "net/http/status"
+    HTTP_REASONS = Net::HTTP::STATUS_CODES
+
+    #
+    # HTTPX plugin for webmock.
+    #
+    # Requests are "hijacked" at the session, before they're distributed to a connection.
+    #
+    module Plugin
+      class << self
+        def build_webmock_request_signature(request)
+          uri = WebMock::Util::URI.heuristic_parse(request.uri)
+          uri.query = request.query
+          uri.path = uri.normalized_path.gsub("[^:]//", "/")
+
+          WebMock::RequestSignature.new(
+            request.verb.downcase.to_sym,
+            uri.to_s,
+            body: request.body.to_s,
+            headers: request.headers.to_h
+          )
+        end
+
+        def build_webmock_response(_request, response)
+          webmock_response = WebMock::Response.new
+          webmock_response.status = [response.status, HTTP_REASONS[response.status]]
+          webmock_response.body = response.body.to_s
+          webmock_response.headers = response.headers.to_h
+          webmock_response
+        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, webmock_response.exception) if webmock_response.exception
+
+          request.options.response_class.new(request,
+                                             webmock_response.status[0],
+                                             "2.0",
+                                             webmock_response.headers).tap do |res|
+            res.mocked = true
+          end
+        end
+
+        def build_error_response(request, exception)
+          HTTPX::ErrorResponse.new(request, exception)
+        end
+      end
+
+      module InstanceMethods
+        private
+
+        def do_init_connection(connection, selector)
+          super
+
+          connection.once(:unmock_connection) do
+            next unless connection.current_session == self
+
+            unless connection.addresses?
+              # reset Happy Eyeballs, fail early
+              connection.sibling = nil
+
+              deselect_connection(connection, selector)
+            end
+            resolve_connection(connection, selector)
+          end
+        end
+      end
+
+      module ResponseMethods
+        attr_accessor :mocked
+
+        def initialize(*)
+          super
+          @mocked = false
+        end
+      end
+
+      module ResponseBodyMethods
+        def decode_chunk(chunk)
+          return chunk if @response.mocked
+
+          super
+        end
+      end
+
+      module ConnectionMethods
+        def initialize(*)
+          super
+          @mocked = true
+        end
+
+        def open?
+          return true if @mocked
+
+          super
+        end
+
+        def interests
+          return if @mocked
+
+          super
+        end
+
+        def terminate
+          force_reset
+        end
+
+        def send(request)
+          request_signature = Plugin.build_webmock_request_signature(request)
+          WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
+
+          if (mock_response = WebMock::StubRegistry.instance.response_for_request(request_signature))
+            response = Plugin.build_from_webmock_response(request, mock_response)
+            WebMock::CallbackRegistry.invoke_callbacks({ lib: :httpx }, request_signature, mock_response)
+            log { "mocking #{request.uri} with #{mock_response.inspect}" }
+            request.transition(:headers)
+            request.transition(:body)
+            request.transition(:trailers)
+            request.transition(:done)
+            response.finish!
+            request.response = response
+            request.emit(:response, response)
+            request_signature.headers = request.headers.to_h
+
+            response << mock_response.body.dup unless response.is_a?(HTTPX::ErrorResponse)
+          elsif WebMock.net_connect_allowed?(request_signature.uri)
+            if WebMock::CallbackRegistry.any_callbacks?
+              request.on(:response) do |resp|
+                unless resp.is_a?(HTTPX::ErrorResponse)
+                  webmock_response = Plugin.build_webmock_response(request, resp)
+                  WebMock::CallbackRegistry.invoke_callbacks(
+                    { lib: :httpx, real_request: true }, request_signature,
+                    webmock_response
+                  )
+                end
+              end
+            end
+            @mocked = false
+            emit(:unmock_connection, self)
+            super
+          else
+            raise WebMock::NetConnectNotAllowedError, request_signature
+          end
+        end
+      end
+    end
+
+    class HttpxAdapter < HttpLibAdapter
+      adapter_for :httpx
+
+      class << self
+        def enable!
+          @original_session ||= HTTPX::Session
+
+          webmock_session = HTTPX.plugin(Plugin)
+
+          HTTPX.send(:remove_const, :Session)
+          HTTPX.send(:const_set, :Session, webmock_session.class)
+        end
+
+        def disable!
+          return unless @original_session
+
+          HTTPX.send(:remove_const, :Session)
+          HTTPX.send(:const_set, :Session, @original_session)
+        end
+      end
+    end
+  end
+end

data/lib/httpx/altsvc.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+module HTTPX
+  module AltSvc
+    # makes connections able to accept requests destined to primary service.
+    module ConnectionMixin
+      using URIExtensions
+
+      def send(request)
+        request.headers["alt-used"] = @origin.authority if @parser && !@write_buffer.full? && match_altsvcs?(request.uri)
+
+        super
+      end
+
+      def match?(uri, options)
+        return false if !used? && (@state == :closing || @state == :closed)
+
+        match_altsvcs?(uri) && match_altsvc_options?(uri, options)
+      end
+
+      private
+
+      # checks if this is connection is an alternative service of
+      # +uri+
+      def match_altsvcs?(uri)
+        @origins.any? { |origin| altsvc_match?(uri, origin) } ||
+          AltSvc.cached_altsvc(@origin).any? do |altsvc|
+            origin = altsvc["origin"]
+            altsvc_match?(origin, uri.origin)
+          end
+      end
+
+      def match_altsvc_options?(uri, options)
+        return @options == options unless @options.ssl.all? do |k, v|
+          v == (k == :hostname ? uri.host : options.ssl[k])
+        end
+
+        @options.options_equals?(options, Options::REQUEST_BODY_IVARS + %i[@ssl])
+      end
+
+      def altsvc_match?(uri, other_uri)
+        other_uri = URI(other_uri)
+
+        uri.origin == other_uri.origin || begin
+          case uri.scheme
+          when "h2"
+            (other_uri.scheme == "https" || other_uri.scheme == "h2") &&
+              uri.host == other_uri.host &&
+              uri.port == other_uri.port
+          else
+            false
+          end
+        end
+      end
+    end
+
+    @altsvc_mutex = Thread::Mutex.new
+    @altsvcs = Hash.new { |h, k| h[k] = [] }
+
+    module_function
+
+    def cached_altsvc(origin)
+      now = Utils.now
+      @altsvc_mutex.synchronize do
+        lookup(origin, now)
+      end
+    end
+
+    def cached_altsvc_set(origin, entry)
+      now = Utils.now
+      @altsvc_mutex.synchronize do
+        return if @altsvcs[origin].any? { |altsvc| altsvc["origin"] == entry["origin"] }
+
+        entry["TTL"] = Integer(entry["ma"]) + now if entry.key?("ma")
+        @altsvcs[origin] << entry
+        entry
+      end
+    end
+
+    def lookup(origin, ttl)
+      return [] unless @altsvcs.key?(origin)
+
+      @altsvcs[origin] = @altsvcs[origin].select do |entry|
+        !entry.key?("TTL") || entry["TTL"] > ttl
+      end
+      @altsvcs[origin].reject { |entry| entry["noop"] }
+    end
+
+    def emit(request, response)
+      return unless response.respond_to?(:headers)
+      # Alt-Svc
+      return unless response.headers.key?("alt-svc")
+
+      origin = request.origin
+      host = request.uri.host
+
+      altsvc = response.headers["alt-svc"]
+
+      # https://datatracker.ietf.org/doc/html/rfc7838#section-3
+      # A field value containing the special value "clear" indicates that the
+      # origin requests all alternatives for that origin to be invalidated
+      # (including those specified in the same response, in case of an
+      # invalid reply containing both "clear" and alternative services).
+      if altsvc == "clear"
+        @altsvc_mutex.synchronize do
+          @altsvcs[origin].clear
+        end
+
+        return
+      end
+
+      parse(altsvc) do |alt_origin, alt_params|
+        alt_origin.host ||= host
+        yield(alt_origin, origin, alt_params)
+      end
+    end
+
+    def parse(altsvc)
+      return enum_for(__method__, altsvc) unless block_given?
+
+      scanner = StringScanner.new(altsvc)
+      until scanner.eos?
+        alt_service = scanner.scan(/[^=]+=("[^"]+"|[^;,]+)/)
+
+        alt_params = []
+        loop do
+          alt_param = scanner.scan(/[^=]+=("[^"]+"|[^;,]+)/)
+          alt_params << alt_param.strip if alt_param
+          scanner.skip(/;/)
+          break if scanner.eos? || scanner.scan(/ *, */)
+        end
+        alt_params = Hash[alt_params.map { |field| field.split("=", 2) }]
+
+        alt_proto, alt_authority = alt_service.split("=", 2)
+        alt_origin = parse_altsvc_origin(alt_proto, alt_authority)
+        return unless alt_origin
+
+        yield(alt_origin, alt_params.merge("proto" => alt_proto))
+      end
+    end
+
+    def parse_altsvc_scheme(alt_proto)
+      case alt_proto
+      when "h2c"
+        "http"
+      when "h2"
+        "https"
+      end
+    end
+
+    def parse_altsvc_origin(alt_proto, alt_origin)
+      alt_scheme = parse_altsvc_scheme(alt_proto)
+
+      return unless alt_scheme
+
+      alt_origin = alt_origin[1..-2] if alt_origin.start_with?("\"") && alt_origin.end_with?("\"")
+
+      URI.parse("#{alt_scheme}://#{alt_origin}")
+    end
+  end
+end

data/lib/httpx/base64.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+if RUBY_VERSION < "3.3.0"
+  require "base64"
+elsif !defined?(Base64)
+  module HTTPX
+    # require "base64" will not be a default gem after ruby 3.4.0
+    module Base64
+      module_function
+
+      def decode64(str)
+        str.unpack1("m")
+      end
+
+      def strict_encode64(bin)
+        [bin].pack("m0")
+      end
+
+      def urlsafe_encode64(bin, padding: true)
+        str = strict_encode64(bin)
+        str.chomp!("==") or str.chomp!("=") unless padding
+        str.tr!("+/", "-_")
+        str
+      end
+    end
+  end
+end

data/lib/httpx/buffer.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module HTTPX
+  # Internal class to abstract a string buffer, by wrapping a string and providing the
+  # minimum possible API and functionality required.
+  #
+  #     buffer = Buffer.new(640)
+  #     buffer.full? #=> false
+  #     buffer << "aa"
+  #     buffer.capacity #=> 638
+  #
+  class Buffer
+    extend Forwardable
+
+    def_delegator :@buffer, :to_s
+
+    def_delegator :@buffer, :to_str
+
+    def_delegator :@buffer, :empty?
+
+    def_delegator :@buffer, :bytesize
+
+    def_delegator :@buffer, :clear
+
+    def_delegator :@buffer, :replace
+
+    attr_reader :limit
+
+    if RUBY_VERSION >= "3.4.0"
+      def initialize(limit)
+        @buffer = String.new("", encoding: Encoding::BINARY, capacity: limit)
+        @limit = limit
+      end
+
+      def <<(chunk)
+        @buffer.append_as_bytes(chunk)
+      end
+    else
+      def initialize(limit)
+        @buffer = "".b
+        @limit = limit
+      end
+
+      def_delegator :@buffer, :<<
+    end
+
+    def full?
+      @buffer.bytesize >= @limit
+    end
+
+    def capacity
+      @limit - @buffer.bytesize
+    end
+
+    def shift!(fin)
+      @buffer = @buffer.byteslice(fin..-1) || "".b
+    end
+  end
+end

data/lib/httpx/callbacks.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Callbacks
+    def on(type, &action)
+      callbacks(type) << action
+      action
+    end
+
+    def once(type, &block)
+      on(type) do |*args, &callback|
+        block.call(*args, &callback)
+        :delete
+      end
+    end
+
+    def emit(type, *args)
+      log { "emit #{type.inspect} callbacks" } if respond_to?(:log)
+      callbacks(type).delete_if { |pr| :delete == pr.call(*args) } # rubocop:disable Style/YodaCondition
+    end
+
+    def callbacks_for?(type)
+      @callbacks && @callbacks.key?(type) && @callbacks[type].any?
+    end
+
+    protected
+
+    def callbacks(type = nil)
+      return @callbacks unless type
+
+      @callbacks ||= Hash.new { |h, k| h[k] = [] }
+      @callbacks[type]
+    end
+  end
+end

data/lib/httpx/chainable.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module HTTPX
+  # Session mixin, implements most of the APIs that the users call.
+  # delegates to a default session when extended.
+  module Chainable
+    %w[head get post put delete trace options connect patch].each do |meth|
+      class_eval(<<-MOD, __FILE__, __LINE__ + 1)
+        def #{meth}(*uri, **options)                # def get(*uri, **options)
+          request("#{meth.upcase}", uri, **options) #   request("GET", uri, **options)
+        end                                         # end
+      MOD
+    end
+
+    # delegates to the default session (see HTTPX::Session#request).
+    def request(*args, **options)
+      branch(default_options).request(*args, **options)
+    end
+
+    def accept(type)
+      with(headers: { "accept" => String(type) })
+    end
+
+    # delegates to the default session (see HTTPX::Session#wrap).
+    def wrap(&blk)
+      branch(default_options).wrap(&blk)
+    end
+
+    # returns a new instance loaded with the +pl+ plugin and +options+.
+    def plugin(pl, options = nil, &blk)
+      klass = is_a?(S) ? self.class : Session
+      klass = Class.new(klass)
+      klass.instance_variable_set(:@default_options, klass.default_options.merge(default_options))
+      klass.plugin(pl, options, &blk).new
+    end
+
+    # returns a new instance loaded with +options+.
+    def with(options, &blk)
+      branch(default_options.merge(options), &blk)
+    end
+
+    private
+
+    # returns default instance of HTTPX::Options.
+    def default_options
+      @options || Session.default_options
+    end
+
+    # returns a default instance of HTTPX::Session.
+    def branch(options, &blk)
+      return self.class.new(options, &blk) if is_a?(S)
+
+      Session.new(options, &blk)
+    end
+
+    def method_missing(meth, *args, **options, &blk)
+      case meth
+      when /\Awith_(.+)/
+
+        option = Regexp.last_match(1)
+
+        return super unless option
+
+        with(option.to_sym => args.first || options)
+      when /\Aon_(.+)/
+        callback = Regexp.last_match(1)
+
+        return super unless %w[
+          connection_opened connection_closed
+          request_error
+          request_started request_body_chunk request_completed
+          response_started response_body_chunk response_completed
+        ].include?(callback)
+
+        warn "DEPRECATION WARNING: calling `.#{meth}` on plain HTTPX sessions is deprecated. " \
+             "Use `HTTPX.plugin(:callbacks).#{meth}` instead."
+
+        plugin(:callbacks).__send__(meth, *args, **options, &blk)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(meth, *)
+      case meth
+      when /\Awith_(.+)/
+        option = Regexp.last_match(1)
+
+        default_options.respond_to?(option) || super
+      when /\Aon_(.+)/
+        callback = Regexp.last_match(1)
+
+        %w[
+          connection_opened connection_closed
+          request_error
+          request_started request_body_chunk request_completed
+          response_started response_body_chunk response_completed
+        ].include?(callback) || super
+      else
+        super
+      end
+    end
+  end
+
+  extend Chainable
+end