puma 6.6.0 → 7.0.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94e6b5d56525a92e2e279d59467572a254c7c03b9dc14a3e91ec5eba67b54620
-  data.tar.gz: 55e78ab10a5d222cce09dc89a92fbbd15d8e8ae7abbec95ca309e2903f68bd97
+  metadata.gz: 695cb479d32857b62538bba8ced9800338e2d36d2eb988cbb79b64f71bcfd549
+  data.tar.gz: 131ea05b36e3408f9611e69bc42c9301a934d9cfc271093ab5bef7b9b8558752
 SHA512:
-  metadata.gz: 750f9ec059b9710eb5ae739dc04ad600fff8386a40dc3ef83500189caacf8b7413d01eb60d751befd1aa077f3565e60617d13ceba8b9a0c29912abf410b700ff
-  data.tar.gz: 1a56b1696333ae86e643bd045ebe83f6a1700ac5df948113a443326e867ce17bf3f4b7e05e01cda6b99605130a2b77ccf49d2ae153ad2e879971c7238d652548
+  metadata.gz: 90b89539f0ed2d5bf8dd6832f3cbffe93df0318b1ce8c7ecf051e86b3f6c057f8ab7c98e99f660f15625ed63a4ae05b5fedbaf882d6fd3d17a4f1a193a922c33
+  data.tar.gz: 0423f25bc1e9286b1b001074c2a7544c88d7b770d3018b738bc7aaad926c2767d2269908f5e180cd6c6cb9e5612b384eedddf7523752cd8737f81bedcf165009

data/History.md

