worker_killer 1.2.0.338627 → 1.2.1.338700

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c510f8e679380c48f3187ea9ca4addd8f6e3a3c5056836a53c67ecf333d78755
-  data.tar.gz: c43019874aadf5af779740d5e383cc55c9aa8dc1db746ddfd2b0a026e1e47689
+  metadata.gz: 986b0714653c95814fad3451e5dd4b94f7bfbd51d906862ba9162e6a43538323
+  data.tar.gz: dbd7caf55941dcd7507a5faff2e70accb5506149c5d3aee5f5cf5e87bc9b3999
 SHA512:
-  metadata.gz: 6cdea2fd58d762db14739fcfabdd51c5458ef3d94028233c99a2c9108883be0910d0bd2340686dbc51ee8343083d73c4822743f5b0beedf3d9a4b87452748ec8
-  data.tar.gz: efdc76b06a1074882101877f8b98b5470e83b4aaf174a46c9a8cae00b4c0d417b70b328d06b28f88f878464d07b333d1d0c90dff9e51c7571cb7adb407b71b5d
+  metadata.gz: e85bbb81be5b5d24615958f95d23c41e892b7212a1fbb5c09aa51b97887bb50dc857faef09e9e4bf686b169c395ded52868d0d8715482ca44f9897cedfb93d21
+  data.tar.gz: cb15d46503bcb63785a77c3e5cdcf602edce81fb7cd939da9d1047bdbe21686e6aad6c8f1137b15e079777f2f2179e8e8a70cd5c3ab0be379ad553a4929ab7bf

data/lib/worker_killer/configuration.rb

@@ -4,10 +4,13 @@ module WorkerKiller
   # Methods for configuring WorkerKiller
   class Configuration
 
+    # Attempts configuration is deprecated and unsed
     attr_accessor :logger, :quit_attempts, :term_attempts
 
     # Override defaults for configuration
+    # Attempts configuration is deprecated and unsed
     def initialize(quit_attempts: 10, term_attempts: 50)
+      # Attempts configuration is deprecated and unsed
       @quit_attempts = quit_attempts
       @term_attempts = term_attempts
       @logger = Logger.new(STDOUT, level: Logger::INFO, progname: 'WorkerKiller')

data/lib/worker_killer/count_limiter.rb

@@ -8,19 +8,23 @@ module WorkerKiller
       @max = max
       @limit = nil
       @left = nil
+
+      @started_at = Time.now
+      @triggered = false
       @verbose = verbose
     end
 
+    def initialize_limits
+      @limit = min + WorkerKiller.randomize(max - min + 1)
+      @left = @limit
+    end
+
     def check
-      # initialize limits on first check
-      if @limit.nil?
-        @limit = min + WorkerKiller.randomize(max - min + 1)
-        @left = @limit
-      end
+      return true if @triggered
 
-      return nil if @limit < 1
+      initialize_limits if @limit.nil?
 
-      @started_at ||= Time.now
+      return nil if @limit < 1
 
       if @verbose
         logger.info "#{self.class}: worker (pid: #{Process.pid}) has #{@left} left before being limited"
@@ -28,8 +32,8 @@ module WorkerKiller
 
       return false if (@left -= 1) > 0
 
+      # сработает только один раз для @left == 0
       logger.warn "#{self.class}: worker (pid: #{Process.pid}) exceeds max number of requests (limit: #{@limit})"
-
       true
     end
 

data/lib/worker_killer/killer/delayed_job.rb

@@ -2,23 +2,19 @@ module WorkerKiller
   module Killer
     class DelayedJob < ::WorkerKiller::Killer::Base
 
-      def do_kill(sig, pid, alive_sec, dj:, **_params)
-        if sig == :KILL
-          logger.error "#{self.class}: force to #{sig} self (pid: #{pid}) alive: #{alive_sec} sec (trial #{kill_attempts})"
+      def do_kill(sig, pid, alive_sec, dj:, **_kwargs)
+        case sig
+        when :QUIT
+          logger.info "#{self.class}: try to stop DelayedJob due to #{sig} self (pid: #{pid}) alive: #{alive_sec} sec (kill attempts #{kill_attempts})"
+          dj.stop
+        when :TERM
+          logger.warn "#{self.class}: force to #{sig} self (pid: #{pid}) alive: #{alive_sec} sec (kill attempts #{kill_attempts})"
           Process.kill sig, pid
