puma 7.0.4-java → 7.1.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 504463ef9ae6d0f72e563929b1fffc93a8dae6a81ba26a8d2ad2d11ca6cf74ac
-  data.tar.gz: ffc359bcb19e5ec013fea326e49f877ed02460e0501cc4cb3e397741b0858b69
+  metadata.gz: c34ad6eb102937d5162b4ee769397333da4ad801d17fab6cc70226319ad94db2
+  data.tar.gz: 4c4fd1e10d19a1a156a8cd524bcf547e7b0c59cbac7868a21c3cd469ca60c96d
 SHA512:
-  metadata.gz: 2b32465bffbdd70561c6220e8f01539f4eeb821fa081c10623698ffa770ac5bd4fbc727da3a038c522c0a3d152bba9e6d4a3dea30d45d3d3b0244fdde3dd8fb5
-  data.tar.gz: 7c955cc7fe61bda55ba381d7af9d2b2ee7166f30d534f26ee9b955985c36672857eb39e2e487a2a481007f7b75e65a87a208fc9ea8746bdd4c687547d45a9405
+  metadata.gz: 5f1f1026adb88d8bae2fb4008a94731b190af258c68270ab4f1c7578457f260612982d102c19b302b2f724b5e8bed7e774a6a3b8effd79d1ed23afa5349928cb
+  data.tar.gz: f01f2c0187729869c45940da06a5a496eaf404889baa0ee4cacbfb704a286b5d2f0852ffb0cf7671a2db8a5263850b83d4d381dc689f05ded5190c27b234afa8

data/History.md

