raptor 0.8.0 → 0.10.0

data/lib/raptor/http1.rb

@@ -19,9 +19,11 @@ module Raptor
   #
   class Http1
     BODY_BUFFER_THRESHOLD = 256 * 1024
+    CHUNKED_WRITE_THRESHOLD = 512 * 1024
     FILE_CHUNK_SIZE = 64 * 1024
     MAX_CHUNK_OVERHEAD = 16 * 1024
     READ_BUFFER_SIZE = 64 * 1024
+    RESPONSE_BUFFER_CAPACITY = 4 * 1024
     KEEPALIVE_READ_TIMEOUT = 0.001
     MAX_KEEPALIVE_REQUESTS = 100
 
@@ -122,6 +124,7 @@ module Raptor
 
     # @rbs @app: ^(Hash[String, untyped]) -> [Integer, Hash[String, String | Array[String]], untyped]
     # @rbs @server_port: Integer
+    # @rbs @server_port_string: String
     # @rbs @write_timeout: Integer
     # @rbs @max_body_size: Integer?
     # @rbs @body_spool_threshold: Integer?
@@ -129,6 +132,7 @@ module Raptor
     # @rbs @access_log_io: IO?
     # @rbs @on_error: ^(Hash[String, untyped]?, Exception) -> void | nil
     # @rbs @running: AtomicBoolean
+    # @rbs @env_template: Hash[String, untyped]
 
     # Creates a new Http1 handler.
     #
@@ -148,6 +152,7 @@ module Raptor
     def initialize(app, server_port, connection_options: {}, http1_options: {}, access_log_io: nil, on_error: nil)
       @app = app
       @server_port = server_port
+      @server_port_string = server_port.to_s.freeze
       @write_timeout = connection_options[:write_timeout] || Http::WRITE_TIMEOUT
       @max_body_size = connection_options[:max_body_size]
       @body_spool_threshold = connection_options[:body_spool_threshold]
@@ -155,6 +160,13 @@ module Raptor
       @access_log_io = access_log_io
       @on_error = on_error
       @running = AtomicBoolean.new(true)
+      @env_template = {
+        Rack::RACK_VERSION => Rack::VERSION,
+        Rack::RACK_IS_HIJACK => true,
+        Rack::SCRIPT_NAME => "",
+        Rack::QUERY_STRING => "",
+        Http::SERVER_SOFTWARE => Http::SERVER_SOFTWARE_VALUE
+      }.freeze
     end
 
     # Instance-level wrapper around {Http.socket_write} that applies the
@@ -170,6 +182,19 @@ module Raptor
       Http.socket_write(socket, string, timeout: @write_timeout)
     end
 
+    # Instance-level wrapper around {Http.socket_writev} that applies the
+    # configured `write_timeout`.
+    #
+    # @param socket [TCPSocket] the socket to write to
+    # @param strings [Array<String>] the buffers to write in order
+    # @return [void]
+    # @raise [Http::WriteError] if the socket is not writable within the timeout or raises IOError
+    #
+    # @rbs (TCPSocket socket, Array[String] strings) -> void
+    def socket_writev(socket, strings)
+      Http.socket_writev(socket, strings, timeout: @write_timeout)
+    end
+
     # Signals eager keep-alive loops to stop processing further requests on
     # their connections. In-flight requests complete normally.
     #
@@ -194,8 +219,10 @@ module Raptor
     #
     # @rbs (TCPSocket socket, Integer id, Reactor reactor, AtomicThreadPool thread_pool, String remote_addr, String url_scheme) -> void
     def eager_accept(socket, id, reactor, thread_pool, remote_addr, url_scheme)