-          return
-        end
-
-        dj.stop
-        logger.info "#{self.class}: try to stop DelayedJob due to #{sig} self (pid: #{pid}) alive: #{alive_sec} sec (trial #{kill_attempts})"
-
-        return if sig != :TERM
-
-        if @termination
-          logger.warn "#{self.class}: force to #{sig} self (pid: #{pid}) alive: #{alive_sec} sec (trial #{kill_attempts})"
+        when :KILL
+          logger.error "#{self.class}: force to #{sig} self (pid: #{pid}) alive: #{alive_sec} sec (kill attempts #{kill_attempts})"
           Process.kill sig, pid
         else
-          @termination = true
+          logger.error "#{self.class}: DO NOTHING: unknown #{sig} self (pid: #{pid}) alive: #{alive_sec} sec (kill attempts #{kill_attempts})"
         end
       end
 

data/lib/worker_killer/killer/puma.rb

@@ -14,7 +14,7 @@ module ::WorkerKiller
         return if @worker_num.nil? # May be nil if Puma not in Cluster mode
         return if @already_sended == sig
 
-        logger.warn "#{self.class} send [W#{worker_num}] to Puma Plugin (from pid: #{pid}) alive: #{alive_sec} sec (trial #{kill_attempts}) triggered by #{sig}"
+        logger.warn "#{self.class} send [W#{worker_num}] to Puma Plugin (from pid: #{pid}) alive: #{alive_sec} sec (kill attempts #{kill_attempts}) triggered by #{sig}"
 
         @already_sended = sig
         @puma_plugin.set_logger!(logger)
@@ -22,18 +22,6 @@ module ::WorkerKiller
         @puma_plugin.request_restart_server(worker_num)
       end
 
-      def do_inhibit(_path_info)
-        @puma_plugin.set_logger!(logger)
-
-        @puma_plugin.inhibit_restart(worker_num)
-      end
-
-      def do_release
-        @puma_plugin.set_logger!(logger)
-
-        @puma_plugin.release_restart(worker_num)
-      end
-
     end
   end
 end

data/lib/worker_killer/killer/signal.rb

@@ -2,11 +2,11 @@ module WorkerKiller
   module Killer
     class Signal < ::WorkerKiller::Killer::Base
 
-      def do_kill(sig, pid, alive_sec, **params)
+      def do_kill(sig, pid, alive_sec, **_kwargs)
         return if sig == @last_signal
 
         @last_signal = sig
-        logger.warn "#{self} send SIG#{sig} (pid: #{pid}) alive: #{alive_sec} sec (trial #{kill_attempts})"
+        logger.warn "#{self} send SIG#{sig} (pid: #{pid}) alive: #{alive_sec} sec (kill attempts #{kill_attempts})"
         Process.kill sig, pid
       end
 

data/lib/worker_killer/killer.rb

@@ -8,6 +8,7 @@ module WorkerKiller
         @logger = logger
         @config = WorkerKiller.configuration
         @kill_attempts = 0
+        @sig = nil
       end
 
       def kill(start_time, **params)
@@ -15,11 +16,16 @@ module WorkerKiller
 
         @kill_attempts += 1
 
-        sig = :QUIT
-        sig = :TERM if kill_attempts > config.quit_attempts
-        sig = :KILL if kill_attempts > (config.quit_attempts + config.term_attempts)
+        case @sig
+        when nil
+          @sig = :QUIT
+        when :QUIT
+          @sig = :TERM
+        when :TERM
+          @sig = :KILL
+        end
 
-        do_kill(sig, Process.pid, alive_sec, **params)
+        do_kill(@sig, Process.pid, alive_sec, **params)
       end
 
       # :nocov:

data/lib/worker_killer/memory_limiter.rb

@@ -15,28 +15,32 @@ module WorkerKiller
         @max_percent = max
       end
 
+      @started_at = Time.now
       @check_cycle = check_cycle
       @check_count = 0
+
+      @triggered = false
       @verbose = verbose
     end
 
+    def initialize_limits(rss)
+      if min.nil?
+        set_limits(rss, rss + rss * @max_percent)
+      else
+        set_limits(min, min + WorkerKiller.randomize(max - min + 1))
+      end
+    end
+
     def check
-      @started_at ||= Time.now
       @check_count += 1
-
-
       return nil if (@check_count % @check_cycle) != 0
 
