http_loader 0.10.3

data/http_loader.gemspec

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative 'lib/http_loader/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'http_loader'
+  spec.version       = HttpLoader::VERSION
+  spec.authors       = ['Vitalii Lazebnyi']
+  spec.email         = ['vitalii.lazebnyi.github@gmail.com']
+
+  spec.summary       = 'Keep-Alive High Concurrency Load Testing Framework'
+  spec.description   = 'A performance testing tool for HTTP/HTTPS.'
+  spec.homepage      = 'https://github.com/VitaliiLazebnyi/http_loader'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = '>= 4.0'
+  spec.metadata['allowed_push_host']     = 'https://rubygems.org'
+  spec.metadata['source_code_uri']       = 'https://github.com/VitaliiLazebnyi/http_loader'
+  spec.metadata['bug_tracker_uri']       = 'https://github.com/VitaliiLazebnyi/http_loader/issues'
+  spec.metadata['changelog_uri']         = 'https://github.com/VitaliiLazebnyi/http_loader/blob/main/CHANGELOG.md'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.cert_chain  = ['certs/http_loader-public_cert.pem']
+  spec.signing_key = File.expand_path('~/.gem/gem-private_key.pem') if $PROGRAM_NAME.end_with?('gem') && File.exist?(File.expand_path('~/.gem/gem-private_key.pem'))
+
+  spec.files = %w[
+    BUGS.md
+    Gemfile
+    LICENSE.txt
+    PERFORMANCE_REPORT.md
+    README.md
+    REQUIREMENTS.md
+    http_loader.gemspec
+  ] + Dir.glob('{lib,bin,certs}/**/*', base: __dir__).select do |f|
+    File.file?(File.expand_path(f, __dir__))
+  end
+  spec.bindir        = 'bin'
+  spec.executables   = ['http_loader']
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'async', '~> 2.39'
+  spec.add_dependency 'async-http', '~> 0.95'
+  spec.add_dependency 'falcon', '~> 0.55'
+  spec.add_dependency 'rack', '~> 3.2'
+  spec.add_dependency 'rackup', '~> 2.3'
+  spec.add_dependency 'sorbet-runtime', '~> 0.6'
+
+  spec.add_development_dependency 'memory_profiler', '~> 1.1'
+  spec.add_development_dependency 'rake', '~> 13.3'
+  spec.add_development_dependency 'rspec', '~> 3.13'
+  spec.add_development_dependency 'rubocop', '~> 1.86'
+  spec.add_development_dependency 'rubocop-md', '~> 2.0'
+  spec.add_development_dependency 'rubocop-performance', '~> 1.26'
+  spec.add_development_dependency 'rubocop-rake', '~> 0.7'
+  spec.add_development_dependency 'rubocop-rspec', '~> 3.9'
+  spec.add_development_dependency 'rubocop-thread_safety', '~> 0.7'
+  spec.add_development_dependency 'ruby-prof', '~> 2.0'
+  spec.add_development_dependency 'simplecov', '~> 0.22'
+  spec.add_development_dependency 'sorbet', '~> 0.6'
+  spec.add_development_dependency 'yard', '~> 0.9'
+  spec.add_development_dependency 'yard-sorbet', '~> 0.8'
+end

data/lib/http_loader/cli_args.rb

