raptor 0.7.0 → 0.9.0

data/ext/raptor_bpf/reuseport_select.bpf.c

@@ -0,0 +1,63 @@
+#include <linux/bpf.h>
+#include <bpf/bpf_helpers.h>
+
+#define MAX_WORKERS 64
+
+// Per-worker listening sockets, keyed by worker index.
+struct {
+  __uint(type, BPF_MAP_TYPE_REUSEPORT_SOCKARRAY);
+  __type(key, __u32);
+  __type(value, __u64);
+  __uint(max_entries, MAX_WORKERS);
+} socks SEC(".maps");
+
+// Worker count at slot 0, per-worker backlog at slots 1..N.
+struct {
+  __uint(type, BPF_MAP_TYPE_ARRAY);
+  __type(key, __u32);
+  __type(value, __u32);
+  __uint(max_entries, MAX_WORKERS + 1);
+} loads SEC(".maps");
+
+// Routes each incoming connection to the worker with the lowest backlog,
+// with a random tie-break when loads are equal.
+SEC("sk_reuseport")
+int select_least_loaded(struct sk_reuseport_md *ctx) {
+  __u32 count_key = 0;
+  __u32 *count_ptr = bpf_map_lookup_elem(&loads, &count_key);
+  if (!count_ptr || *count_ptr == 0) {
+    return SK_DROP;
+  }
+  __u32 num_workers = *count_ptr;
+  if (num_workers > MAX_WORKERS) {
+    num_workers = MAX_WORKERS;
+  }
+
+  __u32 min_load = ~0u;
+  __u32 max_load = 0;
+  __u32 min_idx = 0;
+
+  for (__u32 worker_idx = 0; worker_idx < MAX_WORKERS; worker_idx++) {
+    if (worker_idx >= num_workers) {
+      break;
+    }
+    __u32 worker_key = worker_idx + 1;
+    __u32 *load_ptr = bpf_map_lookup_elem(&loads, &worker_key);
+    if (!load_ptr) {
+      continue;
+    }
+    if (*load_ptr < min_load) {
+      min_load = *load_ptr;
+      min_idx = worker_idx;
+    }
+    if (*load_ptr > max_load) {
+      max_load = *load_ptr;
+    }
+  }
+
+  __u32 chosen_idx = (min_load == max_load) ? (bpf_get_prandom_u32() % num_workers) : min_idx;
+  bpf_sk_select_reuseport(ctx, &socks, &chosen_idx, 0);
+  return SK_PASS;
+}
+
+char _license[] SEC("license") = "GPL";

data/ext/raptor_http/extconf.rb

@@ -2,6 +2,6 @@
 
 require "mkmf"
 
-append_cflags("-fvisibility=hidden")
+append_cflags(["-fvisibility=hidden", "-Wno-type-limits"])
 
 create_makefile("raptor/raptor_http")

data/ext/raptor_native/extconf.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "mkmf"
+
+append_cflags("-fvisibility=hidden")
+
+create_makefile("raptor/raptor_native")

data/ext/raptor_native/raptor_native.c