+      return true if @triggered
+
       rss = GetProcessMem.new.bytes
 
       # initialize relative memory limits on first check
-      if @limit.nil?
-        if min.nil?
-          set_limits(rss, rss + rss * @max_percent)
-        else
-          set_limits(min, min + WorkerKiller.randomize(max - min + 1))
-        end
-      end
+      initialize_limits(rss) if @limit.nil?
 
       do_check(rss)
     end
@@ -51,6 +55,8 @@ module WorkerKiller
 
       return false if rss <= @limit
 
+      @triggered = true
+
       logger.warn "#{self.class}: worker (pid: #{Process.pid}) exceeds memory limit (#{rss_mb} MB > #{@limit_mb} MB)"
 
       true

data/lib/worker_killer/middleware.rb

@@ -4,7 +4,7 @@ require 'worker_killer/count_limiter'
 module WorkerKiller
   class Middleware
 
-    attr_reader :limiter, :killer, :reaction, :inhibitions
+    attr_reader :limiter, :killer, :interval, :reaction, :inhibitions
 
     # inhibitions - список адресов, которые будут времнно блокировать перезапуск воркеров:
     # Rails.application.config.middleware.insert_before(
@@ -12,68 +12,98 @@ module WorkerKiller
     #   WorkerKiller::Middleware::RequestsLimiter, killer:, min: 2, max: 3, inhibitions: ['/test']
     # )
     #
-    def initialize(app, killer:, klass:, inhibitions: [], reaction: nil, **opts)
+    def initialize(app, killer:, klass:, interval: 10, inhibitions: [], reaction: nil, **opts)
       @app = app
       @killer = killer
+      @interval = interval
 
-      @inhibitions = if @killer.respond_to?(:do_inhibit)
-        inhibitions.dup.freeze
-      else
-        [].freeze
-      end
+      @inhibitions = inhibitions.dup.freeze
 
       @reaction = reaction || method(:default_kill)
 
       @limiter = klass.new(**opts)
+      @last_reacted_at = 0.0
+      @inhibited = 0
+      @delayed_reaction = nil
     end
 
     def call(env)
-      inhibited = false
       if (path_info = env['PATH_INFO']) && inhibitions.any?{|i| path_info[i] }
-        inihibit(path_info)
-        inhibited = true
+        call_with_inhibition(env, path_info) do
+          # реакция будет вызвана после реального окончания обработки
+          react if limiter.check
+        end
+      else
+        @app.call(env).tap do
+          # реакция будет вызвана сейчас (как обычно)
+          react if limiter.check
+        end
       end
+    end
 
-      tuple = @app.call(env)
-      tuple = with_inhibition(tuple) if inhibited
+    def call_with_inhibition(env, path_info, &after)
+      inihibit(path_info)
 
-      tuple
-    ensure
-      reaction.call(limiter, killer) if killer && limiter.check
-    end
+      rack_response = nil
+      begin
+        rack_response = @app.call(env)
+      rescue Exception
+        # в случае ошибоки во время @app.call возращаем как было
+        release
+        raise
+      end
 
-    def with_inhibition(tuple)
       # Почему именно each описано в спецификации в разделе The Response
       # https://github.com/rack/rack/blob/main/SPEC.rdoc
-      if tuple[2].respond_to?(:each)
-        old = tuple[2]
-        tuple[2] = Enumerator.new do |y|
-          old.each do |chunk|
-            y << chunk
-          end
-          old.close if old.respond_to?(:close)
-          release
-        end
+      if rack_response[2].respond_to?(:each)
+        rack_response[2] = wrap_rack_response_body(rack_response[2], &after)
       else
-        release
+        release # освобождаем сразу
+        after.call
+      end
+
+      rack_response
+    end
+
+    def wrap_rack_response_body(rack_response_body, &after)
+      Enumerator.new do |y|
+        rack_response_body.each {|chunk| y << chunk }
+        # Почему именно close описано в спецификации в разделе The Response
+        # https://github.com/rack/rack/blob/main/SPEC.rdoc
+        rack_response_body.close if rack_response_body.respond_to?(:close)
+
+        release # освобождаем после отправки всего тела
+        after.call
+      end
+    end
+
+    def react
+      now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      return if now - @last_reacted_at < @interval
+
+      @last_reacted_at = now
+      if @inhibited > 0
+        @delayed_reaction = -> { reaction.call(limiter, killer) }
+      else
+        reaction.call(limiter, killer)
       end