-      data = begin
-        socket.read_nonblock(READ_BUFFER_SIZE)
+      buffer = (Thread.current[:raptor_read_buffer] ||= String.new(capacity: READ_BUFFER_SIZE))
+
+      begin
+        socket.read_nonblock(READ_BUFFER_SIZE, buffer)
       rescue IO::WaitReadable
         reactor.add(
           id: id,
@@ -209,15 +236,12 @@ module Raptor
         return
       end
 
-      buffer = String.new
-      buffer << data
-
       while socket.respond_to?(:pending) && socket.pending > 0
         buffer << socket.read_nonblock(socket.pending)
       end
 
       parser = HttpParser.new
-      env = {}
+      env = @env_template.dup
       nread = begin
         parser.execute(env, buffer, 0)
       rescue HttpParserError
@@ -278,12 +302,13 @@ module Raptor
     # @rbs () -> ^(Hash[Symbol, untyped]) -> Hash[Symbol, untyped]
     def http_parser_worker
       max_body_size = @max_body_size
+      env_template = @env_template
 
       proc do |data|
         next Raptor::Http2.process_frames(data) if data[:protocol] == :http2
 
         parser = Raptor::HttpParser.new
-        env = {}
+        env = env_template.dup
         nread = begin
           parser.execute(env, data[:buffer], 0)
         rescue Raptor::HttpParserError
@@ -530,8 +555,10 @@ module Raptor
           return
         end
 
-        data = begin
-          socket.read_nonblock(READ_BUFFER_SIZE)
+        buffer = (Thread.current[:raptor_read_buffer] ||= String.new(capacity: READ_BUFFER_SIZE))
+
+        begin
+          socket.read_nonblock(READ_BUFFER_SIZE, buffer)
         rescue IO::WaitReadable
           reactor.persist(socket, id, request_count, remote_addr: remote_addr, url_scheme: url_scheme)
           return
@@ -540,15 +567,12 @@ module Raptor
           return
         end
 
-        buffer = String.new
-        buffer << data
-
         while socket.respond_to?(:pending) && socket.pending > 0
           buffer << socket.read_nonblock(socket.pending)
         end
 
         parser = HttpParser.new
-        env = {}
+        env = @env_template.dup
         nread = begin
           parser.execute(env, buffer, 0)
         rescue HttpParserError
@@ -631,7 +655,7 @@ module Raptor
       reactor.persist(socket, id, request_count, remote_addr: remote_addr, url_scheme: url_scheme)
       state = {
         id: id,
-        buffer: buffer,
+        buffer: buffer.dup,
         env: env,
         request_count: request_count,
         parse_data: parse_data,
@@ -682,53 +706,54 @@ module Raptor
     #
     # @rbs (Hash[String, untyped] env, Hash[Symbol, untyped] parse_data, String? body, TCPSocket socket, ?remote_addr: String, ?url_scheme: String) -> Hash[String, untyped]
     def build_rack_env(env, parse_data, body, socket, remote_addr: Server::DEFAULT_REMOTE_ADDR, url_scheme: Server::HTTP_SCHEME)
-      env[Rack::RACK_VERSION] = Rack::VERSION
       env[Rack::RACK_INPUT] = build_rack_input(body)
       env[Rack::RACK_ERRORS] = $stderr
       env[Rack::RACK_RESPONSE_FINISHED] = []
-
-      env[Rack::RACK_IS_HIJACK] = true
       env[Rack::RACK_HIJACK] = proc do
         env[RACK_HIJACKED] = true
         env[RACK_HIJACK_IO] = socket
         socket
       end
-
       env[Rack::RACK_EARLY_HINTS] = proc do |hints|
         send_early_hints(socket, hints) rescue nil
       end
 
-      env[Rack::SCRIPT_NAME] = "" unless env.key?(Rack::SCRIPT_NAME)
       env[Rack::PATH_INFO] = env.delete(Rack::REQUEST_PATH) if env.key?(Rack::REQUEST_PATH)
       env[Rack::PATH_INFO] = "" unless env.key?(Rack::PATH_INFO)
-      env[Rack::QUERY_STRING] = "" unless env.key?(Rack::QUERY_STRING)
-
       if (content_length = parse_data[:content_length]).positive?
         env[Http::CONTENT_LENGTH] = content_length.to_s
       end
 
       env[Http::REMOTE_ADDR] = remote_addr
-      env[Http::SERVER_SOFTWARE] = Http::SERVER_SOFTWARE_VALUE
       env[Http::HTTP_VERSION] = env[Rack::SERVER_PROTOCOL]
 
       behind_tls_proxy = (url_scheme == Server::HTTP_SCHEME) && forwarded_https?(env)
       env[Rack::RACK_URL_SCHEME] = behind_tls_proxy ? Server::HTTPS_SCHEME : url_scheme
-      default_port = behind_tls_proxy ? "443" : @server_port.to_s
+      default_port = behind_tls_proxy ? "443" : @server_port_string
 
       http_host = env[Rack::HTTP_HOST]
-      if http_host
+      host = nil
+      port = nil
+      if http_host && !http_host.empty?
         if http_host.start_with?("[")
-          host = http_host[/\A\[([^\]]+)\]/, 1]
-          port = http_host[/\]:(\d+)\z/, 1]
+          bracket_end = http_host.index("]")
+          if bracket_end
+            host = http_host.byteslice(1, bracket_end - 1)
+            port_colon = http_host.index(":", bracket_end + 1)
+            port = port_colon && http_host.byteslice(port_colon + 1, http_host.bytesize - port_colon - 1)
+          end
         else