@@ -0,0 +1,120 @@
+# typed: false
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+
+module HttpLoader
+  # Extracted arguments parsers for strict metric compliance.
+  module CliArgs
+    # ClientParser configures OptionParser mapping specifically for Client configurations
+    class ClientParser
+      def self.parse(opts, options)
+        parse_core(opts, options)
+        parse_ping(opts, options)
+        parse_timeouts(opts, options)
+      end
+
+      def self.parse_core(opts, options)
+        opts.on('--connections_count=COUNT', Integer, 'Total') { |v| options[:connections] = v }
+        opts.on('--https', 'Use HTTPS natively') { options[:use_https] = true }
+        opts.on('--url=URL', String, 'URLs') { |v| options[:target_urls] = v.split(',') }
+        opts.on('--verbose', 'Verbose logging') { options[:verbose] = true }
+      end
+
+      def self.parse_ping(opts, options)
+        opts.on('--[no-]ping', 'Ping') { |v| options[:ping] = v }
+        opts.on('--ping_period=SECONDS', Integer, 'Ping period') { |v| options[:ping_period] = v }
+      end
+
+      def self.parse_timeouts(opts, options)
+        opts.on('--http_loader_timeout=S', Float, 'Keep') { |v| options[:http_loader_timeout] = v }
+        opts.on('--connections_per_second=R', Integer, 'Rate') { |v| options[:connections_per_second] = v }
+        opts.on('--max_concurrent_connections=C', Integer, 'Max') { |v| options[:max_concurrent_connections] = v }
+        parse_advanced(opts, options)
+      end
+
+      def self.parse_advanced(opts, options)
+        opts.on('--reopen_closed_connections', 'Reopen') { options[:reopen_closed_connections] = true }
+        opts.on('--reopen_interval=S', Float, 'Reopen delay') { |v| options[:reopen_interval] = v }
+        opts.on('--read_timeout=S', Float, 'Read timeout') { |v| options[:read_timeout] = v }
+        parse_tracking(opts, options)
+      end
+
+      def self.parse_tracking(opts, options)
+        opts.on('--user_agent=A', String, 'User Agent') { |v| options[:user_agent] = v }
+        opts.on('--jitter=F', Float, 'Randomize sleep') { |v| options[:jitter] = v }
+        opts.on('--track_status_codes', 'Track HTTP codes') { options[:track_status_codes] = true }
+        parse_endpoints(opts, options)
+      end
+
+      def self.parse_endpoints(opts, options)
+        opts.on('--ramp_up=S', Float, 'Smoothly scale') { |val| options[:ramp_up] = val }
+        opts.on('--bind_ips=IPS', String, 'IPs') { |val| options[:bind_ips] = val.split(',') }
+        opts.on('--proxy_pool=U', String, 'URI pool') { |val| options[:proxy_pool] = val.split(',') }
+        parse_slowloris(opts, options)
+      end
+
+      def self.parse_slowloris(opts, options)
+        opts.on('--qps_per_connection=R', Integer, 'Active QPS') { |val| options[:qps_per_connection] = val }
+        opts.on('--headers=LIST', String, 'Headers') do |val|
+          val.split(',').each do |pair|
+            key, value = pair.split(':', 2)
+            options[:headers][key.strip] = value.strip if key && value
+          end
+        end
+        parse_slowloris_delays(opts, options)
+      end
+
+      def self.parse_slowloris_delays(opts, options)
+        opts.on('--slowloris_delay=S', Float, 'Gap') { |v| options[:slowloris_delay] = v }
+        opts.on('--export_json=FILE', String) { nil }
+        opts.on('--target_duration=S', Float) { nil }
+      end
+    end
+
+    # HarnessParser strictly parses orchestrator arguments ignoring explicitly mapped client arguments dynamically.
+    class HarnessParser
+      def self.parse(opts, options)
+        opts.on('--connections_count=C', Integer) { |v| options[:connections] = v }
+        opts.on('--https') { options[:use_https] = true }
+        opts.on('--url=URL', String) { |v| options[:target_urls] = v.split(',') }
+        opts.on('--export_json=FILE', String) { |v| options[:export_json] = v }
+        opts.on('--target_duration=S', Float) { |v| options[:target_duration] = v }
+        ignore_core_args(opts)
+      end
+
+      def self.ignore_core_args(opts)
+        opts.on('--verbose') { nil }
+        opts.on('--[no-]ping') { nil }
+        opts.on('--ping_period=S', Integer) { nil }
+        opts.on('--http_loader_timeout=S', Float) { nil }
+        opts.on('--connections_per_second=R', Integer) { nil }
+        ignore_time_args(opts)
+      end
+
+      def self.ignore_time_args(opts)
+        opts.on('--max_concurrent_connections=C', Integer) { nil }
+        opts.on('--reopen_closed_connections') { nil }
+        opts.on('--reopen_interval=S', Float) { nil }
+        opts.on('--read_timeout=S', Float) { nil }
+        opts.on('--user_agent=A', String) { nil }
+        ignore_advanced_args(opts)
+      end
+
+      def self.ignore_advanced_args(opts)
+        opts.on('--jitter=F', Float) { nil }
+        opts.on('--track_status_codes') { nil }
+        opts.on('--ramp_up=S', Float) { nil }
+        opts.on('--bind_ips=IPS', String) { nil }
+        opts.on('--proxy_pool=U', String) { nil }
+        ignore_payload_args(opts)
+      end
+
+      def self.ignore_payload_args(opts)
+        opts.on('--qps_per_connection=R', Integer) { nil }
+        opts.on('--headers=LIST', String) { nil }
+        opts.on('--slowloris_delay=S', Float) { nil }
+      end
+    end
+  end
+end