-      tuple
     end
 
     def default_kill(l, k)
       k.kill(l.started_at)
     end
 
-    def inihibit(path_info)
-      killer.do_inhibit(path_info)
-    rescue StandardError => e
-      logger.error "#{self.class}::inhibit error: #{e.inspect}"
+    def inihibit(_path_info)
+      @inhibited += 1
     end
 
     def release
-      killer.do_release
-    rescue StandardError => e
-      logger.error "#{self.class}::release error: #{e.inspect}"
+      return unless ((@inhibited -= 1) == 0) && @delayed_reaction
+
+      @delayed_reaction.tap do |cb|
+        @delayed_reaction = nil
+        cb.call
+      end
     end
 
     def logger

data/lib/worker_killer/puma_plugin.rb

@@ -42,6 +42,7 @@ module WorkerKiller
       cb = if dsl.respond_to?(:before_worker_boot)
         :before_worker_boot
       else
+        # DEPRECATED
         :on_worker_boot
       end
 
@@ -64,6 +65,7 @@ module WorkerKiller
       cb = if launcher.events.respond_to?(:after_booted)
         :after_booted
       else
+        # DEPRECATED
         :on_booted
       end
 

data/lib/worker_killer/puma_plugin_ng.rb

@@ -22,7 +22,7 @@ module WorkerKiller
 
     end
 
-    attr_accessor :killer, :puma_server, :inhibited, :kill_queue
+    attr_accessor :killer, :puma_server, :kill_queue
 
     def initialize
       @killer = ::WorkerKiller::Killer::Puma.new(worker_num: nil, puma_plugin: self)
@@ -31,9 +31,9 @@ module WorkerKiller
 
       @puma_server = nil
 
-      @force_restart = false
-      @inhibited ||= Hash.new {|h, k| h[k] = 0 }
+      @force_restart = %w[t 1].include?(ENV.fetch('WORKER_KILLER_PUMA_AGGRESSIVE', 'false').to_s.downcase[0].to_s)
       @kill_queue ||= Set.new
+      @last_restarted_at = 0.0
     end
 
     # Этот метод зовётся при ИНИЦИАЛИЗАЦИИ плагина внути master-процесса, в самомо начале
@@ -46,9 +46,12 @@ module WorkerKiller
       cb = if dsl.respond_to?(:before_worker_boot)
         :before_worker_boot
       else
+        # DEPRECATED
         :on_worker_boot
       end
 
+      puts "SEND:#{cb}"
+
       dsl.send(cb) do |num|
         @killer.worker_num = num
         @worker_num = num
@@ -80,37 +83,22 @@ module WorkerKiller
     def request_restart_server(worker_num)
       return if @worker_num != worker_num
 
-      log("Equeue worker #{worker_num} for restarting...")
+      log("Enqueue worker #{worker_num} for restarting...")
       kill_queue << worker_num
-    end
-
-    # Этот метод зовётся из Middleware внтури воркера
-    def inhibit_restart(worker_num)
-      return if @worker_num != worker_num
-
-      cnt = inhibited[worker_num] += 1 # just increase inhibit counter
-      debug("Worker inhibition increased: #{cnt}")
-    end
-
-    # Этот метод зовётся из Middleware внтури воркера
-    def release_restart(worker_num)
-      return if @worker_num != worker_num
-
-      cnt = inhibited[worker_num] -= 1 # just decrease inhibit counter
-      debug("Worker inhibition decreased: #{cnt}")
-      return unless cnt <= 0
-
-      inhibited.delete(worker_num)
-      debug('Worker released')
-      do_kill('RELEASE') if @force_restart
+      do_kill('FORCE') if @force_restart
     end
 
     def do_kill(name)
       return if kill_queue.empty?
 
+      now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      return if now - @last_restarted_at < 10
+
+      @last_restarted_at = now
       log "Killing workers by #{name}: #{kill_queue}"
-      (kill_queue - inhibited.keys).each do |worker_num|
+      kill_queue.each do |worker_num|
         kill_queue.delete(worker_num)
+        Thread.current.puma_server.options[:force_shutdown_after] = nil
         Thread.current.puma_server.begin_restart
       end
     end

data/lib/worker_killer/version.rb

@@ -2,7 +2,7 @@
 
 module WorkerKiller
 