-          host, port = http_host.split(":", 2)
+          colon = http_host.index(":")
+          if colon
+            host = http_host.byteslice(0, colon)
+            port = http_host.byteslice(colon + 1, http_host.bytesize - colon - 1)
+          else
+            host = http_host
+          end
         end
-        env[Rack::SERVER_NAME] ||= host
-        env[Rack::SERVER_PORT] ||= port || default_port
-      else
-        env[Rack::SERVER_NAME] ||= Server::DEFAULT_SERVER_NAME
-        env[Rack::SERVER_PORT] ||= default_port
       end
+      env[Rack::SERVER_NAME] ||= host || Server::DEFAULT_SERVER_NAME
+      env[Rack::SERVER_PORT] ||= port || default_port
 
       env
     end
@@ -922,7 +947,8 @@ module Raptor
       end
     end
 
-    # Builds the HTTP status line string.
+    # Returns the HTTP status line for `status`. Callers must not retain the
+    # returned string across further calls on the same thread.
     #
     # @param http_version [String] "HTTP/1.1" or "HTTP/1.0"
     # @param status [Integer] HTTP status code
@@ -931,7 +957,10 @@ module Raptor
     # @rbs (String http_version, Integer status) -> String
     def build_status_line(http_version, status)
       cache = http_version == HTTP_11 ? STATUS_LINE_CACHE_11 : STATUS_LINE_CACHE_10
-      cache[status].dup
+      response = (Thread.current[:raptor_response_buffer] ||= String.new(capacity: RESPONSE_BUFFER_CAPACITY))
+      response.clear
+      response << cache[status]
+      response
     end
 
     # Writes response headers and delegates body writing to the hijack callback.
@@ -1032,8 +1061,6 @@ module Raptor
       else
         raise TypeError, "body must respond to each, to_ary, or to_path"
       end
-
-      socket_write(socket, "0\r\n\r\n") if use_chunked
     end
 
     # Calculates content length from an array or file body without consuming it.
@@ -1073,10 +1100,16 @@ module Raptor
     def write_file_body(socket, response, path, content_length, use_chunked)
       File.open(path, "rb") do |file|
         if use_chunked
-          socket_write(socket, response)
+          buffer = response
           while (chunk = file.read(FILE_CHUNK_SIZE))
-            socket_write(socket, "#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n")
+            buffer << chunk.bytesize.to_s(16) << "\r\n" << chunk << "\r\n"
+            if buffer.bytesize >= CHUNKED_WRITE_THRESHOLD
+              socket_write(socket, buffer)
+              buffer = +""
+            end
           end
+          buffer << "0\r\n\r\n"
+          socket_write(socket, buffer)
         elsif content_length && content_length < BODY_BUFFER_THRESHOLD
           response << file.read(content_length)
           socket_write(socket, response)