@@ -0,0 +1,99 @@
+#ifdef __linux__
+#define _GNU_SOURCE 1
+#endif
+
+#include "ruby.h"
+#include "ruby/io.h"
+#include <sys/uio.h>
+#include <errno.h>
+#include <limits.h>
+
+#ifdef __linux__
+#include <sched.h>
+#include <unistd.h>
+#endif
+
+static VALUE eEAGAINWaitWritable;
+
+static VALUE raptor_native_writev_nonblock(VALUE self, VALUE io, VALUE strings) {
+  (void)self;
+  Check_Type(strings, T_ARRAY);
+  long len = RARRAY_LEN(strings);
+  if (len == 0) return LONG2NUM(0);
+  if (len > IOV_MAX) len = IOV_MAX;
+
+  int fd = rb_io_descriptor(io);
+  struct iovec *iov = alloca(len * sizeof(struct iovec));
+
+  for (long i = 0; i < len; i++) {
+    VALUE str = RARRAY_AREF(strings, i);
+    Check_Type(str, T_STRING);
+    iov[i].iov_base = RSTRING_PTR(str);
+    iov[i].iov_len = RSTRING_LEN(str);
+  }
+
+  ssize_t written;
+  while ((written = writev(fd, iov, (int)len)) < 0) {
+    if (errno == EINTR) continue;
+    if (errno == EAGAIN || errno == EWOULDBLOCK) rb_raise(eEAGAINWaitWritable, "writev would block");
+    rb_sys_fail("writev");
+  }
+
+  return LONG2NUM((long)written);
+}
+
+static VALUE raptor_native_pin_to_cpu(VALUE self, VALUE cpu) {
+  (void)self;
+#ifdef __linux__
+  int worker_index = NUM2INT(cpu);
+  cpu_set_t current;
+  CPU_ZERO(&current);
+  if (sched_getaffinity(0, sizeof(current), &current) < 0) rb_sys_fail("sched_getaffinity");
+
+  int cpu_id = -1;
+  int seen = 0;
+  for (int candidate = 0; candidate < CPU_SETSIZE; candidate++) {
+    if (!CPU_ISSET(candidate, &current)) continue;
+    if (seen == worker_index) { cpu_id = candidate; break; }
+    seen++;
+  }
+  if (cpu_id < 0) return Qfalse;
+
+  cpu_set_t set;
+  CPU_ZERO(&set);
+  CPU_SET(cpu_id, &set);
+  if (sched_setaffinity(0, sizeof(set), &set) < 0) rb_sys_fail("sched_setaffinity");
+  return Qtrue;
+#else
+  (void)cpu;
+  return Qfalse;
+#endif
+}
+
+static VALUE raptor_native_cpu_count(VALUE self) {
+  (void)self;
+#ifdef __linux__
+  cpu_set_t set;
+  CPU_ZERO(&set);
+  if (sched_getaffinity(0, sizeof(set), &set) < 0) rb_sys_fail("sched_getaffinity");
+  return LONG2NUM((long)CPU_COUNT(&set));
+#else
+  return LONG2NUM(0);
+#endif
+}
+
+RUBY_FUNC_EXPORTED void Init_raptor_native(void) {
+  rb_ext_ractor_safe(true);
+
+  VALUE mRaptor = rb_define_module("Raptor");
+  VALUE mVectorIO = rb_define_module_under(mRaptor, "VectorIO");
+  VALUE mCPU = rb_define_module_under(mRaptor, "CPU");
+
+  rb_define_singleton_method(mVectorIO, "writev_nonblock", raptor_native_writev_nonblock, 2);
+
+  rb_define_singleton_method(mCPU, "pin", raptor_native_pin_to_cpu, 1);
+  rb_define_singleton_method(mCPU, "count", raptor_native_cpu_count, 0);
+
+  eEAGAINWaitWritable = rb_const_get(rb_cIO, rb_intern("EAGAINWaitWritable"));
+  rb_global_variable(&eEAGAINWaitWritable);
+}

data/lib/rackup/handler/raptor.rb

@@ -78,18 +78,28 @@ module Rackup
           else
             config[:binds] || ["tcp://#{defaults[:Host]}:#{defaults[:Port]}"]
           end,
+          socket_backlog: (config[:socket_backlog] || cli_defaults[:socket_backlog]).to_i,
+          drain_accept_queue: config.key?(:drain_accept_queue) ? config[:drain_accept_queue] : cli_defaults[:drain_accept_queue],
           workers: (options[:Workers] || config[:workers] || Etc.nprocessors).to_i,
           ractors: (options[:Ractors] || config[:ractors] || cli_defaults[:ractors]).to_i,
           threads: (options[:Threads] || config[:threads] || cli_defaults[:threads]).to_i,
           app: app
         }
         result[:rackup] = config[:rackup] if config.key?(:rackup)
