pitchfork 0.16.0 → 0.18.0

data/lib/pitchfork/configurator.rb

@@ -14,7 +14,7 @@ module Pitchfork
     include Pitchfork
 
     # :stopdoc:
-    attr_accessor :set, :config_file, :after_load
+    attr_accessor :set, :config_file
 
     # used to stash stuff for deferred processing of cli options in
     # config.ru.  Do not rely on
@@ -41,21 +41,17 @@ module Pitchfork
       :worker_processes => 1,
       :before_fork => nil,
       :after_worker_fork => lambda { |server, worker|
-        server.logger.info("worker=#{worker.nr} gen=#{worker.generation} pid=#{$$} spawned")
+        server.logger.info("#{worker.to_log} spawned")
       },
       :after_mold_fork => lambda { |server, worker|
-        server.logger.info("mold gen=#{worker.generation} pid=#{$$} spawned")
+        server.logger.info("#{worker.to_log} spawned")
       },
       :before_worker_exit => nil,
       :after_worker_exit => lambda { |server, worker, status|
         m = if worker.nil?
-          "repead unknown process (#{status.inspect})"
-        elsif worker.mold?
-          "mold pid=#{worker.pid rescue 'unknown'} gen=#{worker.generation rescue 'unknown'} reaped (#{status.inspect})"
-        elsif worker.service?
-          "service pid=#{worker.pid rescue 'unknown'} gen=#{worker.generation rescue 'unknown'} reaped (#{status.inspect})"
+          "reaped unknown process (#{status.inspect})"
         else
-          "worker=#{worker.nr rescue 'unknown'} pid=#{worker.pid rescue 'unknown'} gen=#{worker.generation rescue 'unknown'} reaped (#{status.inspect})"
+          "#{worker.to_log} reaped (#{status.inspect})"
         end
         if status.success?
           server.logger.info(m)
@@ -64,10 +60,10 @@ module Pitchfork
         end
       },
       :after_worker_ready => lambda { |server, worker|
-        server.logger.info("worker=#{worker.nr} gen=#{worker.generation} ready")
+        server.logger.info("#{worker.to_log} ready")
       },
       :after_monitor_ready => lambda { |server|
-        server.logger.info("Monitor pid=#{Process.pid} ready")
+        server.logger.info("monitor pid=#{Process.pid} ready")
       },
       :after_worker_timeout => nil,
       :after_worker_hard_timeout => nil,
@@ -79,13 +75,14 @@ module Pitchfork
       :client_body_buffer_size => Pitchfork::Const::MAX_BODY,
       :before_service_worker_ready => nil,
       :before_service_worker_exit => nil,
+      :setpgid => true,
     }
     #:startdoc:
 
     def initialize(defaults = {}) #:nodoc:
       self.set = Hash.new(:unset)
       @use_defaults = defaults.delete(:use_defaults)
-      self.config_file = defaults.delete(:config_file)
+      self.config_file = defaults.delete(:config_file) { "config/pitchfork.rb" if File.exist?("config/pitchfork.rb") }
 
       set.merge!(DEFAULTS) if @use_defaults
       defaults.each { |key, value| self.__send__(key, value) }
@@ -207,6 +204,10 @@ module Pitchfork
       end
     end
 
+    def setpgid(bool)
+      set_bool(:setpgid, bool)
+    end
+
     def spawn_timeout(seconds)
       set_int(:spawn_timeout, seconds, 1)
     end
@@ -215,6 +216,14 @@ module Pitchfork
       set_int(:worker_processes, nr, 1)
     end
 
+    def refork_max_unavailable(max)
+      set_int(:refork_max_unavailable, max, 1)
+    end
+
+    def max_consecutive_spawn_errors(max)
+      set_int(:max_consecutive_spawn_errors, max, 1)
+    end
+
     def early_hints(bool)
       set_bool(:early_hints, bool)
     end

data/lib/pitchfork/http_server.rb