@@ -1106,10 +1139,7 @@ module Raptor
       end
     end
 
-    # Writes a single-element array body, optionally buffering it with the headers.
-    #
-    # Small bodies are concatenated with the headers into one write to reduce
-    # system call overhead.
+    # Writes a single-element array body to the socket.
     #
     # @param socket [TCPSocket] the client socket
     # @param response [String] headers already serialized, to be written before the body
@@ -1123,13 +1153,10 @@ module Raptor
       raise TypeError, "body must yield String values" unless chunk.is_a?(String)
 
       if use_chunked
-        response << "#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n"
+        response << chunk.bytesize.to_s(16) << "\r\n" << chunk << "\r\n0\r\n\r\n"
         socket_write(socket, response)
-      elsif chunk.bytesize < BODY_BUFFER_THRESHOLD
-        socket_write(socket, response << chunk)
       else
-        socket_write(socket, response)
-        socket_write(socket, chunk)
+        socket_writev(socket, [response, chunk])
       end
     end
 
@@ -1145,21 +1172,25 @@ module Raptor
     # @rbs (TCPSocket socket, String response, Array[String] body_array, bool use_chunked) -> void
     def write_multiple_chunks(socket, response, body_array, use_chunked)
       if use_chunked
-        socket_write(socket, response)
+        buffer = response
         body_array.each do |chunk|
           raise TypeError, "body must yield String values" unless chunk.is_a?(String)
 
           next if chunk.empty?
 
-          socket_write(socket, "#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n")
+          buffer << chunk.bytesize.to_s(16) << "\r\n" << chunk << "\r\n"
+          if buffer.bytesize >= CHUNKED_WRITE_THRESHOLD
+            socket_write(socket, buffer)
+            buffer = +""
+          end
         end
+        buffer << "0\r\n\r\n"
+        socket_write(socket, buffer)
       else
         body_array.each do |chunk|
           raise TypeError, "body must yield String values" unless chunk.is_a?(String)
-
-          response << chunk
         end
-        socket_write(socket, response)
+        socket_writev(socket, [response, *body_array])
       end
     end
 
@@ -1183,6 +1214,7 @@ module Raptor
 
           socket_write(socket, "#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n")
         end
+        socket_write(socket, "0\r\n\r\n")
       else
         body.each do |chunk|
           raise TypeError, "body must yield String values" unless chunk.is_a?(String)
@@ -1227,15 +1259,42 @@ module Raptor
       headers.each do |name, value|
         next if illegal_header_key?(name)
 
-        Array(value).flat_map { |entry| entry.to_s.split("\n") }.each do |header_value|
-          next if illegal_header_value?(header_value)
-
-          result << "#{name}: #{header_value}\r\n"
+        if value.is_a?(Array)
+          value.each { |entry| append_header_value(result, name, entry) }
+        else
+          append_header_value(result, name, value)
         end
       end
       result
     end
 
+    # Appends one or more `name: value` header lines to `result`. Newline-
+    # separated values are emitted as separate lines; empty values and values
+    # with illegal characters are skipped silently.
+    #
+    # @param result [String] the buffer to append to
+    # @param name [String] the header name
+    # @param value [Object] the header value (any object responding to `to_s`)
+    # @return [void]
+    #
+    # @rbs (String result, String name, untyped value) -> void
+    def append_header_value(result, name, value)
+      string_value = value.is_a?(String) ? value : value.to_s
+      return if string_value.empty?
+
+      if string_value.include?("\n")
+        string_value.split("\n").each do |line|
+          next if line.empty? || illegal_header_value?(line)
+
+          result << name << ": " << line << "\r\n"
+        end
+      else
+        return if illegal_header_value?(string_value)
+
+        result << name << ": " << string_value << "\r\n"
+      end
+    end
+
     # Calls all rack.response_finished callbacks registered in the environment.
     #
     # Callbacks are called in reverse registration order. Individual callback

data/lib/raptor/reuseport_bpf.rb