-        result[:client] = cli_defaults[:client].merge(config[:client] || {})
-        result[:worker_timeout] = (config[:worker_timeout] || cli_defaults[:worker_timeout]).to_i
+        result[:chdir] = config[:chdir] if config.key?(:chdir)
+        result[:environment] = config[:environment] if config.key?(:environment)
+        ::Raptor::CLI::NESTED_OPTION_KEYS.each do |key|
+          result[key] = cli_defaults[key].merge(config[key] || {})
+        end
         result[:worker_boot_timeout] = (config[:worker_boot_timeout] || cli_defaults[:worker_boot_timeout]).to_i
+        result[:worker_timeout] = (config[:worker_timeout] || cli_defaults[:worker_timeout]).to_i
+        result[:worker_drain_timeout] = (config[:worker_drain_timeout] || cli_defaults[:worker_drain_timeout]).to_i
         result[:worker_shutdown_timeout] = (config[:worker_shutdown_timeout] || cli_defaults[:worker_shutdown_timeout]).to_i
         result[:stats_file] = config.key?(:stats_file) ? config[:stats_file] : cli_defaults[:stats_file]
         result[:pid_file] = config[:pid_file] if config.key?(:pid_file)
+        result[:stdout_file] = config[:stdout_file] if config.key?(:stdout_file)
+        result[:stderr_file] = config[:stderr_file] if config.key?(:stderr_file)
+        result[:access_log_file] = config[:access_log_file] if config.key?(:access_log_file)
         result[:on_error] = config[:on_error] if config.key?(:on_error)
         result
       end

data/lib/raptor/binder.rb

@@ -56,7 +56,20 @@ module Raptor
     end
 
     # @rbs @bind_uris: Array[String]
+    # @rbs @socket_backlog: Integer
+    # @rbs @inherited_fds: Hash[String, Array[Integer]]
     # @rbs @listeners: Array[TCPServer | UNIXServer | SslListener]
+    # @rbs @uri_listeners: Hash[String, Array[TCPServer | UNIXServer | SslListener]]
+
+    # Array of bind URIs.
+    #
+    # @return [Array<String>] the bind URIs
+    attr_reader :bind_uris
+
+    # Kernel listen() queue depth for TCP/SSL listeners.
+    #
+    # @return [Integer] the socket backlog
+    attr_reader :socket_backlog
 
     # Array of listening sockets.
     #
@@ -67,19 +80,26 @@ module Raptor
     #
     # Parses the provided bind URIs and creates listening sockets for each one.
     # Supports tcp://, unix://, and ssl:// schemes. Localhost is expanded to
-    # all available loopback addresses (both IPv4 and IPv6).
+    # all available loopback addresses (both IPv4 and IPv6). When `inherited_fds`
+    # supplies file descriptors for a URI, the listener is reconstructed from
+    # those FDs instead of binding fresh.
     #
     # @param bind_uris [Array<String>] array of URI strings to bind to
+    # @param socket_backlog [Integer] kernel listen() queue depth for TCP/SSL listeners
+    # @param inherited_fds [Hash{String => Array<Integer>}] inherited listener FDs keyed by bind URI
     # @return [void]
     # @raise [UnknownBindSchemeError] if a URI has an unsupported scheme
     #
     # @example
     #   binder = Binder.new(["tcp://0.0.0.0:3000", "unix:///tmp/raptor.sock"])
     #
-    # @rbs (Array[String] bind_uris) -> void
-    def initialize(bind_uris)
+    # @rbs (Array[String] bind_uris, ?socket_backlog: Integer, ?inherited_fds: Hash[String, Array[Integer]]) -> void
+    def initialize(bind_uris, socket_backlog: SOCKET_BACKLOG, inherited_fds: {})
       @bind_uris = bind_uris
+      @socket_backlog = socket_backlog
+      @inherited_fds = inherited_fds
       @listeners = nil
+      @uri_listeners = nil
       parse
     end
 
@@ -133,28 +153,91 @@ module Raptor
       @listeners.each(&:close)
     end
 