@@ -11,7 +11,7 @@ require 'pitchfork/info'
 module Pitchfork
   # This is the process manager of Pitchfork. This manages worker
   # processes which in turn handle the I/O and application process.
-  # Listener sockets are started in the master process and shared with
+  # Listener sockets are started in the monitor process and shared with
   # forked worker children.
   class HttpServer
     class TimeoutHandler
@@ -50,7 +50,7 @@ module Pitchfork
 
       def call(original_thread) # :nodoc:
         begin
-          @server.logger.error("worker=#{@worker.nr} pid=#{@worker.pid} timed out, exiting")
+          @server.logger.error("#{@worker.to_log} timed out, exiting")
           if @callback
             @callback.call(@server, @worker, Info.new(original_thread, @rack_env))
           end
@@ -80,9 +80,10 @@ module Pitchfork
     attr_accessor :app, :timeout, :timeout_signal, :soft_timeout, :cleanup_timeout, :spawn_timeout, :worker_processes,
                   :before_fork, :after_worker_fork, :after_mold_fork, :before_service_worker_ready, :before_service_worker_exit,
                   :listener_opts, :children,
-                  :orig_app, :config, :ready_pipe, :early_hints
+                  :orig_app, :config, :ready_pipe, :early_hints, :setpgid
     attr_writer   :after_worker_exit, :before_worker_exit, :after_worker_ready, :after_request_complete,
-                  :refork_condition, :after_worker_timeout, :after_worker_hard_timeout, :after_monitor_ready
+                  :refork_condition, :after_worker_timeout, :after_worker_hard_timeout, :after_monitor_ready, :refork_max_unavailable,
+                  :max_consecutive_spawn_errors
 
     attr_reader :logger
     include Pitchfork::SocketHelper
@@ -103,6 +104,9 @@ module Pitchfork
       @exit_status = 0
       @app = app
       @respawn = false
+      @refork_max_unavailable = nil
+      @consecutive_spawn_errors = 0
+      @max_consecutive_spawn_errors = nil
       @last_check = Pitchfork.time_now
       @promotion_lock = Flock.new("pitchfork-promotion")
       Info.keep_io(@promotion_lock)
@@ -116,11 +120,11 @@ module Pitchfork
 
       proc_name role: 'monitor', status: ARGV.join(' ')
 
-      # We use @control_socket differently in the master and worker processes:
+      # We use @control_socket differently in the monitor and worker processes:
       #
-      # * The master process never closes or reinitializes this once
-      # initialized.  Signal handlers in the master process will write to
-      # it to wake up the master from IO.select in exactly the same manner
+      # * The monitor process never closes or reinitializes this once
+      # initialized.  Signal handlers in the monitor process will write to
+      # it to wake up the monitor from IO.select in exactly the same manner
       # djb describes in https://cr.yp.to/docs/selfpipe.html
       #
       # * The workers immediately close the pipe they inherit.  See the
@@ -142,7 +146,7 @@ module Pitchfork
       # attempt to connect to the listener(s)
       config.commit!(self, :skip => [:listeners, :pid])
       @orig_app = app
-      # list of signals we care about and trap in master.
+      # list of signals we care about and trap in monitor.
       @queue_sigs = [
         :QUIT, :INT, :TERM, :USR2, :TTIN, :TTOU ]
 
@@ -157,16 +161,16 @@ module Pitchfork
       # This socketpair is used to wake us up from select(2) in #join when signals
       # are trapped.  See trap_deferred.
       # It's also used by newly spawned children to send their soft_signal pipe
-      # to the master when they are spawned.
+      # to the monitor when they are spawned.
       @control_socket.replace(Pitchfork.socketpair)
       Info.keep_ios(@control_socket)
-      @master_pid = $$
+      @monitor_pid = $$
 
       # setup signal handlers before writing pid file in case people get
       # trigger happy and send signals as soon as the pid file exists.
       # Note that signals don't actually get handled until the #join method