@@ -0,0 +1,109 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+require "socket"
+require "uri"
+
+begin
+  require "libbpf-ruby"
+rescue LoadError
+end
+
+module Raptor
+  # Routes incoming connections across worker processes to the worker with
+  # the lowest reactor backlog.
+  #
+  # Auto-enabled on Linux when the `libbpf-ruby` gem is installed and the
+  # BPF object file has been compiled. Falls back silently to standard
+  # `SO_REUSEPORT` when either is missing. Raises when the kernel refuses
+  # the BPF program. Wraps `tcp://` bindings only; non-tcp bindings are
+  # left to the binder's shared listeners.
+  #
+  module ReuseportBPF
+    LIBBPF_LOADED = !!defined?(LibBPFRuby)
+    BPF_OBJECT_PATH = File.expand_path("../../ext/raptor_bpf/reuseport_select.bpf.o", __dir__)
+
+    # Whether the preconditions for BPF-directed reuseport are met on this
+    # platform. Does not imply that the kernel will accept the program.
+    #
+    # @return [Boolean]
+    #
+    # @rbs () -> bool
+    def self.supported?
+      LIBBPF_LOADED && File.exist?(BPF_OBJECT_PATH)
+    end
+
+    # Prepares BPF-directed routing for `worker_count` workers.
+    #
+    # Returns true when BPF-directed dispatch is active. Returns false
+    # when the platform is unsupported. Raises when the kernel refuses
+    # the program.
+    #
+    # @param worker_count [Integer] number of worker processes that will bind sockets
+    # @return [Boolean]
+    #
+    # @rbs (Integer worker_count) -> bool
+    def self.setup(worker_count)
+      return false unless supported?
+
+      @object = LibBPFRuby::Object.new(BPF_OBJECT_PATH)
+      @program_fd = @object.program_fd("select_least_loaded")
+      @socks_fd = @object.map_fd("socks")
+      @loads_fd = @object.map_fd("loads")
+
+      LibBPFRuby.map_update(@loads_fd, [0].pack("L"), [worker_count].pack("L"))
+      true
+    end
+
+    # Returns tcp listening sockets bound and registered for `worker_index`.
+    # Skips non-tcp bind URIs.
+    #
+    # @param bind_uris [Array<String>] the configured bind URIs
+    # @param worker_index [Integer] slot index for this worker in the socks map
+    # @param socket_backlog [Integer] kernel listen() queue depth
+    # @return [Array<TCPServer>] the tcp listening sockets created for this worker
+    #
+    # @rbs (Array[String] bind_uris, Integer worker_index, Integer socket_backlog) -> Array[TCPServer]
+    def self.create_worker_listeners(bind_uris, worker_index, socket_backlog)
+      @load_key = [worker_index + 1].pack("L")
+      @load_value = String.new("\x00\x00\x00\x00", encoding: Encoding::ASCII_8BIT)
+
+      bind_uris.filter_map do |bind_uri|
+        uri = URI(bind_uri)
+        next unless uri.scheme == "tcp"
+
+        host = uri.host
+        host = host[1..-2] if host&.start_with?("[")
+
+        addrinfo = Addrinfo.tcp(host, uri.port)
+        socket = Socket.new(addrinfo.afamily, Socket::SOCK_STREAM, 0)
+        socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
+        socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEPORT, true)
+        socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+        socket.bind(addrinfo)
+        socket.listen(socket_backlog)
+
+        LibBPFRuby.sockmap_update(@socks_fd, [worker_index].pack("L"), socket)
+        LibBPFRuby.attach_reuseport(socket, @program_fd)
+
+        tcp_server = TCPServer.for_fd(socket.fileno)
+        socket.autoclose = false
+        tcp_server
+      end
+    end
+
+    # Publishes this worker's current backlog to the BPF map.
+    #
+    # @param backlog [Integer] the worker's current reactor backlog
+    # @return [void]
+    #
+    # @rbs (Integer backlog) -> void
+    def self.update_load(backlog)
+      @load_value.setbyte(0, backlog & 0xff)
+      @load_value.setbyte(1, (backlog >> 8) & 0xff)
+      @load_value.setbyte(2, (backlog >> 16) & 0xff)
+      @load_value.setbyte(3, (backlog >> 24) & 0xff)
+      LibBPFRuby.map_update(@loads_fd, @load_key, @load_value)
+    end
+  end
+end