+    # Returns the file descriptors of every listener, grouped by the bind URI
+    # they were created from. The result is the payload to hand to a successor
+    # process via the `inherited_fds:` constructor argument.
+    #
+    # @return [Hash{String => Array<Integer>}]
+    #
+    # @rbs () -> Hash[String, Array[Integer]]
+    def inheritable_fds
+      @uri_listeners.transform_values { |listeners| listeners.map { |listener| listener.to_io.fileno } }
+    end
+
+    # Clears the close-on-exec flag on every listener so the file descriptors
+    # survive `Kernel.exec`.
+    #
+    # @return [void]
+    #
+    # @rbs () -> void
+    def clear_close_on_exec
+      @listeners.each { |listener| listener.to_io.close_on_exec = false }
+    end
+
     private
 
-    # Parses bind URIs and creates listening sockets.
+    # Parses bind URIs and creates listening sockets, reusing inherited file
+    # descriptors for URIs supplied in `@inherited_fds`.
     #
     # @return [void]
     # @raise [UnknownBindSchemeError] if a URI scheme is not supported
     #
     # @rbs () -> void
     def parse
-      @listeners = @bind_uris.map do |bind_uri|
-        uri = URI.parse(bind_uri)
-        case uri.scheme
-        when "tcp"
-          create_tcp_listeners(uri.host, uri.port)
-        when "unix"
-          create_unix_listeners(uri.path)
-        when "ssl"
-          create_ssl_listeners(uri.host, uri.port, URI.decode_www_form(uri.query || "").to_h)
+      @uri_listeners = @bind_uris.to_h do |bind_uri|
+        if filenos = @inherited_fds[bind_uri]
+          [bind_uri, restore_listeners(bind_uri, filenos)]
         else
-          raise UnknownBindSchemeError.new(uri.scheme)
+          [bind_uri, create_listeners(bind_uri)]
         end
-      end.tap(&:flatten!)
+      end
+      @listeners = @uri_listeners.values.flatten
+    end
+
+    # Creates fresh listeners for the given bind URI.
+    #
+    # @param bind_uri [String] the URI to bind
+    # @return [Array<TCPServer, UNIXServer, SslListener>]
+    # @raise [UnknownBindSchemeError] if the URI scheme is not supported
+    #
+    # @rbs (String bind_uri) -> Array[TCPServer | UNIXServer | SslListener]
+    def create_listeners(bind_uri)
+      uri = URI.parse(bind_uri)
+      case uri.scheme
+      when "tcp"
+        create_tcp_listeners(uri.host, uri.port)
+      when "unix"
+        create_unix_listeners(uri.path)
+      when "ssl"
+        create_ssl_listeners(uri.host, uri.port, URI.decode_www_form(uri.query || "").to_h)
+      else
+        raise UnknownBindSchemeError.new(uri.scheme)
+      end
+    end
+
+    # Reconstructs listeners for the given bind URI from inherited file
+    # descriptors.
+    #
+    # @param bind_uri [String] the URI the FDs were bound to
+    # @param filenos [Array<Integer>] file descriptors to wrap
+    # @return [Array<TCPServer, UNIXServer, SslListener>]
+    # @raise [UnknownBindSchemeError] if the URI scheme is not supported
+    #
+    # @rbs (String bind_uri, Array[Integer] filenos) -> Array[TCPServer | UNIXServer | SslListener]
+    def restore_listeners(bind_uri, filenos)
+      uri = URI.parse(bind_uri)
+      case uri.scheme
+      when "tcp"
+        filenos.map { |fileno| TCPServer.for_fd(fileno) }
+      when "unix"
+        register_unix_socket_cleanup(uri.path)
+        filenos.map { |fileno| UNIXServer.for_fd(fileno) }
+      when "ssl"
+        ssl_context = build_ssl_context(URI.decode_www_form(uri.query || "").to_h)
+        filenos.map { |fileno| SslListener.new(tcp_server: TCPServer.for_fd(fileno), ssl_context: ssl_context) }
+      else
+        raise UnknownBindSchemeError.new(uri.scheme)
+      end
     end
 
     # Creates TCP server sockets for the given host and port.
@@ -171,11 +254,15 @@ module Raptor
 
       host = host[1..-2] if host&.start_with?("[")
 