-      @queue_sigs.each { |sig| trap(sig) { @sig_queue << sig; awaken_master } }
-      trap(:CHLD) { awaken_master }
+      @queue_sigs.each { |sig| trap(sig) { @sig_queue << sig; awaken_monitor } }
+      trap(:CHLD) { awaken_monitor }
 
       if REFORKING_AVAILABLE
         spawn_initial_mold
@@ -224,7 +228,7 @@ module Pitchfork
     # to delay between retries.
     # A negative value for +:tries+ indicates the listen will be
     # retried indefinitely, this is useful when workers belonging to
-    # different masters are spawned during a transparent upgrade.
+    # different monitors are spawned during a transparent upgrade.
     def listen(address, opt = listener_opts[address] || {})
       address = config.expand_addr(address)
       return if String === address && listener_names.include?(address)
@@ -291,7 +295,7 @@ module Pitchfork
 
       proc_name role: 'monitor', status: ARGV.join(' ')
 
-      logger.info "master process ready" # test_exec.rb relies on this message
+      logger.info "monitor process ready" # test_exec.rb relies on this message
       if @ready_pipe
         begin
           @ready_pipe.syswrite($$.to_s)
@@ -306,11 +310,11 @@ module Pitchfork
             break
           end
         rescue => e
-          Pitchfork.log_error(@logger, "master loop error", e)
+          Pitchfork.log_error(@logger, "monitor loop error", e)
         end
       end
       stop # gracefully shutdown all workers on our way out
-      logger.info "master complete status=#{@exit_status}"
+      logger.info "monitor complete status=#{@exit_status}"
       @exit_status
     end
 
@@ -326,10 +330,17 @@ module Pitchfork
 
       case message = @sig_queue.shift
       when nil
-        # avoid murdering workers after our master process (or the
+        # avoid murdering workers after our monitor process (or the
         # machine) comes out of suspend/hibernation
         if (@last_check + @timeout) >= (@last_check = Pitchfork.time_now)
           sleep_time = murder_lazy_workers
+          if @max_consecutive_spawn_errors && @consecutive_spawn_errors > @max_consecutive_spawn_errors && !SharedMemory.shutting_down?
+            logger.fatal("#{@consecutive_spawn_errors} consecutive failures to spawn children, aborting - broken after_worker_fork callback?")
+            @exit_status = 1
+            SharedMemory.shutting_down!
+            stop(false)
+            return StopIteration
+          end
         else
           sleep_time = @timeout/2.0 + 1
           @logger.debug("waiting #{sleep_time}s after suspend/hibernation")
@@ -339,7 +350,7 @@ module Pitchfork
           restart_outdated_workers if REFORKING_AVAILABLE
         end
 
-        master_sleep(sleep_time) if sleep
+        monitor_sleep(sleep_time) if sleep
       when :QUIT, :TERM # graceful shutdown
         SharedMemory.shutting_down!
         logger.info "#{message} received, starting graceful shutdown"
@@ -363,28 +374,31 @@ module Pitchfork
       when Message::WorkerSpawned
         worker = @children.update(message)
         # TODO: should we send a message to the worker to acknowledge?
-        logger.info "worker=#{worker.nr} pid=#{worker.pid} gen=#{worker.generation} registered"
+        logger.info "#{worker.to_log} registered"
       when Message::MoldSpawned
         new_mold = @children.update(message)
-        logger.info("mold pid=#{new_mold.pid} gen=#{new_mold.generation} spawned")
+        logger.info("#{new_mold.to_log} spawned")
       when Message::ServiceSpawned
         new_service = @children.update(message)
-        logger.info("service pid=#{new_service.pid} gen=#{new_service.generation} spawned")
+        logger.info("#{new_service.to_log} spawned")
       when Message::MoldReady
+        @consecutive_spawn_errors = 0
         old_molds = @children.molds
         new_mold = @children.update(message)
-        logger.info("mold pid=#{new_mold.pid} gen=#{new_mold.generation} ready")
+        logger.info("#{new_mold.to_log} ready")
         old_molds.each do |old_mold|