data/lib/http_loader/client/config.rb

@@ -0,0 +1,33 @@
+# typed: strong
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+
+module HttpLoader
+  class Client
+    # Config parameters for Client connections.
+    class Config < T::Struct
+      const :connections, Integer
+      const :target_urls, T::Array[String], default: []
+      const :use_https, T::Boolean, default: false
+      const :verbose, T::Boolean, default: false
+      const :ping, T::Boolean, default: true
+      const :ping_period, Integer, default: 5
+      const :http_loader_timeout, Float, default: 0.0
+      const :connections_per_second, Integer, default: 0
+      const :max_concurrent_connections, Integer, default: 1000
+      const :reopen_closed_connections, T::Boolean, default: false
+      const :reopen_interval, Float, default: 5.0
+      const :read_timeout, Float, default: 0.0
+      const :user_agent, String, default: 'Keep-Alive Test'
+      const :jitter, Float, default: 1.0
+      const :track_status_codes, T::Boolean, default: false
+      const :ramp_up, Float, default: 0.0
+      const :bind_ips, T::Array[String], default: []
+      const :proxy_pool, T::Array[String], default: []
+      const :qps_per_connection, Integer, default: 0
+      const :headers, T::Hash[String, String], default: {}
+      const :slowloris_delay, Float, default: 0.0
+    end
+  end
+end

data/lib/http_loader/client/error_handler.rb

@@ -0,0 +1,28 @@
+# typed: strong
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+
+module HttpLoader
+  class Client
+    # ErrorHandler provides error handling strategies natively.
+    module ErrorHandler
+      extend T::Sig
+      extend T::Helpers
+
+      requires_ancestor { HttpLoader::Client }
+
+      sig { params(idx: Integer, err: StandardError).void }
+      def handle_err(idx, err)
+        case err
+        when Errno::EMFILE
+          @logger.error("[Client #{idx}] ERROR_EMFILE: #{err.message}")
+        when Errno::EADDRNOTAVAIL
+          @logger.error("[Client #{idx}] ERROR_EADDRNOTAVAIL: Ephemeral port limit reached.")
+        else
+          @logger.error("[Client #{idx}] ERROR_OTHER: #{err.message}")
+        end
+      end
+    end
+  end
+end

data/lib/http_loader/client/http_session.rb