data/lib/raptor/server.rb

@@ -5,6 +5,8 @@ require "socket"
 
 require "atomic-ruby/atomic_boolean"
 
+require_relative "reuseport_bpf"
+
 module Raptor
   # Accepts client connections and dispatches them into the request
   # pipeline. Skips acceptance when the reactor backlog is high so an
@@ -22,7 +24,7 @@ module Raptor
   #   reactor = Reactor.new(ractor_pool, thread_pool, connection_options: {}, http1_options: {})
   #   http1 = Http1.new(app, 3000)
   #   http2 = Http2.new(app, 3000)
-  #   server = Server.new(binder, reactor, thread_pool, http1, http2, connection_options: { first_data_timeout: 30 })
+  #   server = Server.new(binder, reactor, thread_pool, http1, http2, connection_options: { first_data_timeout: 30 }, listeners: binder.listeners)
   #   server.run
   #   # ... later
   #   server.shutdown
@@ -36,15 +38,17 @@ module Raptor
     DEFAULT_REMOTE_ADDR = "127.0.0.1"
     DEFAULT_SERVER_NAME = "localhost"
 
-    MIN_BACKPRESSURE_THRESHOLD = 64
+    MIN_BACKPRESSURE_THRESHOLD = 8
 
     # @rbs @binder: Binder
+    # @rbs @listeners: Array[TCPServer | UNIXServer | Binder::SslListener]
     # @rbs @reactor: Reactor
     # @rbs @thread_pool: AtomicThreadPool
     # @rbs @http1: Http1
     # @rbs @http2: Http2
     # @rbs @first_data_timeout: Integer
     # @rbs @drain_accept_queue: bool
+    # @rbs @bpf_active: bool
     # @rbs @running: AtomicBoolean
 
     # Creates a new Server instance.
@@ -55,44 +59,52 @@ module Raptor
     # @param http1 [Http1] the HTTP/1.1 handler
     # @param http2 [Http2] the HTTP/2 handler (provides the initial SETTINGS frame)
     # @param connection_options [Hash] per-connection timeout configuration, used to bound TLS handshakes
+    # @param listeners [Array] the per-worker listeners this server accepts on
     # @param drain_accept_queue [Boolean] whether to drain the kernel accept queue on shutdown
+    # @param worker_index [Integer, nil] the slot index for BPF load reporting
     # @return [void]
     #
-    # @rbs (Binder binder, Reactor reactor, AtomicThreadPool thread_pool, Http1 http1, Http2 http2, connection_options: Hash[Symbol, untyped], ?drain_accept_queue: bool) -> void
-    def initialize(binder, reactor, thread_pool, http1, http2, connection_options:, drain_accept_queue: false)
+    # @rbs (Binder binder, Reactor reactor, AtomicThreadPool thread_pool, Http1 http1, Http2 http2, connection_options: Hash[Symbol, untyped], listeners: Array[untyped], ?drain_accept_queue: bool, ?worker_index: Integer?) -> void
+    def initialize(binder, reactor, thread_pool, http1, http2, connection_options:, listeners:, drain_accept_queue: false, worker_index: nil)
       @binder = binder
+      @listeners = listeners
       @reactor = reactor
       @thread_pool = thread_pool
       @http1 = http1
       @http2 = http2
       @first_data_timeout = connection_options[:first_data_timeout]
       @drain_accept_queue = drain_accept_queue
+      @bpf_active = !!worker_index
       @running = AtomicBoolean.new(true)
     end
 
     # Starts the server's main accept loop in a new thread.
     #
     # The accept loop polls listening sockets for ready connections and accepts