-          logger.info("Terminating old mold pid=#{old_mold.pid} gen=#{old_mold.generation}")
+          logger.info("Terminating old #{old_mold.to_log}")
           old_mold.soft_kill(:TERM)
         end
+      when Message::WorkerReady, Message::ServiceReady
+        @consecutive_spawn_errors = 0
       else
         logger.error("Unexpected message in sig_queue #{message.inspect}")
         logger.error(@sig_queue.inspect)
       end
     end
 
-    # Terminates all workers, but does not exit master process
+    # Terminates all workers, but does not exit monitor process
     def stop(graceful = true)
       proc_name role: 'monitor', status: 'shutting down'
       @respawn = false
@@ -413,7 +427,7 @@ module Pitchfork
     end
 
     def worker_exit(worker)
-      logger.info "worker=#{worker.nr} pid=#{worker.pid} gen=#{worker.generation} exiting"
+      logger.info "#{worker.to_log} exiting"
       proc_name status: "exiting"
 
       if @before_worker_exit
@@ -427,7 +441,7 @@ module Pitchfork
     end
 
     def service_exit(service)
-      logger.info "service pid=#{service.pid} gen=#{service.generation} exiting"
+      logger.info "#{service.to_log} exiting"
       proc_name status: "exiting"
 
       if @before_service_worker_exit
@@ -467,8 +481,12 @@ module Pitchfork
 
     private
 
+    def refork_max_unavailable
+      @refork_max_unavailable ||= (worker_processes * 0.1).ceil
+    end
+
     # wait for a signal handler to wake us up and then consume the pipe
-    def master_sleep(sec)
+    def monitor_sleep(sec)
       @control_socket[0].wait(sec) or return
       case message = @control_socket[0].recvmsg_nonblock(exception: false)
       when :wait_readable, NOOP
@@ -478,9 +496,9 @@ module Pitchfork
       end
     end
 
-    def awaken_master
-      return if $$ != @master_pid
-      @control_socket[1].sendmsg_nonblock(NOOP, exception: false) # wakeup master process from select
+    def awaken_monitor
+      return if $$ != @monitor_pid
+      @control_socket[1].sendmsg_nonblock(NOOP, exception: false) # wakeup monitor process from select
     end
 
     # reaps all unreaped workers
@@ -490,6 +508,9 @@ module Pitchfork
         wpid or return
         worker = @children.reap(wpid) and worker.close rescue nil
         if worker
+          unless worker.ready?
+            @consecutive_spawn_errors += 1
+          end
           @after_worker_exit.call(self, worker, status)
         else
           logger.info("reaped unknown subprocess #{status.inspect}")
@@ -548,11 +569,8 @@ module Pitchfork
         end
       end
 
-      if child.mold?
-        logger.error "mold pid=#{child.pid} gen=#{child.generation} timed out, killing"
-      else
-        logger.error "worker=#{child.nr} pid=#{child.pid} gen=#{child.generation} timed out, killing"
-      end
+      logger.error "#{child.to_log} timed out, killing"
+      @consecutive_spawn_errors += 1 unless child.ready?
       @children.hard_kill(@timeout_signal.call(child.pid), child) # take no prisoners for hard timeout violations
     end
 
@@ -572,7 +590,7 @@ module Pitchfork
 
     def after_fork_internal
       @promotion_lock.at_fork
-      @control_socket[0].close_write # this is master-only, now
+      @control_socket[0].close_write # this is monitor-only, now
       @ready_pipe.close if @ready_pipe
       Pitchfork::Configurator::RACKUP.clear
       @ready_pipe = @init_listeners = nil
@@ -583,12 +601,13 @@ module Pitchfork
     end
 
     def spawn_worker(worker, detach:)
-      logger.info("worker=#{worker.nr} gen=#{worker.generation} spawning...")
+      logger.info("#{worker.to_log} spawning...")
 
       # We set the deadline before spawning the child so that if for some
       # reason it gets stuck before reaching the worker loop,
       # the monitor process will kill it.
       worker.update_deadline(@spawn_timeout)
+
       @before_fork&.call(self)
       fork_sibling("spawn_worker") do
         worker.pid = Process.pid