@@ -0,0 +1,118 @@
+# typed: strong
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+require 'net/http'
+
+module HttpLoader
+  class Client
+    # Handles normal and QPS-driven HTTP keep-alive connections.
+    class HttpSession
+      extend T::Sig
+
+      sig { params(config: Config, logger: Logger).void }
+      def initialize(config, logger)
+        @config = config
+        @logger = logger
+      end
+
+      sig { params(client_index: Integer, uri: URI::Generic, http: Net::HTTP, start_time: Time).void }
+      def run(client_index, uri, http, start_time)
+        return if @config.slowloris_delay.positive?
+
+        fire_initial_request(uri, http)
+        maintain_keepalive(client_index, uri, http, start_time)
+      end
+
+      private
+
+      sig { params(uri: URI::Generic, http: Net::HTTP).void }
+      def fire_initial_request(uri, http)
+        request = Net::HTTP::Get.new(uri)
+        request['Connection'] = 'keep-alive'
+        request['User-Agent'] = @config.user_agent
+        @config.headers.each { |k, v| request[k] = v }
+
+        http.request(request) do |response|
+          response.read_body { |_chunk| nil }
+        end
+      end
+
+      sig { params(client_index: Integer, uri: URI::Generic, http: Net::HTTP, start_time: Time).void }
+      def maintain_keepalive(client_index, uri, http, start_time)
+        loop do
+          elapsed = Time.now - start_time
+          if @config.http_loader_timeout.positive? && elapsed >= @config.http_loader_timeout
+            @logger.info("[Client #{client_index}] Keep-alive timeout reached, closing.")
+            break
+          end
+
+          break unless process_heartbeat?(client_index, uri, http)
+        end
+      end
+
+      sig { params(client_index: Integer, uri: URI::Generic, http: Net::HTTP).returns(T::Boolean) }
+      def process_heartbeat?(client_index, uri, http)
+        if @config.qps_per_connection.positive?
+          perform_qps?(client_index, uri, http)
+        elsif @config.ping
+          perform_ping?(client_index, uri, http)
+        else
+          sleep(calculate_sleep(1.0))
+          true
+        end
+      end
+
+      sig { params(client_index: Integer, uri: URI::Generic, http: Net::HTTP).returns(T::Boolean) }
+      def perform_qps?(client_index, uri, http)
+        sleep(calculate_sleep(1.0 / @config.qps_per_connection))
+        req = build_request(Net::HTTP::Get.new(uri))
+
+        res = http.request(req) do |r|
+          r.read_body { |_c| nil }
+        end
+        log_status(client_index, res)
+        success?(res)
+      end
+
+      sig { params(client_index: Integer, uri: URI::Generic, http: Net::HTTP).returns(T::Boolean) }
+      def perform_ping?(client_index, uri, http)
+        sleep(calculate_sleep(@config.ping_period.to_f))
+        req = build_request(Net::HTTP::Head.new(uri))
+
+        res = http.request(req)
+        log_status(client_index, res)
+        success?(res)
+      end
+
+      sig { params(req: Net::HTTPRequest).returns(Net::HTTPRequest) }
+      def build_request(req)
+        req['Connection'] = 'keep-alive'
+        req['User-Agent'] = @config.user_agent
+        @config.headers.each { |k, v| req[k] = v }
+        req
+      end
+
+      sig { params(res: Net::HTTPResponse).returns(T::Boolean) }
+      def success?(res)
+        res.is_a?(Net::HTTPSuccess) || res.is_a?(Net::HTTPRedirection)
+      end
+
+      sig { params(client_index: Integer, res: Net::HTTPResponse).void }
+      def log_status(client_index, res)
+        return unless @config.track_status_codes
+        return if success?(res)
+
+        @logger.info("[Client #{client_index}] Upstream returned HTTP #{res.code}")
+      end
+
+      sig { params(base_seconds: Float).returns(Float) }
+      def calculate_sleep(base_seconds)
+        return base_seconds if @config.jitter.zero?
+
+        variance = base_seconds * @config.jitter
+        [0.0, base_seconds + rand(-variance..variance)].max
+      end
+    end
+  end
+end

data/lib/http_loader/client/logger.rb

