raptor 0.18.0 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df28f67647ac4c928757722392b5a0da9f61a31c6f81ad7126b6023b12311355
-  data.tar.gz: 5f7e1298a2aa0fb6622db15749b503261b62a4321549b39f955282285bd74c0c
+  metadata.gz: 6620d52a503c84e57e9aea223f0980e2215aeb58da7154e077c31c0d1858bf12
+  data.tar.gz: 36c546ae9bb960f6049a82e123af665375785872533b4657f0c336abd8ab7a9f
 SHA512:
-  metadata.gz: 00bc3616aa1877c4b79f3acdf00165981ed6401e3a2fb16a2c1565ef92b557772dd1960b31f85b370778e3f2f735904eca6b8cf969ca4aa1f62de3687aea1839
-  data.tar.gz: af947a551e8f0e3b8d07bd8c07e9b1e686e8f36a1d48af458fb331e1ca8c937f44504b4c9895c233cfe3905d22bce1176d57438baa428e9d44257edc46ba5c1f
+  metadata.gz: 729594070744ec522ec48852af6cce2c5aeef4df2050359473bdbf3f11aeaa167dbf7124e9a2fa21e622f77b6351d508fa3f4cf7438839e1b4e8a037784a7c89
+  data.tar.gz: 6812627b196892d9ffbc7608d34fc54c790d2d96ecdd4fa0823946389cc147a6e1640028cd057b958e91e9a2fc6307397e693bd5e6e7998b1c41b9fc9d13195b

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 ## [Unreleased]
 
+## [0.19.0] - 2026-08-29
+
+- Skip HTTP/2 Ractor pools without SSL bindings
+- Default to adaptive application thread scaling
+
 ## [0.18.0] - 2026-08-29
 
 - Add adaptive application thread scaling with `max_threads`

data/README.md

@@ -36,30 +36,29 @@ run proc { |_env| [200, { "content-type" => "text/plain" }, ["Hello, World!"]] }
 
 ```
 > bundle exec raptor -w 10 -t 3 hello_world.ru
-[Raptor 83654|Main|Main] Cluster initializing:
-[Raptor 83654|Main|Main] ├─ Version: 0.18.0
-[Raptor 83654|Main|Main] ├─ Ruby Version: ruby 4.0.6 (2026-07-14 revision 03b6d3f889) +YJIT +PRISM [arm64-darwin23]
-[Raptor 83654|Main|Main] ├─ Environment: development
-[Raptor 83654|Main|Main] ├─ Master PID: 83654
-[Raptor 83654|Main|Main] │  └─ 10 worker processes
-[Raptor 83654|Main|Main] │     ├─ 1 server thread
-[Raptor 83654|Main|Main] │     ├─ 1 reactor thread
-[Raptor 83654|Main|Main] │     ├─ 1 HTTP/1.1 pipeline ractor
-[Raptor 83654|Main|Main] │     ├─ 1 HTTP/2 pipeline ractor
-[Raptor 83654|Main|Main] │     ├─ 2 pipeline collector threads
-[Raptor 83654|Main|Main] │     ├─ 3 worker threads
-[Raptor 83654|Main|Main] │     └─ 1 stats thread
-[Raptor 83654|Main|Main] └─ Listening on 0.0.0.0:9292
-[Raptor 83658|Main|Main] Worker 2 booted
-[Raptor 83659|Main|Main] Worker 3 booted
-[Raptor 83656|Main|Main] Worker 0 booted
-[Raptor 83660|Main|Main] Worker 4 booted
-[Raptor 83662|Main|Main] Worker 6 booted
-[Raptor 83657|Main|Main] Worker 1 booted
-[Raptor 83661|Main|Main] Worker 5 booted
-[Raptor 83663|Main|Main] Worker 7 booted
-[Raptor 83664|Main|Main] Worker 8 booted
-[Raptor 83665|Main|Main] Worker 9 booted
+[Raptor 46475|Main|Main] Cluster initializing:
+[Raptor 46475|Main|Main] ├─ Version: 0.19.0
+[Raptor 46475|Main|Main] ├─ Ruby Version: ruby 4.0.6 (2026-07-14 revision 03b6d3f889) +YJIT +PRISM [arm64-darwin23]
+[Raptor 46475|Main|Main] ├─ Environment: development
+[Raptor 46475|Main|Main] ├─ Master PID: 46475
+[Raptor 46475|Main|Main] │  └─ 10 worker processes
+[Raptor 46475|Main|Main] │     ├─ 1 server thread
+[Raptor 46475|Main|Main] │     ├─ 1 reactor thread
+[Raptor 46475|Main|Main] │     ├─ 1 HTTP/1.1 pipeline ractor
+[Raptor 46475|Main|Main] │     ├─ 1 pipeline collector thread
+[Raptor 46475|Main|Main] │     ├─ 3 worker threads (scaling, no limit)
+[Raptor 46475|Main|Main] │     └─ 1 stats thread
+[Raptor 46475|Main|Main] └─ Listening on 0.0.0.0:9292
+[Raptor 46480|Main|Main] Worker 0 booted
+[Raptor 46484|Main|Main] Worker 4 booted
+[Raptor 46482|Main|Main] Worker 2 booted
+[Raptor 46481|Main|Main] Worker 1 booted
+[Raptor 46483|Main|Main] Worker 3 booted
+[Raptor 46485|Main|Main] Worker 5 booted
+[Raptor 46486|Main|Main] Worker 6 booted
+[Raptor 46487|Main|Main] Worker 7 booted
+[Raptor 46488|Main|Main] Worker 8 booted
+[Raptor 46489|Main|Main] Worker 9 booted
 ```
 
 ```
@@ -93,7 +92,7 @@ The config file is a Ruby file that evaluates to a hash of options. By default R
   drain_accept_queue: false,
   workers: 4, # `Etc.nprocessors`
   threads: 3,
-  max_threads: nil, # `Float::INFINITY` for no limit
+  max_threads: Float::INFINITY, # set to `threads` for a fixed pool
   chdir: nil,
   environment: nil, # falls back to `RAILS_ENV`, then `RACK_ENV`, then `"development"`
   connection: {
@@ -129,10 +128,10 @@ The config file is a Ruby file that evaluates to a hash of options. By default R
 }
 ```
 