-  VERSION = '1.2.0'
+  VERSION = '1.2.1'
 
 end
 

data/spec/killer/delayed_job_spec.rb

@@ -1,35 +1,16 @@
 RSpec.describe WorkerKiller::Killer::DelayedJob do
-  let(:config) do
-    WorkerKiller::Configuration.new.tap do |c|
-      c.quit_attempts = 2
-      c.term_attempts = 2
-    end
-  end
-
   let(:dj){ double }
-  subject(:killer){ described_class.new() }
+  subject(:killer){ described_class.new }
 
   describe '#kill' do
-    context 'with use_quit TRUE' do
-      around do |example|
-        prev = WorkerKiller.configuration
-        WorkerKiller.configuration = config
-        example.run
-      ensure
-        WorkerKiller.configuration = prev
-      end
-
-      it 'expect right signal order' do
-        expect(dj).to receive(:stop).exactly(4)
-        expect(Process).to receive(:kill).with(:TERM, anything).exactly(1).times
-        expect(Process).to receive(:kill).with(:KILL, anything).exactly(5).times
+    it 'expect right signal order' do
+      expect(dj).to receive(:stop).exactly(1)
+      expect(Process).to receive(:kill).with(:TERM, anything).exactly(1).times
+      expect(Process).to receive(:kill).with(:KILL, anything).exactly(6).times
 
-        2.times { killer.kill(Time.now, dj: dj) } # 1 QUIT
-        2.times { killer.kill(Time.now, dj: dj) } # 1 TERM
-        5.times { killer.kill(Time.now, dj: dj) } # 5 KILL
-      end
+      3.times { killer.kill(Time.now, dj: dj) } # 1 QUIT 1 TERM 1 KILL
+      5.times { killer.kill(Time.now, dj: dj) } # 5 KILL
     end
   end
-  
 end
 

data/spec/killer/passenger_spec.rb

@@ -1,42 +1,25 @@
 RSpec.describe WorkerKiller::Killer::Passenger do
-  let(:config) do
-    WorkerKiller::Configuration.new.tap do |c|
-      c.quit_attempts = 2
-      c.term_attempts = 2
-    end
-  end
-
-  let(:killer){ described_class.new() }
+  let(:killer){ described_class.new }
 
   describe '#kill' do
     before do
       allow(described_class).to receive(:check_passenger_config).and_return('custompath')
     end
 
-    around do |example|
-      prev = WorkerKiller.configuration
-      WorkerKiller.configuration = config
-      example.run
-    ensure
-      WorkerKiller.configuration = prev
-    end
-
     it 'expect right signal order' do
       expect(Kernel).to receive(:system).with("custompath detach-process #{Process.pid}").and_return(true)
-      expect(Process).to receive(:kill).with(:KILL, anything).exactly(5).times
-
-      thread = killer.kill(Time.now)
-      thread.join
+      expect(Process).to receive(:kill).with(:KILL, anything).exactly(6).times
 
-      1.times { killer.kill(Time.now) } # 1 QUIT
-      2.times { killer.kill(Time.now) } # 1 TERM
+      3.times { killer.kill(Time.now) } # 1 QUIT 1 TERM 1 KILL
       5.times { killer.kill(Time.now) } # 5 KILL
     end
   end
 
   describe '#check_passenger_config!' do
     it do