@@ -1,3 +1,18 @@
+## 7.0.0.pre1 / 2025-07-31
+
+* Changed
+  * Fix long tail response problem with keepalive connections ([#3678])
+
+## 6.6.1 / 2025-07-30
+
+* Bugfixes
+  * Accept `to_path` to be `nil` on request bodies ([#3635])
+  * Fix single runner stats before the server start ([#3572])
+  * Fix incomplete worker boot state on refork ([#3601])
+  * Improve HttpParserError messages for better debugging ([#3586])
+  * Fix refork logs to distinguish from phased restarts ([#3598])
+  * Fix `rack.after_reply` so it doesn't interrupt chain on error ([#3680])
+
 ## 6.6.0 / 2025-01-29
 
 * Features
@@ -163,7 +178,7 @@
 
 * Features
   * Ability to supply a custom logger ([#2770], [#2511])
-  * Warn when clustered-only hooks are defined in single mode ([#3089])
+  * Warn when cluster mode-only hooks are defined in single mode ([#3089])
   * Adds the on_booted event ([#2709])
 
 * Bugfixes
@@ -758,7 +773,7 @@ Each patchlevel release contains a separate security fix. We recommend simply up
   * Fix Java 8 support ([#1773])
   * Fix error `uninitialized constant Puma::Cluster` ([#1731])
   * Fix `not_token` being able to be set to true ([#1803])
-  * Fix "Hang on SIGTERM with ruby 2.6 in clustered mode" (PR [#1741], [#1674], [#1720], [#1730], [#1755])
+  * Fix "Hang on SIGTERM with ruby 2.6 in cluster mode" (PR [#1741], [#1674], [#1720], [#1730], [#1755])
 
 ## 3.12.1 / 2019-03-19
 
@@ -1169,7 +1184,7 @@ Each patchlevel release contains a separate security fix. We recommend simply up
 * 4 minor features:
 
   * Listen to unix socket with provided backlog if any
-  * Improves the clustered stats to report worker stats
+  * Improves the cluster mode stats to report worker stats
   * Pass the env to the lowlevel_error handler. Fixes [#854]
   * Treat path-like hosts as unix sockets. Fixes [#824]
 
@@ -1896,7 +1911,7 @@ The "clearly I don't have enough tests for the config" release.
 
 * 3 doc changes:
   * Add note about on_worker_boot hook
-  * Add some documentation for Clustered mode
+  * Add some documentation for Cluster mode
   * Added quotes to /etc/puma.conf
 
 ## 2.0.1 / 2013-04-30
@@ -2150,6 +2165,13 @@ be added back in a future date when a java Puma::MiniSSL is added.
 * Bugfixes
   * Your bugfix goes here <Most recent on the top, like GitHub> (#Github Number)
 
+[#3678]:https://github.com/puma/puma/pull/3678     "PR by @MSP-Greg, merged 2025-07-31"
+[#3680]:https://github.com/puma/puma/pull/3680     "PR by @byroot, merged 2025-07-31"
+[#3572]:https://github.com/puma/puma/pull/3572     "PR by @barthez, merged 2025-02-06"
+[#3586]:https://github.com/puma/puma/pull/3586     "PR by @MSP-Greg, merged 2025-02-03"
+[#3598]:https://github.com/puma/puma/pull/3598     "PR by @joshuay03, merged 2025-01-31"
+[#3601]:https://github.com/puma/puma/pull/3601     "PR by @joshuay03, merged 2025-01-31"
+[#3635]:https://github.com/puma/puma/pull/3635     "PR by @LevitatingBusinessMan, merged 2025-05-08"
 [#3570]:https://github.com/puma/puma/pull/3570     "PR by @mohamedhafez, merged 2024-12-30"
 [#3567]:https://github.com/puma/puma/issues/3567   "Issue by @mohamedhafez, closed 2024-12-30"
 [#3383]:https://github.com/puma/puma/pull/3383     "PR by @joshuay03, merged 2024-11-29"

data/README.md

@@ -4,7 +4,7 @@
 
 # Puma: A Ruby Web Server Built For Parallelism
 
-[![Actions](https://github.com/puma/puma/workflows/Tests/badge.svg?branch=master)](https://github.com/puma/puma/actions?query=workflow%3ATests)
+[![Actions](https://github.com/puma/puma/actions/workflows/tests.yml/badge.svg?branch=master)](https://github.com/puma/puma/actions/workflows/tests.yml?query=branch%3Amaster)
 [![Code Climate](https://codeclimate.com/github/puma/puma.svg)](https://codeclimate.com/github/puma/puma)
 [![StackOverflow](https://img.shields.io/badge/stackoverflow-Puma-blue.svg)]( https://stackoverflow.com/questions/tagged/puma )
 
@@ -102,9 +102,9 @@ Puma will automatically scale the number of threads, from the minimum until it c
 
 Be aware that additionally Puma creates threads on its own for internal purposes (e.g. handling slow clients). So, even if you specify -t 1:1, expect around 7 threads created in your application.
 
-### Clustered mode
+### Cluster mode
 
-Puma also offers "clustered mode". Clustered mode `fork`s workers from a master process. Each child process still has its own thread pool. You can tune the number of workers with the `-w` (or `--workers`) flag:
+Puma also offers "cluster mode". Cluster mode `fork`s workers from a master process. Each child process still has its own thread pool. You can tune the number of workers with the `-w` (or `--workers`) flag:
 
 ```
 $ puma -t 8:32 -w 3
@@ -116,13 +116,13 @@ Or with the `WEB_CONCURRENCY` environment variable:
 $ WEB_CONCURRENCY=3 puma -t 8:32
 ```
 
-Note that threads are still used in clustered mode, and the `-t` thread flag setting is per worker, so `-w 2 -t 16:16` will spawn 32 threads in total, with 16 in each worker process.
+Note that threads are still used in cluster mode, and the `-t` thread flag setting is per worker, so `-w 2 -t 16:16` will spawn 32 threads in total, with 16 in each worker process.
 
 If the `WEB_CONCURRENCY` environment variable is set to `"auto"` and the `concurrent-ruby` gem is available in your application, Puma will set the worker process count to the result of [available processors](https://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent.html#available_processor_count-class_method).
 
 For an in-depth discussion of the tradeoffs of thread and process count settings, [see our docs](https://github.com/puma/puma/blob/9282a8efa5a0c48e39c60d22ca70051a25df9f55/docs/kubernetes.md#workers-per-pod-and-other-config-issues).
 
-In clustered mode, Puma can "preload" your application. This loads all the application code *prior* to forking. Preloading reduces total memory usage of your application via an operating system feature called [copy-on-write](https://en.wikipedia.org/wiki/Copy-on-write).
+In cluster mode, Puma can "preload" your application. This loads all the application code *prior* to forking. Preloading reduces total memory usage of your application via an operating system feature called [copy-on-write](https://en.wikipedia.org/wiki/Copy-on-write).
 
 If the `WEB_CONCURRENCY` environment variable is set to a value > 1 (and `--prune-bundler` has not been specified), preloading will be enabled by default. Otherwise, you can use the `--preload` flag from the command line:
 
@@ -140,9 +140,9 @@ preload_app!
 
 Preloading can’t be used with phased restart, since phased restart kills and restarts workers one-by-one, and preloading copies the code of master into the workers.
 
-#### Clustered mode hooks
+#### Cluster mode hooks
 
-When using clustered mode, Puma's configuration DSL provides `before_fork` and `on_worker_boot`
+When using cluster mode, Puma's configuration DSL provides `before_fork` and `on_worker_boot`
 hooks to run code when the master process forks and child workers are booted respectively.
 
 It is recommended to use these hooks with `preload_app!`, otherwise constants loaded by your
@@ -176,7 +176,7 @@ after_refork do
 end
 ```
 
-Importantly, note the following considerations when Ruby forks a child process: 
+Importantly, note the following considerations when Ruby forks a child process:
 
 1. File descriptors such as network sockets **are** copied from the parent to the forked
    child process. Dual-use of the same sockets by parent and child will result in I/O conflicts

data/docs/signals.md

@@ -17,13 +17,13 @@ $ ps aux | grep tail
 schneems        87152   0.0  0.0  2432772    492 s032  S+   12:46PM   0:00.00 tail -f my.log
 ```
 
-You can send a signal in Ruby using the [Process module](https://ruby-doc.org/3.2.2/Process.html#method-c-kill):
+You can send a signal in Ruby using the [Process module](https://docs.ruby-lang.org/en/master/Process.html#method-c-kill):
 
 ```
 $ irb
 > puts pid
 => 87152
-Process.detach(pid) # https://ruby-doc.org/3.2.2/Process.html#method-c-detach
+Process.detach(pid) # https://docs.ruby-lang.org/en/master/Process.html#method-c-detach
 Process.kill("TERM", pid)
 ```
 

data/docs/stats.md

@@ -65,7 +65,8 @@ When Puma runs in single mode, these stats are available at the top level. When
   and is not used for any internal decisions, unlike `busy_theads`, which is usually a more useful stat.
 * max_threads: the maximum number of threads Puma is configured to spool per worker
 * requests_count: the number of requests this worker has served since starting
-
+* reactor_max: the maximum observed number of requests held in Puma's "reactor" which is used for asyncronously buffering request bodies. This stat is reset on every call, so it's the maximum value observed since the last stat call.
+* backlog_max: the maximum number of requests that have been fully buffered by the reactor and placed in a ready queue, but have not yet been picked up by a server thread. This stat is reset on every call, so it's the maximum value observed since the last stat call.
 
 ### cluster mode
 

data/docs/systemd.md

@@ -72,7 +72,7 @@ systemd and Puma also support socket activation, where systemd opens the
 listening socket(s) in advance and provides them to the Puma master process on
 startup. Among other advantages, this keeps listening sockets open across puma
 restarts and achieves graceful restarts, including when upgraded Puma, and is
-compatible with both clustered mode and application preload.
+compatible with both cluster mode and application preload.
 
 **Note:** Any wrapper scripts which `exec`, or other indirections in `ExecStart`
 may result in activated socket file descriptors being closed before reaching the

data/ext/puma_http11/org/jruby/puma/Http11.java

@@ -29,7 +29,7 @@ public class Http11 extends RubyObject {
     public final static int MAX_REQUEST_URI_LENGTH = getConstLength("PUMA_REQUEST_URI_MAX_LENGTH", 1024 * 12);
     public final static String MAX_REQUEST_URI_LENGTH_ERR = "HTTP element REQUEST_URI is longer than the " + MAX_REQUEST_URI_LENGTH + " allowed length.";
     public final static int MAX_FRAGMENT_LENGTH = 1024;
-    public final static String MAX_FRAGMENT_LENGTH_ERR = "HTTP element REQUEST_PATH is longer than the 1024 allowed length.";
+    public final static String MAX_FRAGMENT_LENGTH_ERR = "HTTP element FRAGMENT is longer than the 1024 allowed length.";
     public final static int MAX_REQUEST_PATH_LENGTH = getConstLength("PUMA_REQUEST_PATH_MAX_LENGTH", 8192);
     public final static String MAX_REQUEST_PATH_LENGTH_ERR = "HTTP element REQUEST_PATH is longer than the " + MAX_REQUEST_PATH_LENGTH + " allowed length.";
     public final static int MAX_QUERY_STRING_LENGTH = getConstLength("PUMA_QUERY_STRING_MAX_LENGTH", 10 * 1024);

data/lib/puma/client.rb

@@ -111,7 +111,8 @@ module Puma
     end
 
     attr_reader :env, :to_io, :body, :io, :timeout_at, :ready, :hijacked,
-                :tempfile, :io_buffer, :http_content_length_limit_exceeded
+                :tempfile, :io_buffer, :http_content_length_limit_exceeded,
+                :requests_served
 
     attr_writer :peerip, :http_content_length_limit
 
@@ -150,11 +151,12 @@ module Puma
     end
 
     # Number of seconds until the timeout elapses.
+    # @!attribute [r] timeout
     def timeout
       [@timeout_at - Process.clock_gettime(Process::CLOCK_MONOTONIC), 0].max
     end
 
-    def reset(fast_check=true)
+    def reset
       @parser.reset
       @io_buffer.reset
       @read_header = true
@@ -166,11 +168,14 @@ module Puma
       @peerip = nil if @remote_addr_header
       @in_last_chunk = false
       @http_content_length_limit_exceeded = false
+    end
 
+    # only used with back-to-back requests contained in the buffer
+    def process_back_to_back_requests
       if @buffer
         return false unless try_to_parse_proxy_protocol
 
-        @parsed_bytes = @parser.execute(@env, @buffer, @parsed_bytes)
+        @parsed_bytes = parser_execute
 
         if @parser.finished?
           return setup_body
@@ -178,19 +183,15 @@ module Puma
           raise HttpParserError,
             "HEADER is longer than allowed, aborting client early."
         end
-
-        return false
-      else
-        begin
-          if fast_check && @to_io.wait_readable(FAST_TRACK_KA_TIMEOUT)
-            return try_to_finish
-          end
-        rescue IOError
-          # swallow it
-        end
       end
     end
 
+    # if a client sends back-to-back requests, the buffer may contain one or more
+    # of them.
+    def has_back_to_back_requests?
+      !(@buffer.nil? || @buffer.empty?)
+    end
+
     def close
       tempfile_close
       begin
@@ -273,26 +274,28 @@ module Puma
 
       return false unless try_to_parse_proxy_protocol
 
-      @parsed_bytes = @parser.execute(@env, @buffer, @parsed_bytes)
+      @parsed_bytes = parser_execute
 
       if @parser.finished? && above_http_content_limit(@parser.body.bytesize)
         @http_content_length_limit_exceeded = true
       end
 
       if @parser.finished?
-        return setup_body
+        setup_body
       elsif @parsed_bytes >= MAX_HEADER
         raise HttpParserError,
           "HEADER is longer than allowed, aborting client early."
+      else
+        false
       end
-
-      false
     end
 
     def eagerly_finish
       return true if @ready
-      return false unless @to_io.wait_readable(0)
-      try_to_finish
+      while @to_io.wait_readable(0) # rubocop: disable Style/WhileUntilModifier
+        return true if try_to_finish
+      end
+      false
     end
 
     def finish(timeout)
@@ -300,6 +303,44 @@ module Puma
       @to_io.wait_readable(timeout) || timeout! until try_to_finish
     end
 
+    # Wraps `@parser.execute` and adds meaningful error messages
+    # @return [Integer] bytes of buffer read by parser
+    #
+    def parser_execute
+      @parser.execute(@env, @buffer, @parsed_bytes)
+    rescue => e
+      @env[HTTP_CONNECTION] = 'close'
+      raise e unless HttpParserError === e && e.message.include?('non-SSL')
+
+      req, _ = @buffer.split "\r\n\r\n"
+      request_line, headers = req.split "\r\n", 2
+
+      # below checks for request issues and changes error message accordingly
+      if !@env.key? REQUEST_METHOD
+        if request_line.count(' ') != 2
+           # maybe this is an SSL connection ?
+          raise e
+        else
+          method = request_line[/\A[^ ]+/]
+          raise e, "Invalid HTTP format, parsing fails. Bad method #{method}"
+        end
+      elsif !@env.key? REQUEST_PATH
+        path = request_line[/\A[^ ]+ +([^ ?\r\n]+)/, 1]
+        raise e, "Invalid HTTP format, parsing fails. Bad path #{path}"
+      elsif request_line.match?(/\A[^ ]+ +[^ ?\r\n]+\?/) && !@env.key?(QUERY_STRING)
+        query = request_line[/\A[^ ]+ +[^? ]+\?([^ ]+)/, 1]
+        raise e, "Invalid HTTP format, parsing fails. Bad query #{query}"
+      elsif !@env.key? SERVER_PROTOCOL
+        # protocol is bad
+        text = request_line[/[^ ]*\z/]
+        raise HttpParserError, "Invalid HTTP format, parsing fails. Bad protocol #{text}"
+      elsif !headers.empty?
+        # headers are bad
+        hdrs = headers.split("\r\n").map { |h| h.gsub "\n", '\n'}.join "\n"
+        raise HttpParserError, "Invalid HTTP format, parsing fails. Bad headers\n#{hdrs}"
+      end
+    end
+
     def timeout!
       write_error(408) if in_data_phase
       raise ConnectionError

data/lib/puma/cluster/worker.rb

@@ -128,14 +128,15 @@ module Puma
 
             while true
               begin
-                b = server.backlog || 0
-                r = server.running || 0
-                t = server.pool_capacity || 0
-                m = server.max_threads || 0
-                rc = server.requests_count || 0
-                bt = server.busy_threads || 0
-                payload = %Q!#{base_payload}{ "backlog":#{b}, "running":#{r}, "pool_capacity":#{t}, "max_threads":#{m}, "requests_count":#{rc}, "busy_threads":#{bt} }\n!
-                io << payload
+                payload = base_payload.dup
+
+                hsh = server.stats
+                hsh.each do |k, v|
+                  payload << %Q! "#{k}":#{v || 0},!
+                end
+                # sub call properly adds 'closing' string
+                io << payload.sub(/,\z/, " }\n")
+                server.reset_max
               rescue IOError
                 Puma::Util.purge_interrupt_queue
                 break

data/lib/puma/cluster/worker_handle.rb

@@ -4,13 +4,15 @@ module Puma
   class Cluster < Runner
     #—————————————————————— DO NOT USE — this class is for internal use only ———
 
-
     # This class represents a worker process from the perspective of the puma
     # master process. It contains information about the process and its health
     # and it exposes methods to control the process via IPC. It does not
     # include the actual logic executed by the worker process itself. For that,
     # see Puma::Cluster::Worker.
     class WorkerHandle # :nodoc:
+      # array of stat 'max' keys
+      WORKER_MAX_KEYS = [:backlog_max, :reactor_max]
+
       def initialize(idx, pid, phase, options)
         @index = idx
         @pid = pid
@@ -23,6 +25,7 @@ module Puma
         @last_checkin = Time.now
         @last_status = {}
         @term = false
+        @worker_max = Array.new WORKER_MAX_KEYS.length, 0
       end
 
       attr_reader :index, :pid, :phase, :signal, :last_checkin, :last_status, :started_at
@@ -51,12 +54,39 @@ module Puma
         @term
       end
 
-      STATUS_PATTERN = /{ "backlog":(?<backlog>\d*), "running":(?<running>\d*), "pool_capacity":(?<pool_capacity>\d*), "max_threads":(?<max_threads>\d*), "requests_count":(?<requests_count>\d*), "busy_threads":(?<busy_threads>\d*) }/
-      private_constant :STATUS_PATTERN
-
       def ping!(status)
+        hsh = {}
+        k, v = nil, nil
+        # @todo remove each once Ruby 2.5 is no longer supported
+        status.tr('}{"', '').strip.split(", ").each do |kv|
+          cntr = 0
+          kv.split(':').each do |t|
+            if cntr == 0
+              k = t
+              cntr = 1
+            else
+              v = t
+            end
+          end
+          hsh[k.to_sym] = v.to_i
+        end
+
+        # check stat max values, we can't signal workers to reset the max values,
+        # so we do so here
+        WORKER_MAX_KEYS.each_with_index do |key, idx|
+          if hsh[key] < @worker_max[idx]
+            hsh[key] = @worker_max[idx]
+          else
+            @worker_max[idx] = hsh[key]
+          end
+        end
         @last_checkin = Time.now
-        @last_status = status.match(STATUS_PATTERN).named_captures.map { |c_name, c| [c_name.to_sym, c.to_i] }.to_h
+        @last_status = hsh
+      end
+
+      # Resets max values to zero.  Called whenever `Cluster#stats` is called
+      def reset_max
+        WORKER_MAX_KEYS.length.times { |idx| @worker_max[idx] = 0 }
       end
 
       # @see Puma::Cluster#check_workers

data/lib/puma/cluster.rb

@@ -22,6 +22,7 @@ module Puma
       @workers = []
       @next_check = Time.now
 
+      @worker_max = [] # keeps track of 'max' stat values
       @phased_restart = false
     end
 
@@ -44,10 +45,15 @@ module Puma
       end
     end
 
-    def start_phased_restart
+    def start_phased_restart(refork = false)
       @events.fire_on_restart!
+
       @phase += 1
-      log "- Starting phased worker restart, phase: #{@phase}"
+      if refork
+        log "- Starting worker refork, phase: #{@phase}"
+      else
+        log "- Starting phased worker restart, phase: #{@phase}"
+      end
 
       # Be sure to change the directory again before loading
       # the app. This way we can pick up new code.
@@ -166,7 +172,7 @@ module Puma
       (@workers.map(&:pid) - idle_timed_out_worker_pids).empty?
     end
 
-    def check_workers
+    def check_workers(refork = false)
       return if @next_check >= Time.now
 
       @next_check = Time.now + @options[:worker_check_interval]
@@ -184,7 +190,12 @@ module Puma
         w = @workers.find { |x| x.phase != @phase }
 
         if w
-          log "- Stopping #{w.pid} for phased upgrade..."
+          if refork
+            log "- Stopping #{w.pid} for refork..."
+          else
+            log "- Stopping #{w.pid} for phased upgrade..."
+          end
+
           unless w.term?
             w.term
             log "- #{w.signal} sent to #{w.pid}..."
@@ -228,7 +239,7 @@ module Puma
     def phased_restart(refork = false)
       return false if @options[:preload_app] && !refork
 
-      @phased_restart = true
+      @phased_restart = refork ? :refork : true
       wakeup!
 
       true
@@ -258,11 +269,14 @@ module Puma
     end
 
     # Inside of a child process, this will return all zeroes, as @workers is only populated in
-    # the master process.
+    # the master process.  Calling this also resets stat 'max' values to zero.
     # @!attribute [r] stats
+    # @return [Hash]
+
     def stats
       old_worker_count = @workers.count { |w| w.phase != @phase }
       worker_status = @workers.map do |w|
+        w.reset_max
         {
           started_at: utc_iso8601(w.started_at),
           pid: w.pid,
@@ -273,7 +287,6 @@ module Puma
           last_status: w.last_status,
         }
       end
-
       {
         started_at: utc_iso8601(@started_at),
         workers: @workers.size,
@@ -368,7 +381,7 @@ module Puma
 
         before = Thread.list.reject(&fork_safe)
 
-        log "*     Restarts: (\u2714) hot (\u2716) phased"
+        log "*     Restarts: (\u2714) hot (\u2716) phased (#{@options[:fork_worker] ? "\u2714" : "\u2716"}) refork"
         log "* Preloading application"
         load_and_bind
 
@@ -386,7 +399,7 @@ module Puma
           end
         end
       else
-        log "*     Restarts: (\u2714) hot (\u2714) phased"
+        log "*     Restarts: (\u2714) hot (\u2714) phased (#{@options[:fork_worker] ? "\u2714" : "\u2716"}) refork"
 
         unless @config.app_configured?
           error "No application configured, nothing to run"
@@ -448,13 +461,17 @@ module Puma
             end
 
             if @phased_restart
-              start_phased_restart
+              start_phased_restart(@phased_restart == :refork)
+
+              in_phased_restart = @phased_restart
               @phased_restart = false
-              in_phased_restart = true
+
               workers_not_booted = @options[:workers]
+              # worker 0 is not restarted on refork
+              workers_not_booted -= 1 if in_phased_restart == :refork
             end
 
-            check_workers
+            check_workers(in_phased_restart == :refork)
 
             if read.wait_readable([0, @next_check - Time.now].max)
               req = read.read_nonblock(1)

data/lib/puma/configuration.rb

@@ -140,12 +140,10 @@ module Puma
       io_selector_backend: :auto,
       log_requests: false,
       logger: STDOUT,
-      # How many requests to attempt inline before sending a client back to
-      # the reactor to be subject to normal ordering. The idea here is that
-      # we amortize the cost of going back to the reactor for a well behaved
-      # but very "greedy" client across 10 requests. This prevents a not
-      # well behaved client from monopolizing the thread forever.
-      max_fast_inline: 10,
+      # Limits how many requests a keep alive connection can make.
+      # The connection will be closed after it reaches `max_keep_alive`
+      # requests.
+      max_keep_alive: 25,
       max_threads: Puma.mri? ? 5 : 16,
       min_threads: 0,
       mode: :http,

data/lib/puma/const.rb

@@ -100,13 +100,11 @@ module Puma
   # too taxing on performance.
   module Const
 
-    PUMA_VERSION = VERSION = "6.6.0"
-    CODE_NAME = "Return to Forever"
+    PUMA_VERSION = VERSION = "7.0.0.pre1"
+    CODE_NAME = "Romantic Warrior"
 
     PUMA_SERVER_STRING = ["puma", PUMA_VERSION, CODE_NAME].join(" ").freeze
 
-    FAST_TRACK_KA_TIMEOUT = 0.2
-
     # How long to wait when getting some write blocking on the socket when
     # sending data back
     WRITE_TIMEOUT = 10

data/lib/puma/dsl.rb

@@ -654,8 +654,6 @@ module Puma
     # @example
     #   state_permission 0600
     #
-    # @version 5.0.0
-    #
     def state_permission(permission)
       @options[:state_permission] = permission
     end
@@ -811,7 +809,7 @@ module Puma
 
     alias_method :after_worker_boot, :after_worker_fork
 
-    # Code to run after puma is booted (works for both: single and clustered)
+    # Code to run after puma is booted (works for both single and cluster modes).
     #
     # @example
     #   on_booted do
@@ -822,7 +820,7 @@ module Puma
       @config.options[:events].on_booted(&block)
     end
 
-    # Code to run after puma is stopped (works for both: single and clustered)
+    # Code to run after puma is stopped (works for both single and cluster modes).
     #
     # @example
     #   on_stopped do
@@ -851,8 +849,6 @@ module Puma
     #     3.times {GC.start}
     #   end
     #
-    # @version 5.0.0
-    #
     def on_refork(key = nil, &block)
       warn_if_in_single_mode('on_refork')
 
@@ -1111,7 +1107,7 @@ module Puma
 
     # Set the timeout for worker shutdown.
     #
-    # The default is 60 seconds.
+    # The default is 30 seconds.
     #
     # @note Cluster mode only.
     #
@@ -1143,10 +1139,10 @@ module Puma
     # @see Puma::Cluster#cull_workers
     #
     def worker_culling_strategy(strategy)
-      stategy = strategy.to_sym
+      strategy = strategy.to_sym
 
       if ![:youngest, :oldest].include?(strategy)
-        raise "Invalid value for worker_culling_strategy - #{stategy}"
+        raise "Invalid value for worker_culling_strategy - #{strategy}"
       end
 
       @options[:worker_culling_strategy] = strategy
@@ -1194,8 +1190,6 @@ module Puma
     # @see Puma::Server#handle_servers
     # @see Puma::ThreadPool#wait_for_less_busy_worker
     #
-    # @version 5.0.0
-    #
     def wait_for_less_busy_worker(val=0.005)
       @options[:wait_for_less_busy_worker] = val.to_f
     end
@@ -1269,24 +1263,31 @@ module Puma
     # A refork will automatically trigger once after the specified number of requests
     # (default 1000), or pass 0 to disable auto refork.
     #
+    # @note This is experimental.
     # @note Cluster mode only.
     #
-    # @version 5.0.0
-    #
     def fork_worker(after_requests=1000)
       @options[:fork_worker] = Integer(after_requests)
     end
 
-    # The number of requests to attempt inline before sending a client back to
-    # the reactor to be subject to normal ordering.
+    # @deprecated Use {#max_keep_alive} instead.
     #
-    # The default is 10.
+    def max_fast_inline(num_of_requests)
+      warn "[WARNING] `max_fast_inline` is deprecated use `max_keep_alive` instead"
+      @options[:max_keep_alive] ||= Float(num_of_requests) unless num_of_requests.nil?
+    end
+
+    # The number of requests a keep-alive client can submit before being closed.
+    # Note that some applications (server to server) may benefit from a very high
+    # number or Float::INFINITY.
+    #
+    # The default is 25.
     #
     # @example
-    #   max_fast_inline 20
+    #   max_keep_alive 20
     #
-    def max_fast_inline(num_of_requests)
-      @options[:max_fast_inline] = Float(num_of_requests)
+    def max_keep_alive(num_of_requests)
+      @options[:max_keep_alive] = Float(num_of_requests) unless num_of_requests.nil?
     end
 
     # When `true`, keep-alive connections are maintained on inbound requests.

data/lib/puma/reactor.rb

@@ -15,6 +15,12 @@ module Puma
   #
   # The implementation uses a Queue to synchronize adding new objects from the internal select loop.
   class Reactor
+
+    # @!attribute [rw] reactor_max
+    #   Maximum number of clients in the selector.  Reset with calls to `Server.stats`.
+    attr_accessor :reactor_max
+    attr_reader :reactor_size
+
     # Create a new Reactor to monitor IO objects added by #add.
     # The provided block will be invoked when an IO has data available to read,
     # its timeout elapses, or when the Reactor shuts down.
@@ -29,6 +35,8 @@ module Puma
       @input = Queue.new
       @timeouts = []
       @block = block
+      @reactor_size = 0
+      @reactor_max = 0
     end
 
     # Run the internal select loop, using a background thread by default.
@@ -108,6 +116,8 @@ module Puma
     # Start monitoring the object.
     def register(client)
       @selector.register(client.to_io, :r).value = client
+      @reactor_size += 1
+      @reactor_max = @reactor_size if @reactor_max < @reactor_size
       @timeouts << client
     rescue ArgumentError
       # unreadable clients raise error when processed by NIO
@@ -118,6 +128,7 @@ module Puma
     def wakeup!(client)
       if @block.call client
         @selector.deregister client.to_io
+        @reactor_size -= 1
         @timeouts.delete client
       end
     end

data/lib/puma/request.rb

@@ -135,12 +135,15 @@ module Puma
       uncork_socket client.io
       app_body.close if app_body.respond_to? :close
       client&.tempfile_close
-      after_reply = env[RACK_AFTER_REPLY] || []
-      begin
-        after_reply.each { |o| o.call }
-      rescue StandardError => e
-        @log_writer.debug_error e
-      end unless after_reply.empty?
+      if after_reply = env[RACK_AFTER_REPLY]
+        after_reply.each do |o|
+          begin
+            o.call
+          rescue StandardError => e
+            @log_writer.debug_error e
+          end
+        end
+      end
     end
 
     # Assembles the headers and prepares the body for actually sending the
@@ -161,17 +164,7 @@ module Puma
       return false if closed_socket?(socket)
 
       # Close the connection after a reasonable number of inline requests
-      # if the server is at capacity and the listener has a new connection ready.
-      # This allows Puma to service connections fairly when the number
-      # of concurrent connections exceeds the size of the threadpool.
-      force_keep_alive = if @enable_keep_alives
-        requests < @max_fast_inline ||
-        @thread_pool.busy_threads < @max_threads ||
-        !client.listener.to_io.wait_readable(0)
-      else
-        # Always set force_keep_alive to false if the server has keep-alives not enabled.
-        false
-      end
+      force_keep_alive = @enable_keep_alives && client.requests_served < @max_keep_alive
 
       resp_info = str_headers(env, status, headers, res_body, io_buffer, force_keep_alive)
 
@@ -191,7 +184,8 @@ module Puma
           elsif res_body.is_a?(File) && res_body.respond_to?(:size)
             body = res_body
             content_length = body.size
-          elsif res_body.respond_to?(:to_path) && File.readable?(fn = res_body.to_path)
+          elsif res_body.respond_to?(:to_path) && (fn = res_body.to_path) &&
+              File.readable?(fn)
             body = File.open fn, 'rb'
             content_length = body.size
             close_body = true
@@ -199,7 +193,7 @@ module Puma
             body = res_body
           end
         elsif !res_body.is_a?(::File) && res_body.respond_to?(:to_path) &&
-            File.readable?(fn = res_body.to_path)
+            (fn = res_body.to_path) && File.readable?(fn = res_body.to_path)
           body = File.open fn, 'rb'
           content_length = body.size
           close_body = true
@@ -263,7 +257,8 @@ module Puma
 
       fast_write_response socket, body, io_buffer, chunked, content_length.to_i
       body.close if close_body
-      keep_alive
+      # if we're shutting down, close keep_alive connections
+      !shutting_down? && keep_alive
     end
 
     # @param env [Hash] see Puma::Client#env, from request
@@ -581,7 +576,7 @@ module Puma
     #   response body
     # @param io_buffer [Puma::IOBuffer] modified inn place
     # @param force_keep_alive [Boolean] 'anded' with keep_alive, based on system
-    #   status and `@max_fast_inline`
+    #   status and `@max_keep_alive`
     # @return [Hash] resp_info
     # @version 5.0.3
     #

data/lib/puma/server.rb

@@ -94,8 +94,9 @@ module Puma
       @min_threads               = @options[:min_threads]
       @max_threads               = @options[:max_threads]
       @queue_requests            = @options[:queue_requests]
-      @max_fast_inline           = @options[:max_fast_inline]
+      @max_keep_alive            = @options[:max_keep_alive]
       @enable_keep_alives        = @options[:enable_keep_alives]
+      @enable_keep_alives      &&= @queue_requests
       @io_selector_backend       = @options[:io_selector_backend]
       @http_content_length_limit = @options[:http_content_length_limit]
 
@@ -220,7 +221,6 @@ module Puma
       @thread_pool&.spawned
     end
 
-
     # This number represents the number of requests that
     # the server is capable of taking right now.
     #
@@ -324,6 +324,7 @@ module Puma
         pool = @thread_pool
         queue_requests = @queue_requests
         drain = options[:drain_on_shutdown] ? 0 : nil
+        max_flt = @max_threads.to_f
 
         addr_send_name, addr_value = case options[:remote_address]
         when :value
@@ -364,8 +365,20 @@ module Puma
               if sock == check
                 break if handle_check
               else
-                pool.wait_until_not_full
-                pool.wait_for_less_busy_worker(options[:wait_for_less_busy_worker]) if @clustered
+                # if ThreadPool out_of_band code is running, we don't want to add
+                # clients until the code is finished.
+                sleep 0.001 while pool.out_of_band_running
+
+                # only use delay when clustered and busy
+                if pool.busy_threads >= @max_threads
+                  if @clustered
+                    delay = 0.0001 * ((@reactor&.reactor_size || 0) + pool.busy_threads * 1.5)/max_flt
+                    sleep delay
+                  else
+                    # use small sleep for busy single worker
+                    sleep 0.0001
+                  end
+                end
 
                 io = begin
                   sock.accept_nonblock
@@ -453,8 +466,7 @@ module Puma
       requests = 0
 
       begin
-        if @queue_requests &&
-          !client.eagerly_finish
+        if @queue_requests && !client.eagerly_finish
 
           client.set_timeout(@first_data_timeout)
           if @reactor.add client
@@ -467,39 +479,33 @@ module Puma
           client.finish(@first_data_timeout)
         end
 
-        while true
-          @requests_count += 1
-          case handle_request(client, requests + 1)
-          when false
-            break
-          when :async
-            close_socket = false
-            break
-          when true
-            ThreadPool.clean_thread_locals if clean_thread_locals
-
-            requests += 1
+        @requests_count += 1
+        case handle_request(client, requests + 1)
+        when false
+        when :async
+          close_socket = false
+        when true
+          ThreadPool.clean_thread_locals if clean_thread_locals
 
-            # As an optimization, try to read the next request from the
-            # socket for a short time before returning to the reactor.
-            fast_check = @status == :run
+          requests += 1
 
-            # Always pass the client back to the reactor after a reasonable
-            # number of inline requests if there are other requests pending.
-            fast_check = false if requests >= @max_fast_inline &&
-              @thread_pool.backlog > 0
+          client.reset
 
-            next_request_ready = with_force_shutdown(client) do
-              client.reset(fast_check)
-            end
+          # This indicates data exists in the client read buffer and there may be
+          # additional requests on it, so process them
+          next_request_ready = if client.has_back_to_back_requests?
+            with_force_shutdown(client) { client.process_back_to_back_requests }
+          else
+            nil
+          end
 
-            unless next_request_ready
-              break unless @queue_requests
-              client.set_timeout @persistent_timeout
-              if @reactor.add client
-                close_socket = false
-                break
-              end
+          if next_request_ready
+            @thread_pool << client
+            close_socket = false
+          elsif @queue_requests
+            client.set_timeout @persistent_timeout
+            if @reactor.add client
+              close_socket = false
             end
           end
         end
@@ -650,7 +656,16 @@ module Puma
 
     # List of methods invoked by #stats.
     # @version 5.0.0
-    STAT_METHODS = [:backlog, :running, :pool_capacity, :max_threads, :requests_count, :busy_threads].freeze
+    STAT_METHODS = [
+      :backlog,
+      :running,
+      :pool_capacity,
+      :busy_threads,
+      :backlog_max,
+      :max_threads,
+      :requests_count,
+      :reactor_max,
+    ].freeze
 
     # Returns a hash of stats about the running server for reporting purposes.
     # @version 5.0.0
@@ -660,9 +675,16 @@ module Puma
       stats = @thread_pool&.stats || {}
       stats[:max_threads]    = @max_threads
       stats[:requests_count] = @requests_count
+      stats[:reactor_max] = @reactor.reactor_max
+      reset_max
       stats
     end
 
+    def reset_max
+      @reactor.reactor_max = 0
+      @thread_pool.reset_max
+    end
+
     # below are 'delegations' to binder
     # remove in Puma 7?
 

data/lib/puma/single.rb

@@ -17,7 +17,7 @@ module Puma
     def stats
       {
         started_at: utc_iso8601(@started_at)
-      }.merge(@server.stats).merge(super)
+      }.merge(@server&.stats || {}).merge(super)
     end
 
     def restart

data/lib/puma/thread_pool.rb

@@ -25,6 +25,8 @@ module Puma
     # up its work before leaving the thread to die on the vine.
     SHUTDOWN_GRACE_TIME = 5 # seconds
 
+    attr_reader :out_of_band_running
+
     # Maintain a minimum of +min+ and maximum of +max+ threads
     # in the pool.
     #
@@ -35,9 +37,9 @@ module Puma
       @not_empty = ConditionVariable.new
       @not_full = ConditionVariable.new
       @mutex = Mutex.new
+      @todo = Queue.new
 
-      @todo = []
-
+      @backlog_max = 0
       @spawned = 0
       @waiting = 0
 
@@ -50,6 +52,7 @@ module Puma
       @shutdown_grace_time = Float(options[:pool_shutdown_grace_time] || SHUTDOWN_GRACE_TIME)
       @block = block
       @out_of_band = options[:out_of_band]
+      @out_of_band_running = false
       @clean_thread_locals = options[:clean_thread_locals]
       @before_thread_start = options[:before_thread_start]
       @before_thread_exit = options[:before_thread_exit]
@@ -89,20 +92,33 @@ module Puma
     # @return [Hash] hash containing stat info from ThreadPool
     def stats
       with_mutex do
+        temp = @backlog_max
+        @backlog_max = 0
         { backlog: @todo.size,
           running: @spawned,
           pool_capacity: @waiting + (@max - @spawned),
-          busy_threads: @spawned - @waiting + @todo.size
+          busy_threads: @spawned - @waiting + @todo.size,
+          backlog_max: temp
         }
       end
     end
 
+    def reset_max
+      with_mutex { @backlog_max = 0 }
+    end
+
     # How many objects have yet to be processed by the pool?
     #
     def backlog
       with_mutex { @todo.size }
     end
 
+    # The maximum size of the backlog
+    #
+    def backlog_max
+      with_mutex { @backlog_max }
+    end
+
     # @!attribute [r] pool_capacity
     def pool_capacity
       waiting + (@max - spawned)
@@ -214,12 +230,14 @@ module Puma
 
       # we execute on idle hook when all threads are free
       return false unless @spawned == @waiting
-
+      @out_of_band_running = true
       @out_of_band.each(&:call)
       true
     rescue Exception => e
       STDERR.puts "Exception calling out_of_band_hook: #{e.message} (#{e.class})"
       true
+    ensure
+      @out_of_band_running = false
     end
 
     private :trigger_out_of_band_hook
@@ -239,6 +257,8 @@ module Puma
         end
 
         @todo << work
+        t = @todo.size
+        @backlog_max = t if t > @backlog_max
 
         if @waiting < @todo.size and @spawned < @max
           spawn_thread
@@ -248,69 +268,6 @@ module Puma
       end
     end
 
-    # This method is used by `Puma::Server` to let the server know when
-    # the thread pool can pull more requests from the socket and
-    # pass to the reactor.
-    #
-    # The general idea is that the thread pool can only work on a fixed
-    # number of requests at the same time. If it is already processing that
-    # number of requests then it is at capacity. If another Puma process has
-    # spare capacity, then the request can be left on the socket so the other
-    # worker can pick it up and process it.
-    #
-    # For example: if there are 5 threads, but only 4 working on
-    # requests, this method will not wait and the `Puma::Server`
-    # can pull a request right away.
-    #
-    # If there are 5 threads and all 5 of them are busy, then it will
-    # pause here, and wait until the `not_full` condition variable is
-    # signaled, usually this indicates that a request has been processed.
-    #
-    # It's important to note that even though the server might accept another
-    # request, it might not be added to the `@todo` array right away.
-    # For example if a slow client has only sent a header, but not a body
-    # then the `@todo` array would stay the same size as the reactor works
-    # to try to buffer the request. In that scenario the next call to this
-    # method would not block and another request would be added into the reactor
-    # by the server. This would continue until a fully buffered request
-    # makes it through the reactor and can then be processed by the thread pool.
-    def wait_until_not_full
-      with_mutex do
-        while true
-          return if @shutdown
-
-          # If we can still spin up new threads and there
-          # is work queued that cannot be handled by waiting
-          # threads, then accept more work until we would
-          # spin up the max number of threads.
-          return if busy_threads < @max
-
-          @not_full.wait @mutex
-        end
-      end
-    end
-
-    # @version 5.0.0
-    def wait_for_less_busy_worker(delay_s)
-      return unless delay_s && delay_s > 0
-
-      # Ruby MRI does GVL, this can result
-      # in processing contention when multiple threads
-      # (requests) are running concurrently
-      return unless Puma.mri?
-
-      with_mutex do
-        return if @shutdown
-
-        # do not delay, if we are not busy
-        return unless busy_threads > 0
-
-        # this will be signaled once a request finishes,
-        # which can happen earlier than delay
-        @not_full.wait @mutex, delay_s
-      end
-    end
-
     # If there are any free threads in the pool, tell one to go ahead
     # and exit. If +force+ is true, then a trim request is requested
     # even if all threads are being utilized.

data/tools/Dockerfile

@@ -2,6 +2,8 @@
 
 FROM ruby:3.2
 
+RUN apt-get update && apt-get install -y ragel
+
 # throw errors if Gemfile has been modified since Gemfile.lock
 RUN bundle config --global frozen 1
 
@@ -13,4 +15,4 @@ RUN bundle install
 RUN bundle exec rake compile
 
 EXPOSE 9292
-CMD bundle exec bin/puma test/rackup/hello.ru
+CMD ["bundle", "exec", "bin/puma", "test/rackup/hello.ru"]

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: puma
 version: !ruby/object:Gem::Version
-  version: 6.6.0
+  version: 7.0.0.pre1
 platform: ruby
 authors:
 - Evan Phoenix
 bindir: bin
 cert_chain: []
-date: 2025-01-28 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nio4r
@@ -145,7 +145,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.3
+rubygems_version: 3.6.9
 specification_version: 4
 summary: A Ruby/Rack web server built for parallelism.
 test_files: []