@@ -0,0 +1,111 @@
+# typed: strong
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+require 'fileutils'
+require 'time'
+
+module HttpLoader
+  class Client
+    # Handles asynchronous file logging to prevent blocking main connections.
+    class Logger
+      extend T::Sig
+
+      sig { params(verbose: T::Boolean).void }
+      def initialize(verbose)
+        @verbose = verbose
+        @log_dir = T.let(File.expand_path('../../../logs', __dir__), String)
+        @log_queue = T.let(Queue.new, Queue)
+        @logger_task = T.let(nil, T.nilable(T.untyped))
+      end
+
+      sig { void }
+      def setup_files!
+        FileUtils.mkdir_p(@log_dir)
+        File.write(File.join(@log_dir, 'client.err'), '')
+        File.write(File.join(@log_dir, 'client.log'), '') if @verbose
+      end
+
+      sig { params(task: T.untyped).returns(T.untyped) }
+      def run_task(task)
+        @logger_task = task.async do
+          File.open(File.join(@log_dir, 'client.log'), 'a') do |log|
+            File.open(File.join(@log_dir, 'client.err'), 'a') do |err|
+              poll_queue(task, log, err)
+            end
+          end
+        end
+      end
+
+      sig { void }
+      def flush_synchronously!
+        File.open(File.join(@log_dir, 'client.log'), 'a') do |log|
+          File.open(File.join(@log_dir, 'client.err'), 'a') do |err|
+            drain_queue(log, err)
+          end
+        end
+      rescue StandardError
+        nil
+      end
+
+      sig { params(message: String).void }
+      def info(message)
+        return unless @verbose
+
+        @log_queue << [:info, "[#{Time.now.utc.iso8601}] #{message}"]
+      end
+
+      sig { params(message: String).void }
+      def error(message)
+        @log_queue << [:error, "[#{Time.now.utc.iso8601}] #{message}"]
+      end
+
+      private
+
+      sig { params(task: T.untyped, log: File, err: File).void }
+      def poll_queue(task, log, err)
+        loop do
+          msg = fetch_message(task)
+          next unless msg
+          break if msg == :terminate
+
+          write_msg(msg, log, err)
+        end
+      end
+
+      sig { params(log: File, err: File).void }
+      def drain_queue(log, err)
+        loop do
+          msg = begin
+            @log_queue.pop(true)
+          rescue ThreadError
+            nil
+          end
+          break unless msg && msg != :terminate
+
+          write_msg(msg, log, err)
+        end
+      end
+
+      sig { params(task: T.untyped).returns(T.untyped) }
+      def fetch_message(task)
+        @log_queue.pop(true)
+      rescue ThreadError
+        task.sleep(0.05)
+        nil
+      end
+
+      sig { params(msg: T::Array[T.untyped], log: File, err: File).void }
+      def write_msg(msg, log, err)
+        target, content = msg
+        if target == :info
+          log.puts content
+          log.flush
+        elsif target == :error
+          err.puts content
+          err.flush
+        end
+      end
+    end
+  end
+end

data/lib/http_loader/client/slowloris.rb

@@ -0,0 +1,81 @@
+# typed: strong
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+
+module HttpLoader
+  class Client
+    # Handles deliberate thread-hogging Slowloris tactics.
+    class Slowloris
+      extend T::Sig
+
+      sig { params(config: Config, logger: Logger).void }
+      def initialize(config, logger)
+        @config = config
+        @logger = logger
+      end
+
+      sig { params(client_index: Integer, uri: URI::Generic, http: Net::HTTP, start_time: Time).void }
+      def run(client_index, uri, http, start_time)
+        return unless @config.slowloris_delay.positive?
+
+        # We must use T.unsafe because @socket is a protected state variable natively
+        socket_wrapper = T.unsafe(http).instance_variable_get(:@socket)
+        return unless socket_wrapper
+
+        io = socket_wrapper.io
+        fire_initial_payload(io, uri)
+        maintain_hold(client_index, io, start_time)
+      end
+
+      private
+
+      sig { params(io: IO, uri: URI::Generic).void }
+      def fire_initial_payload(io, uri)
+        payload = build_payload_headers(uri)
+
+        payload.each_char do |char|
+          io.write(char)
+          io.flush
+          sleep(calculate_sleep(@config.slowloris_delay))
+        end
+      end
+
+      sig { params(uri: URI::Generic).returns(String) }
+      def build_payload_headers(uri)
+        path = uri.path.empty? ? '/' : uri.path
+        query = uri.query ? "?#{uri.query}" : ''
+        payload = "GET #{path}#{query} HTTP/1.1\r\n" \
+                  "Host: #{uri.host}\r\n" \
+                  "Connection: keep-alive\r\n" \
+                  "User-Agent: #{@config.user_agent}\r\n"
+        @config.headers.each { |k, v| payload += "#{k}: #{v}\r\n" }
+        payload += 'X-Slowloris: ' # unfinished header
+        payload
+      end
+
+      sig { params(client_index: Integer, io: IO, start_time: Time).void }
+      def maintain_hold(client_index, io, start_time)
+        loop do
+          elapsed = Time.now - start_time
+          if @config.http_loader_timeout.positive? && elapsed >= @config.http_loader_timeout
+            @logger.info("[Client #{client_index}] Keep-alive timeout reached, closing Slowloris thread.")
+            break
+          end
+
+          io.write(rand(97..122).chr)
+          io.flush
+          sleep(calculate_sleep(@config.slowloris_delay))
+        end
+      end
+
+      sig { params(base_seconds: Float).returns(Float) }
+      def calculate_sleep(base_seconds)
+        return base_seconds if @config.jitter.zero?
+
+        variance = base_seconds * @config.jitter
+        [0.0, base_seconds + rand(-variance..variance)].max
+      end
+    end
+  end
+end