-      expect{ described_class.check_passenger_config!('nonenone') }.to raise_error(/Can't find passenger/)
+      expect do
+        described_class.check_passenger_config!('nonenone')
+      end.to raise_error(/Can't find passenger/)
     end
   end
 end

data/spec/killer/puma_spec.rb

@@ -10,21 +10,5 @@ RSpec.describe WorkerKiller::Killer::Puma do
     end
   end
 
-  describe '#do_inhibit' do
-    it do
-      expect(puma_plugin).to receive(:inhibit_restart)
-
-      killer.do_inhibit('something')
-    end
-  end
-
-  describe '#do_release' do
-    it do
-      expect(puma_plugin).to receive(:release_restart)
-
-
-      killer.do_release
-    end
-  end
 end
 

data/spec/killer/signal_spec.rb

@@ -1,32 +1,14 @@
 RSpec.describe WorkerKiller::Killer::Signal do
-  let(:config) do
-    WorkerKiller::Configuration.new.tap do |c|
-      c.quit_attempts = 2
-      c.term_attempts = 2
-    end
-  end
-
-  let(:killer){ described_class.new() }
+  let(:killer){ described_class.new }
 
   describe '#kill' do
-    context 'with use_quit TRUE' do
-      around do |example|
-        prev = WorkerKiller.configuration
-        WorkerKiller.configuration = config
-        example.run
-      ensure
-        WorkerKiller.configuration = prev
-      end
-
-      it 'expect right signal order' do
-        expect(Process).to receive(:kill).with(:QUIT, anything).exactly(1).times
-        expect(Process).to receive(:kill).with(:TERM, anything).exactly(1).times
-        expect(Process).to receive(:kill).with(:KILL, anything).exactly(1).times
+    it 'expect right signal order' do
+      expect(Process).to receive(:kill).with(:QUIT, anything).exactly(1).times
+      expect(Process).to receive(:kill).with(:TERM, anything).exactly(1).times
+      expect(Process).to receive(:kill).with(:KILL, anything).exactly(1).times
 
-        2.times { killer.kill(Time.now) } # 1 QUIT
-        2.times { killer.kill(Time.now) } # 1 TERM
-        5.times { killer.kill(Time.now) } # 1 KILL
-      end
+      3.times { killer.kill(Time.now) } # 1 QUIT 1 TERM 1 KILL
+      5.times { killer.kill(Time.now) } # nothing
     end
   end
 end

data/spec/killer_spec.rb

@@ -1,40 +1,24 @@
 RSpec.describe WorkerKiller::Killer::Base do
-  let(:config) do
-    WorkerKiller::Configuration.new.tap do |c|
-      c.quit_attempts = 2
-      c.term_attempts = 2
-    end
-  end
-
-  let(:killer){ described_class.new() }
+  let(:killer){ described_class.new }
 
   describe '#kill' do
-    context 'with use_quit TRUE' do
-      around do |example|
-        prev = WorkerKiller.configuration
-        WorkerKiller.configuration = config
-        example.run
-      ensure
-        WorkerKiller.configuration = prev
+    it 'expect right signal order' do
+      if RUBY_VERSION >= '2.7.0'
+        expect(killer).to receive(:do_kill).with(:QUIT, anything, anything).exactly(1).times
+        expect(killer).to receive(:do_kill).with(:TERM, anything, anything).exactly(1).times
+        expect(killer).to receive(:do_kill).with(:KILL, anything, anything).exactly(6).times
+      else
+        expect(killer).to receive(:do_kill).with(:QUIT, anything, anything,
+                                                 anything).exactly(1).times
+        expect(killer).to receive(:do_kill).with(:TERM, anything, anything,
+                                                 anything).exactly(1).times
+        expect(killer).to receive(:do_kill).with(:KILL, anything, anything,
+                                                 anything).exactly(6).times
       end
 
-      it 'expect right signal order' do
-        if RUBY_VERSION >= "2.7.0"
-          expect(killer).to receive(:do_kill).with(:QUIT, anything, anything).exactly(2).times
-          expect(killer).to receive(:do_kill).with(:TERM, anything, anything).exactly(2).times
-          expect(killer).to receive(:do_kill).with(:KILL, anything, anything).exactly(5).times
-        else
-          expect(killer).to receive(:do_kill).with(:QUIT, anything, anything, anything).exactly(2).times
-          expect(killer).to receive(:do_kill).with(:TERM, anything, anything, anything).exactly(2).times
-          expect(killer).to receive(:do_kill).with(:KILL, anything, anything, anything).exactly(5).times
-        end
-
-        2.times { killer.kill(Time.now) } # 2 QUIT
-        2.times { killer.kill(Time.now) } # 2 TERM
-        5.times { killer.kill(Time.now) } # other - KILL
-      end
+      3.times { killer.kill(Time.now) } # 1 QUIT, 1 TERM, 1 KILL
+      5.times { killer.kill(Time.now) } # 5 KILL
     end
-
   end
 end
 

data/spec/middleware_spec.rb

@@ -1,7 +1,8 @@
 require 'securerandom'
 
 RSpec.describe WorkerKiller::Middleware do
-  let(:app){ double(call: {}) }
+  let(:rack_body) { double(each: %w[1 2 3], close: true) }
+  let(:app){ double(call: [nil, nil, rack_body]) }
   let(:killer) { double(WorkerKiller::Killer::Base, do_inhibit: true) }
   let(:reaction){ double }
   let(:anykey){ SecureRandom.hex(8) }
@@ -9,14 +10,15 @@ RSpec.describe WorkerKiller::Middleware do
   let(:env) { { 'PATH_INFO' => '/something' } }
 
   describe 'Custom class' do
-    let(:klass){ double }
+    let(:limiter_klass){ double }
     let(:options) do
-      { killer: killer, klass: klass, reaction: reaction, anykey: anykey, inhibitions: inhibitions }
+      { killer: killer, klass: limiter_klass, reaction: reaction, anykey: anykey,
+inhibitions: inhibitions }
     end
     subject{ described_class.new(app, **options) }
 
     it 'is expected to be initialized' do
-      expect(klass).to receive(:new).with(anykey: anykey).and_return(99)
+      expect(limiter_klass).to receive(:new).with(anykey: anykey).and_return(99)
       expect(subject.limiter).to eq(99)
       expect(subject.killer).to eq(killer)
     end
@@ -31,14 +33,13 @@ RSpec.describe WorkerKiller::Middleware do
       expect(subject.limiter).to be_an(WorkerKiller::CountLimiter)
       expect(subject.limiter.min).to eq(3)
       expect(subject.limiter.max).to eq(3)
-      expect(killer).to receive(:kill).with(Time).twice
+      expect(killer).to receive(:kill).with(Time)
 
       4.times do
         subject.call(env)
       end
     end
 
-
     describe 'inhibitions' do
       let(:env) { { 'PATH_INFO' => '/attachments' } }
 
@@ -47,11 +48,14 @@ RSpec.describe WorkerKiller::Middleware do
         expect(subject.limiter).to be_an(WorkerKiller::CountLimiter)
         expect(subject.limiter.min).to eq(3)
         expect(subject.limiter.max).to eq(3)
-        expect(killer).to receive(:kill).with(Time).twice
-        expect(killer).to receive(:do_release).exactly(4).times
+        expect(killer).to receive(:kill).with(Time)
+        expect(subject).to receive(:release).exactly(4).times.and_call_original
 
         4.times do
-          subject.call(env)
+          expect(app).to receive(:call).and_return([nil, nil, rack_body])
+          rack_response = subject.call(env)
+          subject.react
+          rack_response[2].each.to_a
         end
       end
     end
@@ -63,7 +67,7 @@ RSpec.describe WorkerKiller::Middleware do
       expect(subject.limiter).to be_an(WorkerKiller::CountLimiter)
       expect(subject.limiter.min).to eq(3)
       expect(subject.limiter.max).to eq(3)
-      expect(reaction).to receive(:call).with(subject.limiter, killer).twice
+      expect(reaction).to receive(:call).with(subject.limiter, killer)
 
       4.times do
         subject.call(env)

data/spec/puma_plugin_ng_spec.rb

@@ -8,7 +8,6 @@ RSpec.describe WorkerKiller::PumaPluginNg do
 
   it {
     is_expected.to have_attributes(killer:     ::WorkerKiller::Killer::Puma,
-                                   inhibited:  Hash,
                                    kill_queue: Set)
   }
 
@@ -32,29 +31,13 @@ RSpec.describe WorkerKiller::PumaPluginNg do
     end
   end
 
-  context '#inhibit_restart' do
-    it do
-      plugin.instance_variable_set('@worker_num', 99)
-      expect { plugin.inhibit_restart(99) }.to change { plugin.inhibited }.from({}).to({ 99 => 1 })
-    end
-  end
-
-  context '#release_restart' do
-    it do
-      plugin.instance_variable_set('@worker_num', 99)
-      plugin.inhibit_restart(99)
-
-      expect { plugin.release_restart(99) }.to change { plugin.inhibited }.from({ 99 => 1 }).to({})
-    end
-  end
-
   context '#do_kill' do
     it do
       Thread.attr_accessor(:puma_server)
 
       plugin.instance_variable_set('@worker_num', 99)
       plugin.request_restart_server(99)
-      puma_server = double()
+      puma_server = double(options: {})
       Thread.current.puma_server = puma_server
       expect(puma_server).to receive(:begin_restart)
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: worker_killer
 version: !ruby/object:Gem::Version
-  version: 1.2.0.338627
+  version: 1.2.1.338700
 platform: ruby
 authors:
 - Samoilenko Yuri
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-11-13 00:00:00.000000000 Z
+date: 2025-11-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: get_process_mem