@@ -616,6 +635,7 @@ module Pitchfork
         end
       end
 
+      service.notify_ready(@control_socket[1])
       proc_name status: "ready"
 
       while readers[0]
@@ -646,7 +666,7 @@ module Pitchfork
     end
 
     def spawn_service(service, detach:)
-      logger.info("service gen=#{service.generation} spawning...")
+      logger.info("#{service.to_log} spawning...")
 
       # We set the deadline before spawning the child so that if for some
       # reason it gets stuck before reaching the worker loop,
@@ -667,7 +687,7 @@ module Pitchfork
     def spawn_initial_mold
       mold = Worker.new(nil)
       mold.create_socketpair!
-      mold.pid = Pitchfork.clean_fork do
+      mold.pid = Pitchfork.clean_fork(setpgid: setpgid) do
         mold.pid = Process.pid
         @promotion_lock.try_lock
         mold.after_fork_in_child
@@ -712,7 +732,7 @@ module Pitchfork
           spawn_worker(worker, detach: false)
         end
         # We could directly register workers when we spawn from the
-        # master, like pitchfork does. However it is preferable to
+        # monitor, like pitchfork does. However it is preferable to
         # always go through the asynchronous registering process for
         # consistency.
         @children.register(worker)
@@ -724,7 +744,7 @@ module Pitchfork
 
     def wait_for_pending_workers
       while @children.pending_workers?
-        master_sleep(0.5)
+        monitor_sleep(0.5)
         if monitor_loop(false) == StopIteration
           return StopIteration
         end
@@ -753,15 +773,14 @@ module Pitchfork
       # We don't shutdown any outdated worker if any worker is already being
       # spawned or a worker is exiting. Only 10% of workers can be reforked at
       # once to minimize the impact on capacity.
-      max_pending_workers = (worker_processes * 0.1).ceil
-      workers_to_restart = max_pending_workers - @children.restarting_workers_count
+      workers_to_restart = refork_max_unavailable - @children.restarting_workers_count
 
       if service = @children.service
         if service.outdated?
           if service.soft_kill(:TERM)
-            logger.info("Sent SIGTERM to service pid=#{service.pid} gen=#{service.generation}")
+            logger.info("Sent SIGTERM to #{service.to_log}")
           else
-            logger.info("Failed to send SIGTERM to service pid=#{service.pid} gen=#{service.generation}")
+            logger.info("Failed to send SIGTERM to #{service.to_log}")
           end
         end
       end
@@ -770,10 +789,10 @@ module Pitchfork
         outdated_workers = @children.workers.select { |w| !w.exiting? && w.generation < @children.mold.generation }
         outdated_workers.each do |worker|
           if worker.soft_kill(:TERM)
-            logger.info("Sent SIGTERM to worker=#{worker.nr} pid=#{worker.pid} gen=#{worker.generation}")
+            logger.info("Sent SIGTERM to #{worker.to_log}")
             workers_to_restart -= 1
           else
-            logger.info("Failed to send SIGTERM to worker=#{worker.nr} pid=#{worker.pid} gen=#{worker.generation}")
+            logger.info("Failed to send SIGTERM to #{worker.to_log}")
           end
           break if workers_to_restart <= 0
         end
@@ -874,7 +893,7 @@ module Pitchfork
       env
     ensure
       if env
-        env["rack.response_finished"].each do |callback|
+        env["rack.response_finished"].reverse_each do |callback|
           if callback.arity == 0
             callback.call
           else
@@ -885,7 +904,6 @@ module Pitchfork
         end
       end
       timeout_handler.finished
-      env
     end
 
     def nuke_listeners!(readers)
@@ -895,14 +913,18 @@ module Pitchfork
       tmp.each { |io| io.close rescue nil } # break out of IO.select
     end
 
+    def reset_signal_handlers
+      [:QUIT, :TERM, :INT].each { |sig| trap(sig) { exit!(0) } }
+    end
+
     # gets rid of stuff the worker has no business keeping track of
     # to free some resources and drops all sig handlers.