-`threads` sets the number of application threads each worker keeps running. Set `max_threads` above it to let Raptor
-add temporary threads when queued work is held up by blocking operations, or use `Float::INFINITY` for no limit.
-Raptor does not add threads when waiting for the GVL is the bottleneck. Temporary threads leave after the queue
-drains. The default `nil` keeps the pool fixed at `threads`.
+`threads` sets the number of application threads each worker keeps running. By default, Raptor adds temporary threads
+without a fixed limit when queued work is held up by blocking operations. It does not add threads when waiting for the
+GVL is the bottleneck, and temporary threads leave after the queue drains. Set `max_threads` to cap growth, or set it
+to the same value as `threads` for a fixed pool.
 
 ## Bindings
 
@@ -207,7 +206,7 @@ Worker 1 (phase 0): pid=91351, requests=1199, busy=1/3, backlog=0, booted, last_
 
 ## (Micro) Benchmarks
 
-Raptor 0.18.0 vs Puma 8.0.2 vs Falcon 0.57.0 across two workload profiles. **IO-bound** is a GET endpoint that
+Raptor 0.19.0 vs Puma 8.0.2 vs Falcon 0.57.0 across two workload profiles. **IO-bound** is a GET endpoint that
 interleaves 5-10 short sleeps (total 2.5-15ms) with small CPU work, simulating a read path that makes several DB or
 cache calls. **CPU-bound** is a POST endpoint that accepts a small JSON body, interleaves 3-5 chunks of JSON item
 building (total 450-1500 items) with sub-100µs sleeps, and returns the built array, simulating a write path that does

data/docs/brisrails-talk.md

@@ -1085,18 +1085,18 @@ The bit that matters most in practice:
 
 ## Scaling app threads without making CPU contention worse
 
-The pool stays fixed at `threads` unless you set `max_threads`.
+The pool starts at `threads` and scales automatically when more threads would help.
 
 - <big>A native CRuby thread hook measures time running, blocked outside the GVL, and waiting for the GVL</big>
 - <big>The queue has to stay non-empty, and every current worker has to be active</big>
 - <big>Blocked time has to exceed half of worker time</big>
 - <big>GVL wait has to stay below two percent</big>
-- <big>Only then does the pool add a temporary thread, up to `max_threads`</big>
+- <big>Only then does the pool add a temporary thread</big>
 - <big>When the queue drains, temporary threads leave and the pool returns to `threads`</big>
 
 The distinction matters. More threads help when requests are asleep in database or network calls. They make CPU-bound Ruby slower when the GVL is already the bottleneck.
 