-    # them when system capacity allows. It checks reactor backlog before accepting
-    # to prevent overload. This provides natural load balancing across multiple
-    # worker processes through backpressure control.
+    # them when the reactor backlog is under the backpressure threshold. On
+    # Linux with BPF-directed dispatch active, a companion thread publishes
+    # this worker's backlog to the BPF map.
     #
     # @return [Thread] the thread running the accept loop
     #
     # @rbs () -> Thread
     def run
+      spawn_load_reporter if @bpf_active
+
       Thread.new do
         Thread.current.name = "Server"
 
+        backpressure_threshold = [(@thread_pool.size * 1.2).ceil, MIN_BACKPRESSURE_THRESHOLD].max
+
         while @running.true?
           begin
-            ready_servers, _, _ = IO.select(@binder.listeners, nil, nil, 1)
+            ready_servers, _, _ = IO.select(@listeners, nil, nil, 1)
           rescue IOError, Errno::EBADF
             break
           end
 
           next unless ready_servers
-          next if @reactor.backlog >= [(@thread_pool.size * 1.2).ceil, MIN_BACKPRESSURE_THRESHOLD].max
+          next if @reactor.backlog >= backpressure_threshold
 
           ready_servers.each { |listener| accept_connection(listener) }
         end
@@ -111,11 +123,28 @@ module Raptor
     def shutdown
       @running.make_false
       drain_accept_queue if @drain_accept_queue
-      @binder.close
+      @listeners.each(&:close)
     end
 
     private
 
+    # Starts a background thread that publishes this worker's reactor
+    # backlog to the BPF map for load-aware dispatch.
+    #
+    # @return [void]
+    #
+    # @rbs () -> void
+    def spawn_load_reporter
+      Thread.new do
+        Thread.current.name = "Load Reporter"
+
+        while @running.true?
+          ReuseportBPF.update_load(@reactor.backlog)
+          sleep 0.01
+        end
+      end
+    end
+
     # Dispatches every connection already in the kernel accept queue for each
     # listener until all are drained.
     #
@@ -125,7 +154,7 @@ module Raptor
     def drain_accept_queue
       loop do
         accepted = false
-        @binder.listeners.each { |listener| accepted = true if accept_connection(listener) }
+        @listeners.each { |listener| accepted = true if accept_connection(listener) }
         break unless accepted
       end
     end
@@ -150,7 +179,6 @@ module Raptor
       end
 
       if tcp_client.is_a?(TCPSocket)
-        tcp_client.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
         remote_addr = tcp_client.remote_address.ip_address
       else
         remote_addr = DEFAULT_REMOTE_ADDR

data/lib/raptor/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Raptor
-  VERSION = "0.8.0"
+  VERSION = "0.10.0"
 end

data/sig/generated/raptor/binder.rbs

@@ -61,6 +61,16 @@ module Raptor
 
     @bind_uris: Array[String]
 
+    # Array of bind URIs.
+    #
+    # @return [Array<String>] the bind URIs
+    attr_reader bind_uris: untyped
+
+    # Kernel listen() queue depth for TCP/SSL listeners.
+    #
+    # @return [Integer] the socket backlog
+    attr_reader socket_backlog: untyped
+
     # Array of listening sockets.
     #
     # @return [Array<TCPServer, UNIXServer, SslListener>] the server sockets

data/sig/generated/raptor/cluster.rbs

@@ -40,8 +40,6 @@ module Raptor
     # @rbs (Hash[Symbol, untyped] options) -> void
     def self.run: (Hash[Symbol, untyped] options) -> void
 
-    @http1_options: Hash[Symbol, untyped]
-
     @http2_options: Hash[Symbol, untyped]
 
     @worker_boot_timeout: Integer
@@ -92,6 +90,10 @@ module Raptor
 
     @hot_restart_requested: bool
 
+    @bpf_active: bool
+
+    @http1_options: Hash[Symbol, untyped]
+
     @connection_options: Hash[Symbol, untyped]
 
     @environment: String