-    # traps for USR2, and HUP may be set in the after_fork Proc
+    # traps for USR2, and HUP may be set in the after_worker_fork/after_mold_fork Procs
     # by the user.
     def init_worker_process(worker)
       proc_name role: "(gen:#{worker.generation}) worker[#{worker.nr}]", status: "init"
       worker.reset
-      worker.register_to_master(@control_socket[1])
+      worker.register_to_monitor(@control_socket[1])
       # we'll re-trap :QUIT and :TERM later for graceful shutdown iff we accept clients
       exit_sigs = [ :QUIT, :TERM, :INT ]
       exit_sigs.each { |sig| trap(sig) { exit!(0) } }
@@ -926,14 +948,13 @@ module Pitchfork
     end
 
     def init_service_process(service)
-      proc_name role: "(gen:#{service.generation}) mold", status: "init"
-      LISTENERS.each(&:close) # Don't appear as listening to incoming requests
-      service.register_to_master(@control_socket[1])
+      proc_name role: "(gen:#{service.generation}) service", status: "init"
+      LISTENERS.each(&:close).clear # Don't appear as listening to incoming requests
+      service.register_to_monitor(@control_socket[1])
       readers = [service]
       trap(:QUIT) { nuke_listeners!(readers) }
       trap(:TERM) { nuke_listeners!(readers) }
       trap(:INT) { nuke_listeners!(readers); exit!(0) }
-      proc_name role: "(gen:#{service.generation}) service", status: "ready"
       readers
     end
 
@@ -944,7 +965,6 @@ module Pitchfork
       trap(:QUIT) { nuke_listeners!(readers) }
       trap(:TERM) { nuke_listeners!(readers) }
       trap(:INT) { nuke_listeners!(readers); exit!(0) }
-      proc_name role: "(gen:#{mold.generation}) mold", status: "ready"
       readers
     end
 
@@ -969,6 +989,7 @@ module Pitchfork
       ready = readers.dup
       @after_worker_ready.call(self, worker)
 
+      worker.notify_ready(@control_socket[1])
       proc_name status: "ready"
 
       while readers[0]
@@ -986,7 +1007,7 @@ module Pitchfork
               if Info.fork_safe?
                 spawn_mold(worker)
               else
-                logger.error("worker=#{worker.nr} gen=#{worker.generation} is no longer fork safe, can't refork")
+                logger.error("#{worker.to_log} is no longer fork safe, can't refork")
               end
             when Message
               worker.update(client)
@@ -1006,7 +1027,7 @@ module Pitchfork
             if @refork_condition.met?(worker, logger)
               proc_name status: "requests: #{worker.requests_count}, spawning mold"
               if spawn_mold(worker)
-                logger.info("worker=#{worker.nr} gen=#{worker.generation} Refork condition met, promoting ourselves")
+                logger.info("#{worker.to_log} refork condition met, promoting ourselves")
               end
               @refork_condition.backoff!
             end
@@ -1052,6 +1073,8 @@ module Pitchfork
       ready = readers.dup
 
       mold.finish_promotion(@control_socket[1])
+      mold.ready = true
+      proc_name status: "ready"
 
       while readers[0]
         begin
@@ -1069,11 +1092,11 @@ module Pitchfork
                 spawn_worker(Worker.new(message.nr, generation: mold.generation), detach: true)
               rescue ForkFailure
                 if retries > 0
-                  @logger.fatal("mold pid=#{mold.pid} gen=#{mold.generation} Failed to spawn a worker. Retrying.")
+                  @logger.fatal("#{mold.to_log} failed to spawn a worker, retrying")
                   retries -= 1
                   retry
                 else
-                  @logger.fatal("mold pid=#{mold.pid} gen=#{mold.generation} Failed to spawn a worker twice in a row. Corrupted mold process?")
+                  @logger.fatal("#{mold.to_log} failed to spawn a worker twice in a row - corrupted mold process?")
                   Process.exit(1)
                 end
               rescue => error