-      tcp_server = TCPServer.new(host, port)
-      tcp_server.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
-      tcp_server.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEPORT, true) if Socket.const_defined?(:SO_REUSEPORT)
-      tcp_server.listen SOCKET_BACKLOG
+      addrinfo = Addrinfo.tcp(host, 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) if Socket.const_defined?(:SO_REUSEPORT)
+      socket.bind(addrinfo)
+      socket.listen(@socket_backlog)
 
+      tcp_server = TCPServer.for_fd(socket.fileno)
+      socket.autoclose = false
       [tcp_server]
     end
 
@@ -200,11 +287,22 @@ module Raptor
         end
       end
 
-      server = UNIXServer.new(path)
+      register_unix_socket_cleanup(path)
+
+      [UNIXServer.new(path)]
+    end
+
+    # Registers an `at_exit` hook that removes the Unix socket file on the
+    # owning master's clean exit. Each call records the current process so
+    # forked workers won't delete a socket their master still owns.
+    #
+    # @param path [String] filesystem path of the Unix socket
+    # @return [void]
+    #
+    # @rbs (String path) -> void
+    def register_unix_socket_cleanup(path)
       master_pid = Process.pid
       at_exit { File.delete(path) rescue nil if Process.pid == master_pid }
-
-      [server]
     end
 
     # Creates SSL server sockets for the given host, port, and SSL parameters.
@@ -220,18 +318,28 @@ module Raptor
     #
     # @rbs (String? host, Integer? port, Hash[String, String] ssl_params) -> Array[SslListener]
     def create_ssl_listeners(host, port, ssl_params)
-      require "openssl"
-
       tcp_servers = create_tcp_listeners(host, port)
+      ssl_context = build_ssl_context(ssl_params)
+      tcp_servers.map { |tcp_server| SslListener.new(tcp_server: tcp_server, ssl_context: ssl_context) }
+    end
 
-      ssl_context = OpenSSL::SSL::SSLContext.new
-      ssl_context.cert = OpenSSL::X509::Certificate.new(File.read(ssl_params["cert"]))
-      ssl_context.key = OpenSSL::PKey.read(File.read(ssl_params["key"]))
-      ssl_context.alpn_protocols = ["h2", "http/1.1"]
-      ssl_context.alpn_select_cb = ->(protocols) { protocols.include?("h2") ? "h2" : "http/1.1" }
-      ssl_context.freeze
+    # Builds a frozen `OpenSSL::SSL::SSLContext` configured for HTTP/2 and
+    # HTTP/1.1 ALPN negotiation.
+    #
+    # @param ssl_params [Hash<String, String>] SSL options ("cert" and "key" paths)
+    # @return [OpenSSL::SSL::SSLContext]
+    #
+    # @rbs (Hash[String, String] ssl_params) -> OpenSSL::SSL::SSLContext
+    def build_ssl_context(ssl_params)
+      require "openssl"
 
-      tcp_servers.map { |tcp_server| SslListener.new(tcp_server: tcp_server, ssl_context: ssl_context) }
+      OpenSSL::SSL::SSLContext.new.tap do |ssl_context|
+        ssl_context.cert = OpenSSL::X509::Certificate.new(File.read(ssl_params["cert"]))
+        ssl_context.key = OpenSSL::PKey.read(File.read(ssl_params["key"]))
+        ssl_context.alpn_protocols = ["h2", "http/1.1"]
+        ssl_context.alpn_select_cb = ->(protocols) { protocols.include?("h2") ? "h2" : "http/1.1" }
+        ssl_context.freeze
+      end
     end
 
     # Returns all available loopback IP addresses.

data/lib/raptor/cli.rb

@@ -26,24 +26,41 @@ module Raptor
   class CLI
     DEFAULT_WORKER_COUNT = Etc.nprocessors
 