-`max_threads: Float::INFINITY` allows the pool to grow without a fixed limit. That still does not make OS threads as cheap as fibers.
+Growth has no fixed limit by default. Set `max_threads` to cap it, or set it to `threads` to keep the pool fixed. OS threads still are not as cheap as fibers.
 
 <br>
 <br>

data/docs/raptor-vs-puma.md

@@ -38,7 +38,7 @@ The rest of this doc explains why the shape looks like that.
 | ---------------------- | ------------------------------------------------------- | ---------------------------------------------------------------------------- |
 | Ruby requirement       | 3.0 and up                                              | 4.0 and up (needs `Ractor::Port`)                                          |
 | Process model          | Single, or cluster (pre-forks by default with 2+ workers); optional refork | Cluster only, always pre-forks                                               |
-| Threading model        | `ThreadPool` with `Mutex` + `ConditionVariable`; autoscaling min/max, or fixed when min == max | `AtomicThreadPool` with a CAS-based queue; fixed by default, with GVL-aware adaptive scaling up to a configured limit |
+| Threading model        | `ThreadPool` with `Mutex` + `ConditionVariable`; autoscaling min/max, or fixed when min == max | `AtomicThreadPool` with a CAS-based queue; GVL-aware adaptive scaling from a fixed baseline, with an optional limit |
 | True parallelism       | One GVL inside each worker; parser runs on an app thread | Protocol Ractors can parse in parallel with the app on the pipeline path     |
 | I/O multiplexing       | `nio4r` reactor for keep-alive idle and slow reads      | `nio4r` reactor for the same, plus a red-black tree for O(log n) timeouts    |
 | Cluster dispatch       | Workers race on inherited listeners with a load-proportional accept delay | Two-choice load-aware BPF dispatch for TCP on Linux; shared-listener fallback |
@@ -234,11 +234,11 @@ Your Rack app still runs on ordinary threads under one worker GVL, so the app do
 
 **How the Ractor pools actually work.** Raptor uses the `ractor-pool` gem, which is another one of my libraries. Each pool has one coordinator Ractor and M pipeline Ractors. When a pipeline Ractor is idle, it sends itself back to the coordinator via `coordinator.send(Ractor.current, move: true)`. When work arrives at the coordinator, it either forwards it to a waiting Ractor (if any) or queues it. This coordinator-dispatch pattern guarantees that no Ractor sits idle while there is work. Results flow back through a shared `Ractor::Port` (a many-to-one channel added in recent Ruby versions and stable in 4.0) to a Ruby-side collector thread. If `M == 1` the coordinator is skipped and work goes straight to the single pipeline Ractor.
 
-Raptor runs two independent pools per worker, one for HTTP/1.1 parsing and one for HTTP/2 parsing. Both defaults scale with headroom via `round(cores / workers)`, clamped to `[1, 3]` for `http1.ractors` and `[1, 2]` for `http2.ractors`. Splitting the pools means h1 and h2 parsing never share ractor slots, so a burst of small HTTP/1.1 requests cannot delay HTTP/2 frame handling on the same connection, and vice versa.
+Raptor always runs an HTTP/1.1 pool because every binding supports HTTP/1.1. It only starts an HTTP/2 pool when an SSL binding is present, since HTTP/2 is negotiated over TLS. SSL bindings still need both pools because ALPN allows each client to choose HTTP/2 or HTTP/1.1. Both pool sizes scale with headroom via `round(cores / workers)`, clamped to `[1, 3]` for `http1.ractors` and `[1, 2]` for `http2.ractors`. Keeping the pools separate means h1 and h2 parsing never share ractor slots, so a burst of small HTTP/1.1 requests cannot delay HTTP/2 frame handling on the same connection, and vice versa.
 
 **Why a custom thread pool.** The `AtomicThreadPool` in `atomic-ruby` (another one of my libraries) is backed by an `AtomicQueue`. The queue is a Michael-Scott multi-producer, multi-consumer FIFO: a singly linked list with a dummy sentinel and atomic head and tail pointers. Producers append nodes at the tail; consumers advance the head. Both operations are O(1) and make progress through compare-and-swap rather than a queue-wide mutex. Separate atoms track queue size and active app threads for backpressure.
 