data/lib/http_loader/client/target_manager.rb

@@ -0,0 +1,99 @@
+# typed: strong
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+require 'uri'
+require 'socket'
+
+module HttpLoader
+  class Client
+    # Manages URI contexts, IPs, proxies, and HTTPS resolution.
+    class TargetManager
+      extend T::Sig
+
+      sig { params(config: Config).void }
+      def initialize(config)
+        @config = config
+        @target_contexts = T.let(build_target_contexts, T::Array[T::Hash[Symbol, T.untyped]])
+      end
+
+      sig { returns(String) }
+      def protocol_label
+        if @config.target_urls.size > 1
+          "MULTIPLE TARGETS (#{@config.target_urls.size})"
+        elsif @config.target_urls.size == 1
+          "EXTERNAL #{T.cast(T.must(@target_contexts.first)[:uri], URI::Generic).scheme&.upcase}"
+        elsif @config.use_https
+          'HTTPS'
+        else
+          'HTTP'
+        end
+      end
+
+      sig { returns(T::Array[T::Hash[Symbol, T.untyped]]) }
+      def contexts
+        @target_contexts
+      end
+
+      sig { params(client_index: Integer).returns(T::Hash[Symbol, T.untyped]) }
+      def context_for(client_index)
+        T.must(@target_contexts[client_index % @target_contexts.size])
+      end
+
+      sig { params(client_index: Integer, args: T::Hash[Symbol, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
+      def http_opts_for(client_index, args)
+        http_opts = args.dup
+        bind_ips = @config.bind_ips
+        http_opts[:local_host] = bind_ips[client_index % bind_ips.size] if bind_ips.any?
+
+        apply_proxy!(http_opts, client_index) if @config.proxy_pool.any?
+        http_opts
+      end
+
+      sig { params(opts: T::Hash[Symbol, T.untyped], client_index: Integer).void }
+      def apply_proxy!(opts, client_index)
+        pool = @config.proxy_pool
+        proxy_uri = URI.parse(pool[client_index % pool.size])
+        opts[:proxy_address] = proxy_uri.host
+        opts[:proxy_port] = proxy_uri.port
+        opts[:proxy_user] = proxy_uri.user if proxy_uri.user
+        opts[:proxy_pass] = proxy_uri.password if proxy_uri.password
+      end
+
+      private
+
+      sig { returns(T::Array[T::Hash[Symbol, T.untyped]]) }
+      def build_target_contexts
+        urls = @config.target_urls.any? ? @config.target_urls : [nil]
+        urls.map do |url|
+          uri = parse_uri(url)
+          args = { read_timeout: @config.read_timeout.positive? ? @config.read_timeout : nil }
+          args[:ipaddr] = resolve_ip(uri)
+          { uri: uri, http_args: secure_opts(uri, args) }
+        end
+      end
+
+      sig { params(url: T.nilable(String)).returns(URI::Generic) }
+      def parse_uri(url)
+        return URI(url.to_s) if url
+
+        @config.use_https ? URI('https://localhost:8443') : URI('http://localhost:8080')
+      end
+
+      sig { params(uri: URI::Generic).returns(T.nilable(String)) }
+      def resolve_ip(uri)
+        ip_info = Addrinfo.getaddrinfo(T.must(uri.host), uri.port, nil, :STREAM)
+        (ip_info.find(&:ipv4?) || ip_info.first)&.ip_address
+      rescue SocketError
+        nil
+      end
+
+      sig { params(uri: URI::Generic, args: T::Hash[Symbol, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
+      def secure_opts(uri, args)
+        return args unless uri.scheme == 'https'
+
+        args.merge(use_ssl: true, verify_mode: OpenSSL::SSL::VERIFY_NONE)
+      end
+    end
+  end
+end