@@ -1,3 +1,17 @@
+## 7.1.0 / 2025-10-16
+
+* Features
+  * Introduce `after_worker_shutdown` hook ([#3707])
+  * Reintroduce keepalive "fast inline" behavior. Provides faster (8x on JRuby & 1.4x on Ruby) pipeline processing  ([#3794])
+
+* Bugfixes
+  * Skip reading zero bytes when request body is buffered ([#3795])
+  * Fix `PUMA_LOG_CONFIG=1` logging twice with prune_bundler enabled ([#3778])
+  * Fix prune_bundler not showing in `PUMA_LOG_CONFIG=1` output ([#3779])
+  * Guard ThreadPool method call, which may be nil during shutdown ([#3791], [#3790])
+  * Set `Thread.current.puma_server` in Thread init code, not every request ([#3774])
+  * Fix race condition while deleting pidfile ([#3657])
+
 ## 7.0.4 / 2025-09-23
 
 * Bugfixes
@@ -2245,6 +2259,15 @@ 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)
 
+[#3707]:https://github.com/puma/puma/pull/3707     "PR by @nerdrew, merged 2025-10-02"
+[#3794]:https://github.com/puma/puma/pull/3794     "PR by @schneems, merged 2025-10-16"
+[#3795]:https://github.com/puma/puma/pull/3795     "PR by @MSP-Greg, merged 2025-10-16"
+[#3778]:https://github.com/puma/puma/pull/3778     "PR by @joshuay03, merged 2025-10-16"
+[#3779]:https://github.com/puma/puma/pull/3779     "PR by @joshuay03, merged 2025-10-16"
+[#3791]:https://github.com/puma/puma/pull/3791     "PR by @MSP-Greg, merged 2025-10-09"
+[#3790]:https://github.com/puma/puma/issues/3790   "Issue by @eric-wtfoxtrot, closed 2025-10-09"
+[#3774]:https://github.com/puma/puma/pull/3774     "PR by @MSP-Greg, merged 2025-10-16"
+[#3657]:https://github.com/puma/puma/pull/3657     "PR by @marksmith, merged 2025-10-16"
 [#3703]:https://github.com/puma/puma/pull/3703     "PR by @marshall-lee, merged 2025-09-20"
 [#3742]:https://github.com/puma/puma/pull/3742     "PR by @kenballus, merged 2025-09-18"
 [#3754]:https://github.com/puma/puma/pull/3754     "PR by @byroot, merged 2025-09-18"

data/README.md

@@ -142,8 +142,8 @@ Preloading can’t be used with phased restart, since phased restart kills and r
 
 #### Cluster mode hooks
 
-When using clustered mode, Puma's configuration DSL provides `before_fork` and `before_worker_boot`
-hooks to run code when the master process forks and child workers are booted respectively.
+When using clustered mode, Puma's configuration DSL provides `before_fork`, `before_worker_boot`, and `after_worker_shutdown`
+hooks to run code when the master process forks, the child workers are booted, and after each child worker exits respectively.
 
 It is recommended to use these hooks with `preload_app!`, otherwise constants loaded by your
 application (such as `Rails`) will not be available inside the hooks.
@@ -157,6 +157,11 @@ end
 before_worker_boot do
   # Add code to run inside the Puma worker process after forking.
 end
+
+after_worker_shutdown do |worker_handle|
+  # Add code to run inside the Puma master process after a worker exits. `worker.process_status` can be used to get the
+  # `Process::Status` of the exited worker.
+end
 ```
 
 In addition, there is an `before_refork` and `after_refork` hooks which are used only in [`fork_worker` mode](docs/fork_worker.md),

data/docs/kubernetes.md

@@ -10,7 +10,7 @@ Assuming you already have a running cluster and docker image repository, you can
 
 A basic Dockerfile example:
 
-```
+```Dockerfile
 FROM ruby:3.4.5-alpine # can be updated to newer ruby versions
 RUN apk update && apk add build-base # and any other packages you need
 
@@ -28,7 +28,7 @@ CMD bundle exec rackup -o 0.0.0.0
 
 A sample `deployment.yaml`:
 
-```
+```yaml
 ---
 apiVersion: apps/v1
 kind: Deployment

data/docs/stats.md

@@ -62,7 +62,7 @@ When Puma runs in single mode, these stats are available at the top level. When
   this is a "wholistic" stat reflecting the overall current state of work to be done and the capacity to do it.
 * pool_capacity: `how many threads are waiting to receive work` + `max_threads` - `running`. In a typical configuration where `min_threads`
   and `max_threads` are configured to the same number, this is simply `how many threads are waiting to receive work`. This number exists only as a stat
-  and is not used for any internal decisions, unlike `busy_theads`, which is usually a more useful stat.
+  and is not used for any internal decisions, unlike `busy_threads`, 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.

data/lib/puma/client.rb

@@ -500,40 +500,36 @@ module Puma
       # after this
       remain = @body_remain
 
-      if remain > CHUNK_SIZE
-        want = CHUNK_SIZE
-      else
-        want = remain
-      end
+      # don't bother with reading zero bytes
+      unless remain.zero?
+        begin
+          chunk = @io.read_nonblock(remain.clamp(0, CHUNK_SIZE), @read_buffer)
+        rescue IO::WaitReadable
+          return false
+        rescue SystemCallError, IOError
+          raise ConnectionError, "Connection error detected during read"
+        end
 
-      begin
-        chunk = @io.read_nonblock(want, @read_buffer)
-      rescue IO::WaitReadable
-        return false
-      rescue SystemCallError, IOError
-        raise ConnectionError, "Connection error detected during read"
-      end
+        # No chunk means a closed socket
+        unless chunk
+          @body.close
+          @buffer = nil
+          set_ready
+          raise EOFError
+        end
 
-      # No chunk means a closed socket
-      unless chunk
-        @body.close
-        @buffer = nil
-        set_ready
-        raise EOFError
+        remain -= @body.write(chunk)
       end
 
-      remain -= @body.write(chunk)
-
       if remain <= 0
         @body.rewind
         @buffer = nil
         set_ready
-        return true
+        true
+      else
+        @body_remain = remain
+        false
       end
-
-      @body_remain = remain
-
-      false
     end
 
     def read_chunked_body

data/lib/puma/cluster/worker_handle.rb

@@ -28,10 +28,10 @@ module Puma
         @worker_max = Array.new WORKER_MAX_KEYS.length, 0
       end
 
-      attr_reader :index, :pid, :phase, :signal, :last_checkin, :last_status, :started_at
+      attr_reader :index, :pid, :phase, :signal, :last_checkin, :last_status, :started_at, :process_status
 
       # @version 5.0.0
-      attr_writer :pid, :phase
+      attr_writer :pid, :phase, :process_status
 
       def booted?
         @stage == :booted

data/lib/puma/cluster.rb

@@ -23,7 +23,7 @@ module Puma
       @next_check = Time.now
 
       @worker_max = [] # keeps track of 'max' stat values
-      @phased_restart = false
+      @pending_phased_restart = false
     end
 
     # Returns the list of cluster worker handles.
@@ -238,7 +238,7 @@ module Puma
     def phased_restart(refork = false)
       return false if @options[:preload_app] && !refork
 
-      @phased_restart = refork ? :refork : true
+      @pending_phased_restart = refork ? :refork : true
       wakeup!
 
       true
@@ -456,11 +456,11 @@ module Puma
               break
             end
 
-            if @phased_restart
-              start_phased_restart(@phased_restart == :refork)
+            if @pending_phased_restart
+              start_phased_restart(@pending_phased_restart == :refork)
 
-              in_phased_restart = @phased_restart
-              @phased_restart = false
+              in_phased_restart = @pending_phased_restart
+              @pending_phased_restart = false
 
               workers_not_booted = @options[:workers]
               # worker 0 is not restarted on refork
@@ -583,7 +583,9 @@ module Puma
           #    `Process.wait2(-1)` from detecting a terminated process: https://bugs.ruby-lang.org/issues/19837.
           # 2. When `fork_worker` is enabled, some worker may not be direct children,
           #    but grand children.  Because of this they won't be reaped by `Process.wait2(-1)`.
-          if reaped_children.delete(w.pid) || Process.wait(w.pid, Process::WNOHANG)
+          if (status = reaped_children.delete(w.pid) || Process.wait2(w.pid, Process::WNOHANG)&.last)
+            w.process_status = status
+            @config.run_hooks(:after_worker_shutdown, w, @log_writer)
             true
           else
             w.term if w.term?

data/lib/puma/cluster_accept_loop_delay.rb

@@ -20,48 +20,47 @@ module Puma
   # already https://github.com/puma/puma/pull/3678/files/2736ebddb3fc8528e5150b5913fba251c37a8bf7#diff-a95f46e7ce116caddc9b9a9aa81004246d5210d5da5f4df90a818c780630166bL251-L291
   #
   # With the introduction of true keepalive support, there are two ways a request can come in:
-  # - A new request from a new client comes into the socket and it must be "accept"-d
+  # - A new request from a new client comes into the socket and it must be "accept"-ed
   # - A keepalive request is served and the connection is retained. Another request is then accepted
   #
   # Ideally the server handles requests in the order they come in, and ideally it doesn't accept more requests than it can handle.
   # These goals are contradictory, because when the server is at maximum capacity due to keepalive connections, it could mean we
   # block all new requests, even if those came in before the new request on the older keepalive connection.
   #
-  # ## Distribute CPU resources across all workers
+  # ## Goal: Distribute CPU resources across all workers
   #
   # - This issue was opened https://github.com/puma/puma/issues/2078
   #
-  # There are several entangled issues and it's not exactly clear the root cause, but the observable outcome
+  # There are several entangled issues and it's not exactly clear what the root cause is, but the observable outcome
   # was that performance was better with a small sleep, and that eventually became the default.
   #
   # An attempt to describe why this works is here: https://github.com/puma/puma/issues/2078#issuecomment-3287032470.
   #
   # Summarizing: The delay is for tuning the rate at which "accept" is called on the socket.
-  # Puma works by calling "accept" nonblock on the socket in a loop. When there are multiple workers,
-  # (processes) then they will "race" to accept a request at roughly the same rate. However if one
+  # Puma works by calling "accept" nonblock on the socket in a loop. When there are multiple workers
+  # (processes), they will "race" to accept a request at roughly the same rate. However, if one
   # worker has all threads busy processing requests, then accepting a new request might "steal" it from
   # a less busy worker. If a worker has no work to do, it should loop as fast as possible.
   #
-  # ## Solution(s): Distribute requests across workers at start
+  # ## Solution: Distribute requests across workers at start
   #
   # For now, both goals are framed as "load balancing" across workers (processes) and achieved through
   # the same mechanism of sleeping longer to delay busier workers. Rather than the prior Puma 6.x
-  # and earlier behavior of using a binary on/off sleep value, we increase it an amound proportional
-  # to the load the server is under. Capping the maximum delay to the scenario where all threads are busy
+  # and earlier behavior of using a binary on/off sleep value, we increase it an amount proportional
+  # to the load the server is under, capping the maximum delay to the scenario where all threads are busy
   # and the todo list has reached a multiplier of the maximum number of threads.
   #
   # Private: API may change unexpectedly
   class ClusterAcceptLoopDelay
-    attr_reader :max_threads, :max_delay
+    attr_reader :max_delay
 
-    # Initialize happens once, `call` happens often. Push global calculations here
+    # Initialize happens once, `call` happens often. Perform global calculations here.
     def initialize(
-        # Number of workers in the cluster
-        workers: ,
-        # Maximum delay in seconds i.e. 0.005 is 5 microseconds
-        max_delay: # In seconds i.e. 0.005 is 5 microseconds
-
-      )
+      # Number of workers in the cluster
+      workers: ,
+      # Maximum delay in seconds i.e. 0.005 is 5 milliseconds
+      max_delay:
+    )
       @on = max_delay > 0 && workers >= 2
       @max_delay = max_delay.to_f
 
@@ -76,12 +75,12 @@ module Puma
     # We want the extreme values of this delay to be known (minimum and maximum) as well as
     # a predictable curve between the two. i.e. no step functions or hard cliffs.
     #
-    # Return value is always numeric. Returns 0 if there should be no delay
+    # Return value is always numeric. Returns 0 if there should be no delay.
     def calculate(
       # Number of threads working right now, plus number of requests in the todo list
       busy_threads_plus_todo:,
       # Maximum number of threads in the pool, note that the busy threads (alone) may go over this value at times
-      # if the pool needs to be reaped. The busy thread plus todo count may go over this value by a large amount
+      # if the pool needs to be reaped. The busy thread plus todo count may go over this value by a large amount.
       max_threads:
     )
       max_value = @overload_multiplier * max_threads

data/lib/puma/configuration.rb

@@ -155,6 +155,7 @@ module Puma
       out_of_band: [],
       # Number of seconds for another request within a persistent session.
       persistent_timeout: 65, # PUMA_PERSISTENT_TIMEOUT
+      prune_bundler: false,
       queue_requests: true,
       rackup: 'config.ru'.freeze,
       raise_exception_on_sigterm: true,

data/lib/puma/const.rb

@@ -100,8 +100,8 @@ module Puma
   # too taxing on performance.
   module Const
 
-    PUMA_VERSION = VERSION = "7.0.4"
-    CODE_NAME = "Romantic Warrior"
+    PUMA_VERSION = VERSION = "7.1.0"
+    CODE_NAME = "Neon Witch"
 
     PUMA_SERVER_STRING = ["puma", PUMA_VERSION, CODE_NAME].join(" ").freeze
 

data/lib/puma/dsl.rb

@@ -656,7 +656,8 @@ module Puma
       @options[:state] = path.to_s
     end
 
-    # Use +permission+ to restrict permissions for the state file.
+    # Use +permission+ to restrict permissions for the state file.  By convention,
+    # +permission+ is an octal number (e.g. `0640` or `0o640`).
     #
     # @example
     #   state_permission 0600
@@ -818,6 +819,20 @@ module Puma
 
     alias_method :after_worker_boot, :after_worker_fork
 
+    # Code to run in the master right after a worker has stopped. The worker's
+    # index and Process::Status are passed as arguments.
+    #
+    # @note Cluster mode only.
+    #
+    # @example
+    #   after_worker_shutdown do |worker_handle|
+    #     puts 'Worker crashed' unless worker_handle.process_status.success?
+    #   end
+    #
+    def after_worker_shutdown(&block)
+      process_hook :after_worker_shutdown, nil, block, cluster_only: true
+    end
+
     # Code to run after puma is booted (works for both single and cluster modes).
     #
     # @example
@@ -1207,13 +1222,19 @@ module Puma
     end
 
 
-    # Attempts to route traffic to less-busy workers by causing them to delay
-    # listening on the socket, allowing workers which are not processing any
+    # Maximum delay of worker accept loop.
+    #
+    # Attempts to route traffic to less-busy workers by causing a busy worker to delay
+    # listening on the socket, allowing workers which are not processing as many
     # requests to pick up new requests first.
     #
     # The default is 0.005 seconds.
     #
-    # Only works on MRI. For all other interpreters, this setting does nothing.
+    # To turn off this feature, set the value to 0.
+    #
+    # @note Cluster mode with >= 2 workers only.
+    #
+    # @note Interpreters with forking support only.
     #
     # @see Puma::Server#handle_servers
     # @see Puma::ThreadPool#wait_for_less_busy_worker

data/lib/puma/launcher.rb

@@ -42,26 +42,39 @@ module Puma
     #   end
     #   Puma::Launcher.new(conf, log_writer: Puma::LogWriter.stdio).run
     def initialize(conf, launcher_args={})
-      @runner        = nil
-      @log_writer    = launcher_args[:log_writer] || LogWriter::DEFAULT
-      @events        = launcher_args[:events] || Events.new
-      @argv          = launcher_args[:argv] || []
-      @original_argv = @argv.dup
-      @config        = conf
-
-      env = launcher_args.delete(:env) || ENV
+      ## Minimal initialization for a potential early restart (e.g. when pruning bundle)
 
+      @config = conf
       @config.clamp
+
       @options = @config.options
 
+      @log_writer = launcher_args[:log_writer] || LogWriter::DEFAULT
+      @log_writer.formatter = LogWriter::PidFormatter.new if clustered?
+      @log_writer.formatter = @options[:log_formatter] if @options[:log_formatter]
+      @log_writer.custom_logger = @options[:custom_logger] if @options[:custom_logger]
       @options[:log_writer] = @log_writer
       @options[:logger] = @log_writer if clustered?
 
+      @events = launcher_args[:events] || Events.new
+
+      @argv = launcher_args[:argv] || []
+      @original_argv = @argv.dup
+
+      ## End minimal initialization
+
+      generate_restart_data
+      Dir.chdir(@restart_dir)
+
+      prune_bundler!
+
+      env = launcher_args.delete(:env) || ENV
+
       # Advertise the Configuration
       Puma.cli_config = @config if defined?(Puma.cli_config)
       log_config if env['PUMA_LOG_CONFIG']
 
-      @binder        = Binder.new(@log_writer, @options)
+      @binder = Binder.new(@log_writer, @options)
       @binder.create_inherited_fds(env).each { |k| env.delete k }
       @binder.create_activated_fds(env).each { |k| env.delete k }
 
@@ -81,21 +94,10 @@ module Puma
         )
       end
 
-      @log_writer.formatter = LogWriter::PidFormatter.new if clustered?
-      @log_writer.formatter = @options[:log_formatter] if @options[:log_formatter]
-
-      @log_writer.custom_logger = @options[:custom_logger] if @options[:custom_logger]
-
-      generate_restart_data
-
       if clustered? && !Puma.forkable?
         unsupported "worker mode not supported on #{RUBY_ENGINE} on this platform"
       end
 
-      Dir.chdir(@restart_dir)
-
-      prune_bundler!
-
       @environment = @options[:environment] if @options[:environment]
       set_rack_environment
 
@@ -139,7 +141,10 @@ module Puma
     # Delete the configured pidfile
     def delete_pidfile
       path = @options[:pidfile]
-      File.unlink(path) if path && File.exist?(path)
+      begin
+        File.unlink(path) if path
+      rescue Errno::ENOENT
+      end
     end
 
     # Begin async shutdown of the server
@@ -381,9 +386,9 @@ module Puma
         # using it.
         @restart_dir = Dir.pwd
 
-        # Use the same trick as unicorn, namely favor PWD because
-        # it will contain an unresolved symlink, useful for when
-        # the pwd is /data/releases/current.
+      # Use the same trick as unicorn, namely favor PWD because
+      # it will contain an unresolved symlink, useful for when
+      # the pwd is /data/releases/current.
       elsif dir = ENV['PWD']
         s_env = File.stat(dir)
         s_pwd = File.stat(Dir.pwd)

data/lib/puma/server.rb

@@ -19,9 +19,6 @@ require 'socket'
 require 'io/wait' unless Puma::HAS_NATIVE_IO_WAIT
 
 module Puma
-  # Add `Thread#puma_server` and `Thread#puma_server=`
-  Thread.attr_accessor(:puma_server)
-
   # The HTTP Server itself. Serves out a single Rack app.
   #
   # This class is used by the `Puma::Single` and `Puma::Cluster` classes
@@ -262,7 +259,7 @@ module Puma
 
       @status = :run
 
-      @thread_pool = ThreadPool.new(thread_name, options) { |client| process_client client }
+      @thread_pool = ThreadPool.new(thread_name, options, server: self) { |client| process_client client }
 
       if @queue_requests
         @reactor = Reactor.new(@io_selector_backend) { |c|
@@ -481,9 +478,6 @@ module Puma
     #
     # Return true if one or more requests were processed.
     def process_client(client)
-      # Advertise this server into the thread
-      Thread.current.puma_server = self
-
       close_socket = true
 
       requests = 0
@@ -502,31 +496,41 @@ module Puma
           client.finish(@first_data_timeout)
         end
 
-        @requests_count += 1
-        case handle_request(client, requests + 1)
-        when false
-        when :async
-          close_socket = false
-        when true
-          requests += 1
+        can_loop = true
+        while can_loop
+          can_loop = false
+          @requests_count += 1
+          case handle_request(client, requests + 1)
+          when false
+          when :async
+            close_socket = false
+          when true
+            requests += 1
 
-          client.reset
+            client.reset
 
-          # 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
-            with_force_shutdown(client) { client.eagerly_finish }
-          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
+              with_force_shutdown(client) { client.eagerly_finish }
+            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
+            if next_request_ready
+              # When Puma has spare threads, allow this one to be monopolized
+              # Perf optimization for https://github.com/puma/puma/issues/3788
+              if @thread_pool.waiting > 0
+                can_loop = true
+              else
+                @thread_pool << client
+                close_socket = false
+              end
+            elsif @queue_requests
+              client.set_timeout @persistent_timeout
+              if @reactor.add client
+                close_socket = false
+              end
             end
           end
         end
@@ -706,7 +710,7 @@ module Puma
 
     def reset_max
       @reactor.reactor_max = 0 if @reactor
-      @thread_pool.reset_max
+      @thread_pool&.reset_max
     end
 
     # below are 'delegations' to binder

data/lib/puma/state_file.rb

@@ -32,10 +32,11 @@ module Puma
             "#{k}: \"#{v}\"\n" : "#{k}: #{v}\n")
         end
       end
+
       if permission
-        File.write path, contents, mode: 'wb:UTF-8'
-      else
         File.write path, contents, mode: 'wb:UTF-8', perm: permission
+      else
+        File.write path, contents, mode: 'wb:UTF-8'
       end
     end
 

data/lib/puma/thread_pool.rb

@@ -5,6 +5,10 @@ require 'thread'
 require_relative 'io_buffer'
 
 module Puma
+
+  # Add `Thread#puma_server` and `Thread#puma_server=`
+  Thread.attr_accessor(:puma_server)
+
   # Internal Docs for A simple thread pool management object.
   #
   # Each Puma "worker" has a thread pool to process requests.
@@ -33,7 +37,9 @@ module Puma
     # The block passed is the work that will be performed in each
     # thread.
     #
-    def initialize(name, options = {}, &block)
+    def initialize(name, options = {}, server: nil, &block)
+      @server = server
+
       @not_empty = ConditionVariable.new
       @not_full = ConditionVariable.new
       @mutex = Mutex.new
@@ -134,6 +140,9 @@ module Puma
       trigger_before_thread_start_hooks
       th = Thread.new(@spawned) do |spawned|
         Puma.set_thread_name '%s tp %03i' % [@name, spawned]
+        # Advertise server into the thread
+        Thread.current.puma_server = @server
+
         todo  = @todo
         block = @block
         mutex = @mutex

metadata

@@ -1,21 +1,21 @@
 --- !ruby/object:Gem::Specification
 name: puma
 version: !ruby/object:Gem::Version
-  version: 7.0.4
+  version: 7.1.0
 platform: java
 authors:
 - Evan Phoenix
 bindir: bin
 cert_chain: []
-date: 2025-09-23 00:00:00.000000000 Z
+date: 2025-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: nio4r
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+  name: nio4r
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -132,6 +132,7 @@ metadata:
   homepage_uri: https://puma.io
   source_code_uri: https://github.com/puma/puma
   rubygems_mfa_required: 'true'
+  msys2_mingw_dependencies: openssl
 rdoc_options: []
 require_paths:
 - lib