-The pool is fixed at `threads` by default. Setting `max_threads` above that baseline enables adaptive growth; `Float::INFINITY` removes the fixed limit. A native CRuby thread-event hook measures how much active workers spend running, blocked outside the GVL, and waiting to acquire it. The pool only adds a temporary thread after work has remained queued across several samples, every current worker is active, blocked time is above half of measured worker time, and GVL wait is below two percent. That last check matters: adding threads helps when existing threads are asleep in database or network calls, but hurts when CPU-bound Ruby threads are already fighting over the GVL. Temporary threads retire after the queue has remained empty for a second.
+The pool starts at `threads` and scales without a fixed limit by default. Set `max_threads` to cap its growth, or set it to the same value as `threads` to keep the pool fixed. A native CRuby thread-event hook measures how much active workers spend running, blocked outside the GVL, and waiting to acquire it. The pool only adds a temporary thread after work has remained queued across several samples, every current worker is active, blocked time is above half of measured worker time, and GVL wait is below two percent. That last check matters: adding threads helps when existing threads are asleep in database or network calls, but hurts when CPU-bound Ruby threads are already fighting over the GVL. Temporary threads retire after the queue has remained empty for a second.
 
 The pool still uses an `AtomicConditionVariable` under the hood to park idle threads (idle threads call `Thread.stop` and get woken with `Thread#wakeup`; there is no spinning), because idle spinning would waste CPU. The difference from Puma's pool is not "no locks anywhere" but rather "the hot path (enqueue and dequeue when the queue has items) is lock-free". Once every worker is busy the mechanics look similar; where things diverge is under contention when you have many threads all trying to push and pop.
 

data/lib/rackup/handler/raptor.rb

@@ -44,7 +44,7 @@ module Rackup
           "Port=PORT"      => "Port to listen on (default: #{DEFAULT_OPTIONS[:Port]})",
           "Workers=NUM"    => "Number of worker processes (default: available processor count)",
           "Threads=NUM"    => "Number of threads per worker (default: 3)",
-          "MaxThreads=NUM" => "Maximum threads per worker (`unlimited` for no limit; default: fixed at Threads)",
+          "MaxThreads=NUM" => "Maximum threads per worker (`unlimited` for no limit; default: unlimited)",
           "Config=PATH"    => "Load additional configuration from PATH"
         }
       end
@@ -71,6 +71,8 @@ module Rackup
         cli_defaults = ::Raptor::CLI::DEFAULT_OPTIONS
         config_path = options[:Config] || ::Raptor::CLI.default_config_path
         config = config_path ? ::Raptor::CLI.load_config_file(config_path) : {}
+        threads = (options[:Threads] || config[:threads] || cli_defaults[:threads]).to_i
+        max_threads = options[:MaxThreads] || config.fetch(:max_threads, cli_defaults[:max_threads])
 
         result = {
           binds: if options[:Host] || options[:Port]
@@ -81,8 +83,8 @@ module Rackup
           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] || Concurrent.available_processor_count).to_i,
-          threads: (options[:Threads] || config[:threads] || cli_defaults[:threads]).to_i,
-          max_threads: ::Raptor::CLI.parse_max_threads(options[:MaxThreads] || config[:max_threads]),
+          threads: threads,
+          max_threads: ::Raptor::CLI.parse_max_threads(max_threads, threads: threads),
           app: app
         }
         result[:rackup] = config[:rackup] if config.key?(:rackup)

data/lib/raptor/binder.rb

@@ -106,6 +106,15 @@ module Raptor
       tcp_listener.local_address.ip_port
     end
 
+    # Returns whether any listener can negotiate HTTP/2.
+    #
+    # @return [Boolean]
+    #
+    # @rbs () -> bool
+    def http2?
+      @listeners.any? { |listener| listener.is_a?(SslListener) }
+    end
+
     # Closes all listening sockets.
     #
     # @return [void]

data/lib/raptor/cli.rb

@@ -34,7 +34,7 @@ module Raptor
       drain_accept_queue: false,
       workers: DEFAULT_WORKER_COUNT,
       threads: 3,
-      max_threads: nil,
+      max_threads: Float::INFINITY,
       rackup: "config.ru",
       chdir: nil,
       environment: nil,
@@ -101,17 +101,27 @@ module Raptor
 
     # Parses a maximum thread count from a CLI, config, or Rack handler value.
     #