@@ -1085,11 +1108,11 @@ module Pitchfork
                 spawn_service(Service.new(generation: mold.generation), detach: true)
               rescue ForkFailure
                 if retries > 0
-                  @logger.fatal("mold pid=#{mold.pid} gen=#{mold.generation} Failed to spawn a service. Retrying.")
+                  @logger.fatal("#{mold.to_log} failed to spawn a service, retrying")
                   retries -= 1
                   retry
                 else
-                  @logger.fatal("mold pid=#{mold.pid} gen=#{mold.generation} Failed to spawn a service twice in a row. Corrupted mold process?")
+                  @logger.fatal("#{mold.to_log} failed to spawn a service twice in a row - corrupted mold process?")
                   Process.exit(1)
                 end
               rescue => error
@@ -1166,9 +1189,9 @@ module Pitchfork
       if REFORKING_AVAILABLE
         r, w = Pitchfork::Info.keep_ios(IO.pipe)
         # We double fork so that the new worker is re-attached back
-        # to the master.
+        # to the monitor.
         # This requires either PR_SET_CHILD_SUBREAPER which is exclusive to Linux 3.4
-        # or the master to be PID 1.
+        # or the monitor to be PID 1.
         if middle_pid = FORK_LOCK.synchronize { Process.fork } # parent
           w.close
           # We need to wait(2) so that the middle process doesn't end up a zombie.
@@ -1186,9 +1209,11 @@ module Pitchfork
             raise ForkFailure, "fork_sibling didn't succeed in #{FORK_TIMEOUT} seconds"
           end
         else # first child
+          reset_signal_handlers
+
           r.close
           Process.setproctitle("<pitchfork fork_sibling(#{role})>")
-          pid = Pitchfork.clean_fork do
+          pid = Pitchfork.clean_fork(setpgid: setpgid) do
             # detach into a grand child
             w.close
             yield
@@ -1203,7 +1228,7 @@ module Pitchfork
           exit!
         end
       else
-        Pitchfork.clean_fork(&block)
+        Pitchfork.clean_fork(setpgid: setpgid, &block)
       end
     end
 

data/lib/pitchfork/info.rb

@@ -98,13 +98,14 @@ module Pitchfork
       def live_workers_count
         now = Pitchfork.time_now(true)
         (0...workers_count).count do |nr|
-          SharedMemory.worker_deadline(nr).value > now
+          state = SharedMemory.worker_state(nr)
+          state.ready? && state.deadline > now
         end
       end
 
       # Returns true if the server is shutting down.
       # This can be useful to implement health check endpoints, so they
-      # can fail immediately after TERM/QUIT/INT was received by the master
+      # can fail immediately after TERM/QUIT/INT was received by the monitor
       # process.
       # Otherwise they may succeed while Pitchfork is draining requests causing
       # more requests to be sent.

data/lib/pitchfork/message.rb

@@ -124,6 +124,7 @@ module Pitchfork
   class Message
     SpawnWorker = new(:nr)
     WorkerSpawned = new(:nr, :pid, :generation, :pipe)
+    WorkerReady = new(:nr, :pid, :generation)
     PromoteWorker = new(:generation)
 
     MoldSpawned = new(:nr, :pid, :generation, :pipe)
@@ -131,6 +132,7 @@ module Pitchfork
 
     SpawnService = new(:_) # Struct.new requires at least 1 member on Ruby < 3.3
     ServiceSpawned = new(:pid, :generation, :pipe)
+    ServiceReady = new(:pid, :generation)
 
     SoftKill = new(:signum)
   end

data/lib/pitchfork/refork_condition.rb

@@ -19,7 +19,7 @@ module Pitchfork
           if worker.requests_count >= limit
             return false if backoff?
 
-            logger.info("worker=#{worker.nr} pid=#{worker.pid} processed #{worker.requests_count} requests, triggering a refork")
+            logger.info("#{worker.to_log} processed #{worker.requests_count} requests, triggering a refork")
             return true
           end
         end