+    NESTED_OPTION_KEYS = [:connection, :http1, :http2].freeze
+
     DEFAULT_OPTIONS = {
       binds: ["tcp://0.0.0.0:9292"].freeze,
+      socket_backlog: 1024,
+      drain_accept_queue: false,
       workers: DEFAULT_WORKER_COUNT,
       ractors: 1,
       threads: 3,
       rackup: "config.ru",
-      client: {
+      chdir: nil,
+      environment: nil,
+      connection: {
         first_data_timeout: 30,
         chunk_data_timeout: 10,
-        persistent_data_timeout: 65,
+        write_timeout: 5,
         max_body_size: nil,
         body_spool_threshold: 1024 * 1024,
       },
-      worker_timeout: 60,
+      http1: {
+        persistent_data_timeout: 65,
+        max_keepalive_requests: 100,
+      },
+      http2: {
+        max_concurrent_streams: 100,
+      },
       worker_boot_timeout: 60,
+      worker_timeout: 60,
+      worker_drain_timeout: 25,
       worker_shutdown_timeout: 30,
       stats_file: "tmp/raptor.json",
       pid_file: nil,
+      stdout_file: nil,
+      stderr_file: nil,
+      access_log_file: nil,
     }.freeze
 
     DEFAULT_CONFIG_PATHS = ["raptor.rb", "config/raptor.rb"].freeze
@@ -102,14 +119,17 @@ module Raptor
     #
     # @rbs (Array[String] argv) -> void
     def initialize(argv)
+      @options = DEFAULT_OPTIONS.dup
+      NESTED_OPTION_KEYS.each { |key| @options[key] = @options[key].dup }
+      @options[:launch_command] = $PROGRAM_NAME
+      @options[:launch_argv] = argv.dup
+
       if argv.first == "stats"
         argv.shift
         @command = :stats
       else
         @command = :server
       end
-      @options = DEFAULT_OPTIONS.dup
-      @options[:client] = @options[:client].dup
 
       apply_config_file(extract_config_path(argv) || self.class.default_config_path)
 
@@ -178,9 +198,6 @@ module Raptor
 
     # Loads a config file and merges it into `@options` over the defaults.
     #
-    # Top-level keys replace defaults; the nested `:client` hash is merged
-    # key-by-key so a config file does not need to restate every client option.
-    #
     # @param path [String, nil] path to the config file, or nil to no-op
     # @return [void]
     #
@@ -190,8 +207,8 @@ module Raptor
 
       config = self.class.load_config_file(path)
       config.each do |key, value|
-        if key == :client && value.is_a?(Hash)
-          @options[:client] = @options[:client].merge(value)
+        if NESTED_OPTION_KEYS.include?(key) && value.is_a?(Hash)
+          @options[key] = @options[key].merge(value)
         else
           @options[key] = value
         end
@@ -212,53 +229,85 @@ module Raptor
         end
 
         opts.on("-b", "--bind URI", String, "Bind address (default: tcp://0.0.0.0:9292)") do |bind|
-          if @options[:binds] == DEFAULT_OPTIONS[:binds]
+          if @options[:binds].equal?(DEFAULT_OPTIONS[:binds])
             @options[:binds] = [bind]
           else
             @options[:binds] << bind
           end
         end
 
+        opts.on("--socket-backlog NUM", Integer, "Socket listen backlog (default: 1024)") do |num|
+          @options[:socket_backlog] = num
+        end
+
+        opts.on("--[no-]drain-accept-queue", "Drain the kernel accept queue on shutdown (default: off)") do |bool|
+          @options[:drain_accept_queue] = bool
+        end
+
         opts.on("-w", "--workers NUM", Integer, "Number of worker processes (default: #{DEFAULT_WORKER_COUNT})") do |num|
           @options[:workers] = num
         end
 
-        opts.on("-r", "--ractors NUM", Integer, "Number of ractors (default: 1)") do |num|
+        opts.on("-r", "--ractors NUM", Integer, "Number of pipeline ractors per worker (default: 1)") do |num|
           @options[:ractors] = num
         end
 
-        opts.on("-t", "--threads NUM", Integer, "Number of threads (default: 3)") do |num|
+        opts.on("-t", "--threads NUM", Integer, "Number of application threads per worker (default: 3)") do |num|
           @options[:threads] = num
         end
 
+        opts.on("-C", "--chdir PATH", String, "Change to PATH before loading the Rack application (default: none)") do |path|
+          @options[:chdir] = path
+        end
+
+        opts.on("-e", "--environment ENV", String, "Application environment label; falls back to $RAILS_ENV, then $RACK_ENV, then development") do |env|
+          @options[:environment] = env
+        end
+
         opts.on("--first-data-timeout SECONDS", Integer, "First data timeout in seconds (default: 30)") do |timeout|
-          @options[:client][:first_data_timeout] = timeout
+          @options[:connection][:first_data_timeout] = timeout
         end
 
         opts.on("--chunk-data-timeout SECONDS", Integer, "Chunk data timeout in seconds (default: 10)") do |timeout|
-          @options[:client][:chunk_data_timeout] = timeout
+          @options[:connection][:chunk_data_timeout] = timeout
         end
 
-        opts.on("--persistent-data-timeout SECONDS", Integer, "Persistent data timeout in seconds (default: 65)") do |timeout|
-          @options[:client][:persistent_data_timeout] = timeout
+        opts.on("--write-timeout SECONDS", Integer, "Per-write socket timeout in seconds (default: 5)") do |timeout|
+          @options[:connection][:write_timeout] = timeout
         end
 
         opts.on("--max-body-size BYTES", Integer, "Maximum request body size in bytes (default: unlimited)") do |bytes|
-          @options[:client][:max_body_size] = bytes
+          @options[:connection][:max_body_size] = bytes
         end
 
-        opts.on("--body-spool-threshold BYTES", Integer, "Spool request bodies larger than this to a tempfile (default: #{1024 * 1024})") do |bytes|
-          @options[:client][:body_spool_threshold] = bytes
+        opts.on("--body-spool-threshold BYTES", Integer, "Request body spool threshold in bytes (default: #{1024 * 1024})") do |bytes|
+          @options[:connection][:body_spool_threshold] = bytes
         end
 
-        opts.on("--worker-timeout SECONDS", Integer, "Worker check-in timeout in seconds (default: 60)") do |timeout|
-          @options[:worker_timeout] = timeout
+        opts.on("--http1-persistent-data-timeout SECONDS", Integer, "HTTP/1.1 keep-alive idle timeout in seconds (default: 65)") do |timeout|
+          @options[:http1][:persistent_data_timeout] = timeout
+        end
+
+        opts.on("--http1-max-keepalive-requests NUM", Integer, "Maximum HTTP/1.1 requests per keep-alive connection (default: 100)") do |num|
+          @options[:http1][:max_keepalive_requests] = num
+        end
+
+        opts.on("--http2-max-concurrent-streams NUM", Integer, "Maximum HTTP/2 concurrent streams per connection (default: 100)") do |num|
+          @options[:http2][:max_concurrent_streams] = num
         end
 
         opts.on("--worker-boot-timeout SECONDS", Integer, "Worker boot timeout in seconds (default: 60)") do |timeout|
           @options[:worker_boot_timeout] = timeout
         end
 
+        opts.on("--worker-timeout SECONDS", Integer, "Worker check-in timeout in seconds (default: 60)") do |timeout|
+          @options[:worker_timeout] = timeout
+        end
+
+        opts.on("--worker-drain-timeout SECONDS", Integer, "Worker request-drain timeout in seconds (default: 25)") do |timeout|
+          @options[:worker_drain_timeout] = timeout
+        end
+
         opts.on("--worker-shutdown-timeout SECONDS", Integer, "Worker shutdown timeout in seconds (default: 30)") do |timeout|
           @options[:worker_shutdown_timeout] = timeout
         end
@@ -271,6 +320,18 @@ module Raptor
           @options[:pid_file] = path
         end
 
+        opts.on("--stdout-file PATH", String, "Redirect stdout to PATH; reopened on SIGHUP (default: none)") do |path|
+          @options[:stdout_file] = path
+        end
+
+        opts.on("--stderr-file PATH", String, "Redirect stderr to PATH; reopened on SIGHUP (default: none)") do |path|
+          @options[:stderr_file] = path
+        end
+
+        opts.on("--access-log-file PATH", String, "Write Common Log Format access logs to PATH; reopened on SIGHUP (default: none)") do |path|
+          @options[:access_log_file] = path
+        end
+
         opts.on("--help", "Show this help") do
           puts opts
           exit