-    # @param value [Integer, Float, String, nil] maximum thread count
-    # @return [Integer, Float, nil] parsed thread count, `Float::INFINITY` for
-    #   `"unlimited"`, or nil for a fixed-size pool
+    # @param value [Integer, Float, String] maximum thread count
+    # @param threads [Integer] baseline thread count
+    # @return [Integer, Float] parsed thread count, or `Float::INFINITY` for
+    #   `"unlimited"`
+    # @raise [ArgumentError] if the maximum is nil or less than the baseline
     #
-    # @rbs (Integer | Float | String | nil value) -> (Integer | Float)?
-    def self.parse_max_threads(value)
-      return unless value
-      return Float::INFINITY if value == "unlimited" || value == Float::INFINITY
-      return value if value.is_a?(Integer)
+    # @rbs (Integer | Float | String value, threads: Integer) -> (Integer | Float)
+    def self.parse_max_threads(value, threads:)
+      raise ArgumentError, "max_threads cannot be nil" unless value
+
+      max_threads = if value == "unlimited" || value == Float::INFINITY
+        Float::INFINITY
+      elsif value.is_a?(Integer)
+        value
+      else
+        Integer(value, 10)
+      end
+
+      raise ArgumentError, "max_threads must be greater than or equal to threads" if max_threads < threads
 
-      Integer(value, 10)
+      max_threads
     end
 
     # @rbs @command: Symbol
@@ -146,7 +156,7 @@ module Raptor
       @parser.parse!(argv)
 
       @options[:rackup] = argv.first if @command == :server && argv.first
-      @options[:max_threads] = self.class.parse_max_threads(@options[:max_threads])
+      @options[:max_threads] = self.class.parse_max_threads(@options[:max_threads], threads: @options[:threads])
     end
 
     # Runs the requested command.
@@ -259,7 +269,7 @@ module Raptor
           @options[:threads] = num
         end
 
-        opts.on("--max-threads NUM", "Maximum application threads per worker (`unlimited` for no limit; default: fixed at --threads)") do |num|
+        opts.on("--max-threads NUM", "Maximum application threads per worker (`unlimited` for no limit; default: unlimited)") do |num|
           @options[:max_threads] = num
         end
 

data/lib/raptor/cluster.rb

@@ -126,7 +126,7 @@ module Raptor
     # @option options [Boolean] :drain_accept_queue whether to drain the kernel accept queue on shutdown
     # @option options [Integer] :workers number of worker processes
     # @option options [Integer] :threads number of threads per worker process
-    # @option options [Integer, Float, nil] :max_threads maximum number of threads per worker process, `Float::INFINITY` for no limit, or nil for a fixed-size pool
+    # @option options [Integer, Float] :max_threads maximum number of threads per worker process, or `Float::INFINITY` for no limit
     # @option options [#call] :app pre-built Rack application
     # @option options [String] :rackup path to Rack configuration file
     # @option options [String, nil] :chdir directory to change to before loading the Rack application, or nil to leave the working directory unchanged
@@ -784,15 +784,17 @@ module Raptor
         end
       end
 
-      http2_ractor_pool = RactorPool.new(
-        size: @http2_ractor_count,
-        worker: http2.parser_worker,
-        name: "HTTP/2"
-      ) do |parsed_result|
-        begin
-          http2.handle_parsed_request(parsed_result, reactor, thread_pool)
-        rescue => error
-          Log.rescued_error(error)
+      http2_ractor_pool = if @binder.http2?
+        RactorPool.new(
+          size: @http2_ractor_count,
+          worker: http2.parser_worker,
+          name: "HTTP/2"
+        ) do |parsed_result|
+          begin
+            http2.handle_parsed_request(parsed_result, reactor, thread_pool)
+          rescue => error
+            Log.rescued_error(error)
+          end
         end
       end
 
@@ -871,7 +873,7 @@ module Raptor
       reactor.shutdown
       reactor_thread.join
       http1_ractor_pool.shutdown
-      http2_ractor_pool.shutdown
+      http2_ractor_pool&.shutdown
       http1.shutdown
       drain_thread_pool(thread_pool)
       stats_thread.join
@@ -979,8 +981,10 @@ module Raptor
       Log.info "│     ├─ 1 server thread"
       Log.info "│     ├─ 1 reactor thread"
       Log.info "│     ├─ #{@http1_ractor_count} HTTP/1.1 pipeline ractor#{"s" if @http1_ractor_count > 1}"
-      Log.info "│     ├─ #{@http2_ractor_count} HTTP/2 pipeline ractor#{"s" if @http2_ractor_count > 1}"
-      Log.info "│     ├─ 2 pipeline collector threads"
+      http2_enabled = @binder.http2?
+      Log.info "│     ├─ #{@http2_ractor_count} HTTP/2 pipeline ractor#{"s" if @http2_ractor_count > 1}" if http2_enabled
+      collector_count = http2_enabled ? 2 : 1
+      Log.info "│     ├─ #{collector_count} pipeline collector thread#{"s" if collector_count > 1}"
       thread_limit = if @max_thread_count == Float::INFINITY
         " (scaling, no limit)"
       elsif @max_thread_count

data/lib/raptor/reactor.rb

@@ -71,7 +71,7 @@ module Raptor
     # Creates a new Reactor instance.
     #
     # @param http1_ractor_pool [RactorPool] ractor pool for HTTP/1.x parsing
-    # @param http2_ractor_pool [RactorPool] ractor pool for HTTP/2 parsing
+    # @param http2_ractor_pool [RactorPool, nil] ractor pool for HTTP/2 parsing, or nil when no listener supports HTTP/2
     # @param thread_pool [AtomicThreadPool] thread pool for application processing
     # @param connection_options [Hash] per-connection timeout configuration
     # @option connection_options [Integer] :first_data_timeout timeout for initial data

data/lib/raptor/version.rb

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

data/sig/generated/raptor/binder.rbs

@@ -81,6 +81,13 @@ module Raptor
     # @rbs () -> Integer
     def server_port: () -> Integer
 
+    # Returns whether any listener can negotiate HTTP/2.
+    #
+    # @return [Boolean]
+    #
+    # @rbs () -> bool
+    def http2?: () -> bool
+
     # Closes all listening sockets.
     #
     # @return [void]

data/sig/generated/raptor/cli.rbs

@@ -46,12 +46,14 @@ module Raptor
 
     # Parses a maximum thread count from a CLI, config, or Rack handler value.
     #
-    # @param value [Integer, Float, String, nil] maximum thread count
-    # @return [Integer, Float, nil] parsed thread count, `Float::INFINITY` for
-    #   `"unlimited"`, or nil for a fixed-size pool
-    #
-    # @rbs (Integer | Float | String | nil value) -> (Integer | Float)?
-    def self.parse_max_threads: (Integer | Float | String | nil value) -> (Integer | Float)?
+    # @param value [Integer, Float, String] maximum thread count
+    # @param threads [Integer] baseline thread count
+    # @return [Integer, Float] parsed thread count, or `Float::INFINITY` for
+    #   `"unlimited"`
+    # @raise [ArgumentError] if the maximum is nil or less than the baseline
+    #
+    # @rbs (Integer | Float | String value, threads: Integer) -> (Integer | Float)
+    def self.parse_max_threads: (Integer | Float | String value, threads: Integer) -> (Integer | Float)
 
     @parser: OptionParser
 

data/sig/generated/raptor/cluster.rbs

@@ -150,7 +150,7 @@ module Raptor
     # @option options [Boolean] :drain_accept_queue whether to drain the kernel accept queue on shutdown
     # @option options [Integer] :workers number of worker processes
     # @option options [Integer] :threads number of threads per worker process
-    # @option options [Integer, Float, nil] :max_threads maximum number of threads per worker process, `Float::INFINITY` for no limit, or nil for a fixed-size pool
+    # @option options [Integer, Float] :max_threads maximum number of threads per worker process, or `Float::INFINITY` for no limit
     # @option options [#call] :app pre-built Rack application
     # @option options [String] :rackup path to Rack configuration file
     # @option options [String, nil] :chdir directory to change to before loading the Rack application, or nil to leave the working directory unchanged

data/sig/generated/raptor/reactor.rbs

@@ -73,7 +73,7 @@ module Raptor
     # Creates a new Reactor instance.
     #
     # @param http1_ractor_pool [RactorPool] ractor pool for HTTP/1.x parsing
-    # @param http2_ractor_pool [RactorPool] ractor pool for HTTP/2 parsing
+    # @param http2_ractor_pool [RactorPool, nil] ractor pool for HTTP/2 parsing, or nil when no listener supports HTTP/2
     # @param thread_pool [AtomicThreadPool] thread pool for application processing
     # @param connection_options [Hash] per-connection timeout configuration
     # @option connection_options [Integer] :first_data_timeout timeout for initial data

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: raptor
 version: !ruby/object:Gem::Version
-  version: 0.18.0
+  version: 0.19.0
 platform: ruby
 authors:
 - Joshua Young