worker_killer 1.1.0.214159 → 1.2.0.338563

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a765c4a2926183623220942f0919ad8f7d83302b7e03140fa8e2509e5639788f
-  data.tar.gz: e06fc24c3067f25d03ee1f43ead253330c0a7734e139d8f3678ec42cc2d59e0d
+  metadata.gz: 64ffd6e8f669eba3536a04cd6910c9193a3a4177640cc8bdfa461c829a97b0e7
+  data.tar.gz: 0b4a46d57ec83559630f31d0c8648b809b7edd923c6f6acd45636204387e9070
 SHA512:
-  metadata.gz: 8a7a69c2c344967413ce45923a07e97bd265ccb6c84a14e6eb18377f3a1c8c791d32360fbc81aa1d0ff8c3e1af0da2d5120d7e003fa9a601383c7a954052de1d
-  data.tar.gz: 1da895a3b057fc9b896fa2a0a5d3cf670f1eaafa2b190ccaf5ee3c31080a48ecae93d795d2d46d130700fd106cf3a1a54cef6e2f0adc2b8d462938253fb623b5
+  metadata.gz: a59dc746b5c4a1ae2d457a590719191e0698231833b6dba31af81ec4e1548b33460118ffc1557ff860263c0ad52b6d699d67f0304f9680e6e82869de3709240a
+  data.tar.gz: 0faf8d3cf8347a367cfa988541dbca1727bb4f8d70302f6bde81b74800b23a506a394cb78bf4e77f470fc5e82f80c26beb836314dbdde72bf02213d3a0b4655e

data/lib/worker_killer/killer/puma.rb

@@ -1,27 +1,37 @@
-require 'socket'
-
 module ::WorkerKiller
   module Killer
     class Puma < ::WorkerKiller::Killer::Base
 
-      attr_accessor :ipc_path, :worker_num
+      attr_accessor :worker_num
 
-      def initialize(ipc_path:, worker_num: nil, **kwargs)
+      def initialize(puma_plugin:, worker_num: nil, **kwargs)
         super(**kwargs)
-        @ipc_path = ipc_path
+        @puma_plugin = puma_plugin
         @worker_num = worker_num
       end
 
       def do_kill(sig, pid, alive_sec, **_params)
+        return if @worker_num.nil? # May be nil if Puma not in Cluster mode
         return if @already_sended == sig
 
-        logger.warn "#{self} send #{worker_num} to Puma Plugin (pid: #{pid}) alive: #{alive_sec} sec (trial #{kill_attempts})"
+        logger.warn "#{self.class} send [W#{worker_num}] to Puma Plugin (from pid: #{pid}) alive: #{alive_sec} sec (trial #{kill_attempts}) triggered by #{sig}"
 
         @already_sended = sig
+        @puma_plugin.set_logger!(logger)
+
+        @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)
 
-        Socket.unix(ipc_path) do |sock|
-          sock.puts Integer(worker_num).to_s
-        end
+        @puma_plugin.release_restart(worker_num)
       end
 
     end

data/lib/worker_killer/killer.rb

@@ -29,7 +29,7 @@ module WorkerKiller
       # :nocov:
 
       def logger
-        @logger || WorkerKiller.configuration.logger
+        @logger ||= WorkerKiller.configuration.logger
       end
 
     end

data/lib/worker_killer/middleware.rb

@@ -4,23 +4,78 @@ require 'worker_killer/count_limiter'
 module WorkerKiller
   class Middleware
 
-    attr_reader :limiter, :killer, :reaction
+    attr_reader :limiter, :killer, :reaction, :inhibitions
 
-    def initialize(app, killer:, klass:, reaction: nil, **opts)
+    # inhibitions - список адресов, которые будут времнно блокировать перезапуск воркеров:
+    # Rails.application.config.middleware.insert_before(
+    #   Rack::Sendfile,
+    #   WorkerKiller::Middleware::RequestsLimiter, killer:, min: 2, max: 3, inhibitions: ['/test']
+    # )
+    #
+    def initialize(app, killer:, klass:, inhibitions: [], reaction: nil, **opts)
       @app = app
       @killer = killer
 
-      @reaction = reaction || proc do |l, k|
-        k.kill(l.started_at)
+      @inhibitions = if @killer.respond_to?(:do_inhibit)
+        inhibitions.dup.freeze
+      else
+        [].freeze
       end
 
+      @reaction = reaction || method(:default_kill)
+
       @limiter = klass.new(**opts)
     end
 
     def call(env)
-      @app.call(env)
+      inhibited = false
+      if (path_info = env['PATH_INFO']) && inhibitions.any?{|i| path_info[i] }
+        inihibit(path_info)
+        inhibited = true
+      end
+
+      tuple = @app.call(env)
+      tuple = with_inhibition(tuple) if inhibited
+
+      tuple
     ensure
-      reaction.call(limiter, killer) if limiter.check
+      reaction.call(limiter, killer) if killer && limiter.check
+    end
+
+    def with_inhibition(tuple)
+      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
+      else
+        release
+      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}"
+    end
+
+    def release
+      killer.do_release
+    rescue StandardError => e
+      logger.error "#{self.class}::release error: #{e.inspect}"
+    end
+
+    def logger
+      @logger ||= WorkerKiller.configuration.logger
     end
 
     class RequestsLimiter < ::WorkerKiller::Middleware

data/lib/worker_killer/puma/plugin/worker_killer_ng.rb

@@ -0,0 +1,13 @@
+require 'worker_killer'
+require 'worker_killer/puma_plugin_ng'
+
+Puma::Plugin.create do
+  def config(cfg)
+    ::WorkerKiller::PumaPluginNg.instance.config(cfg)
+  end
+
+  def start(launcher)
+    ::WorkerKiller::PumaPluginNg.instance.start(launcher)
+  end
+end
+

data/lib/worker_killer/puma_plugin.rb

@@ -1,30 +1,62 @@
+require 'delegate'
 require 'singleton'
+require 'socket'
 
 require 'worker_killer/memory_limiter'
 require 'worker_killer/count_limiter'
 
-
 module WorkerKiller
   class PumaPlugin
 
     include Singleton
 
+    class PumaLogWrapper < SimpleDelegator
+
+      def info(msg)
+        __getobj__.log(msg)
+      end
+
+      def warn(msg)
+        __getobj__.log(msg)
+      end
+
+      def debug(msg)
+        __getobj__.log("(DEBUG) #{msg}")
+      end
+
+    end
+
     attr_accessor :ipc_path, :killer, :thread
 
     def initialize
+      @killer = ::WorkerKiller::Killer::Puma.new(worker_num: nil, puma_plugin: self)
+      @worker_num = nil
+      @debug = false
+
       @ipc_path = File.join('tmp', "puma_worker_killer_#{Process.pid}.socket")
-      @killer = ::WorkerKiller::Killer::Puma.new(worker_num: nil, ipc_path: ipc_path)
-      log "Initializing IPC: #{@ipc_path}"
     end
 
-    def config(puma)
-      puma.on_worker_boot do |num|
-        log "Set worker_num: #{num}"
+    # Этот метод зовётся при ИНИЦИАЛИЗАЦИИ плагина внути master-процесса, в самомо начале
+    # тут можно выполнить конфигурацию чегоднибудь нужного
+    def config(dsl)
+      if %w[t 1].include?(ENV.fetch('WORKER_KILLER_DEBUG', 'false').to_s.downcase[0].to_s)
+        @debug = true
+      end
+
+      dsl.before_worker_boot do |num|
         @killer.worker_num = num
+        @worker_num = num
+        @tag = nil
+        log "Set worker_num: #{num}"
       end
     end
 
+    # Этот метод зовётся при ИНИЦИАЛИЗАЦИИ плагина внути master-процесса, контролирующего кластер Puma
+    # псле форка данные сохранённые тут также доступны (например logger)
     def start(launcher)
+      set_logger!(PumaLogWrapper.new(launcher.log_writer))
+
+      log "Initializing IPC: #{@ipc_path}"
       @runner = launcher.instance_variable_get('@runner')
 
       launcher.events.on_booted do
@@ -32,10 +64,32 @@ module WorkerKiller
       end
     end
 
+    def set_logger!(logger)
+      @logger = logger
+    end
+
+    # Этот метод зовётся из Middleware внтури воркера
+    def request_restart_server(worker_num)
+      log("Equeue worker #{worker_num} for restarting...")
+      Socket.unix(ipc_path) do |sock|
+        sock.puts Integer(worker_num).to_s
+      end
+    end
+
+    # Этот метод зовётся из Middleware внтури воркера
+    def inhibit_restart(_worker_num)
+      nil
+    end
+
+    # Этот метод зовётся из Middleware внтури воркера
+    def release_restart(_worker_num)
+      nil
+    end
+
     def start_ipc_listener
-      log 'Start IPC listener'
+      log "Start IPC listener on #{@ipc_path}"
       Thread.new do
-        Socket.unix_server_loop(ipc_path) do |sock, *args|
+        Socket.unix_server_loop(ipc_path) do |sock, *_args|
           if (line = sock.gets)
             worker_num = Integer(line.strip)
             if (worker = find_worker(worker_num))
@@ -72,7 +126,25 @@ module WorkerKiller
     end
 
     def log(msg)
-      warn("#{self.class}[#{Process.pid}]: #{msg}")
+      if @logger
+        @logger.warn("#{tag} #{msg}")
+      else
+        warn("[#{Process.pid}] #{tag} #{msg}")
+      end
+    end
+
+    def tag
+      @tag ||= "[#{self.class}] #{@worker_num.nil? ? '[M]' : "[W#{@worker_num}]"}"
+    end
+
+    def debug(msg)
+      return unless @debug
+
+      if @logger
+        @logger.debug("#{tag} #{msg}")
+      else
+        warn("[#{Process.pid}] #{tag} (DEBUG) #{msg}")
+      end
     end
 
   end

data/lib/worker_killer/puma_plugin_ng.rb

@@ -0,0 +1,140 @@
+require 'delegate'
+require 'singleton'
+
+require 'worker_killer/memory_limiter'
+require 'worker_killer/count_limiter'
+
+
+module WorkerKiller
+  class PumaPluginNg
+
+    include Singleton
+
+    class PumaLogWrapper < SimpleDelegator
+
+      def info(msg)
+        __getobj__.log(msg)
+      end
+
+      def warn(msg)
+        __getobj__.log(msg)
+      end
+
+      def debug(msg)
+        __getobj__.log("(DEBUG) #{msg}")
+      end
+
+    end
+
+    attr_accessor :killer, :puma_server, :inhibited, :kill_queue
+
+    def initialize
+      @killer = ::WorkerKiller::Killer::Puma.new(worker_num: nil, puma_plugin: self)
+      @worker_num = nil
+      @debug = false
+
+      @puma_server = nil
+
+      @force_restart = false
+      @inhibited ||= Hash.new {|h, k| h[k] = 0 }
+      @kill_queue ||= Set.new
+    end
+
+    # Этот метод зовётся при ИНИЦИАЛИЗАЦИИ плагина внути master-процесса, в самомо начале
+    # тут можно выполнить конфигурацию чегоднибудь нужного
+    def config(dsl)
+      if %w[t 1].include?(ENV.fetch('WORKER_KILLER_DEBUG', 'false').to_s.downcase[0].to_s)
+        @debug = true
+      end
+
+      dsl.before_worker_boot do |num|
+        @killer.worker_num = num
+        @worker_num = num
+        @tag = nil
+        log "Set worker_num: #{num}"
+      end
+
+      dsl.out_of_band do
+        do_kill('OOB') unless @force_restart
+      end
+    end
+
+    # Этот метод зовётся при ИНИЦИАЛИЗАЦИИ плагина внути master-процесса, контролирующего кластер Puma
+    # псле форка данные сохранённые тут также доступны (например logger)
+    def start(launcher)
+      set_logger!(PumaLogWrapper.new(launcher.log_writer))
+    end
+
+    def set_logger!(logger)
+      @logger = logger
+    end
+
+    # Завершать процесс сразу после окончания inhibited метода. Иначе завершение будет происзодть в Out Of Band методе
+    def force_restart!(force = true)
+      @force_restart = force
+    end
+
+    # Этот метод зовётся из Middleware внтури воркера
+    def request_restart_server(worker_num)
+      return if @worker_num != worker_num
+
+      log("Equeue 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
+      log("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
+      log("Worker inhibition decreased: #{cnt}")
+      return unless cnt <= 0
+
+      inhibited.delete(worker_num)
+      log('Worker released')
+      do_kill('RELEASE') if @force_restart
+    end
+
+    def do_kill(name)
+      return if kill_queue.empty?
+
+      log "Killing workers by #{name}: #{kill_queue}"
+      (kill_queue - inhibited.keys).each do |worker_num|
+        kill_queue.delete(worker_num)
+        Thread.current.puma_server.begin_restart
+      end
+    end
+
+    def log(msg)
+      if @logger
+        @logger.warn("#{tag} #{msg}")
+      else
+        warn("[#{Process.pid}] #{tag} #{msg}")
+      end
+    end
+
+    def tag
+      @tag ||= "[#{self.class}] #{@worker_num.nil? ? '[M]' : "[W#{@worker_num}]"}"
+    end
+
+    def debug(msg)
+      return unless @debug
+
+      if @logger
+        @logger.debug("#{tag} #{msg}")
+      else
+        warn("[#{Process.pid}] #{tag} (DEBUG) #{msg}")
+      end
+    end
+
+  end
+end
+

data/lib/worker_killer/version.rb

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

data/spec/killer/puma_spec.rb

@@ -1,34 +1,29 @@
 RSpec.describe WorkerKiller::Killer::Puma do
-  let(:config) do
-    WorkerKiller::Configuration.new.tap do |c|
-      c.quit_attempts = 2
-      c.term_attempts = 2
+  let(:puma_plugin) { double(set_logger!: nil) }
+  let(:killer){ described_class.new(puma_plugin: puma_plugin, worker_num: 99) }
+
+  describe '#kill' do
+    it do
+      expect(puma_plugin).to receive(:request_restart_server)
+
+      killer.kill(Time.now)
     end
   end
 
-  let(:ipc_path) { '/tmp/test_ipx.sock' }
-  let(:killer){ described_class.new(ipc_path: ipc_path, worker_num: 99) }
-  let(:buffer) { StringIO.new }
+  describe '#do_inhibit' do
+    it do
+      expect(puma_plugin).to receive(:inhibit_restart)
 
-  describe '#kill' do
-    around do |example|
-      prev = WorkerKiller.configuration
-      WorkerKiller.configuration = config
-      example.run
-    ensure
-      WorkerKiller.configuration = prev
+      killer.do_inhibit('something')
     end
+  end
 
-    it 'expect right signal order' do
-      expect(Socket).to receive(:unix).with(ipc_path).and_yield(buffer).exactly(3).times
-      expect(Process).not_to receive(:kill)
+  describe '#do_release' do
+    it do
+      expect(puma_plugin).to receive(:release_restart)
 
-      killer.kill(Time.now)
-      expect(buffer.string.strip).to eq(99.to_s)
 
-      1.times { killer.kill(Time.now) } # 1 QUIT
-      2.times { killer.kill(Time.now) } # 1 TERM
-      5.times { killer.kill(Time.now) } # 5 KILL
+      killer.do_release
     end
   end
 end

data/spec/middleware_spec.rb

@@ -2,13 +2,17 @@ require 'securerandom'
 
 RSpec.describe WorkerKiller::Middleware do
   let(:app){ double(call: {}) }
-  let(:killer) { double }
+  let(:killer) { double(WorkerKiller::Killer::Base, do_inhibit: true) }
   let(:reaction){ double }
   let(:anykey){ SecureRandom.hex(8) }
+  let(:inhibitions) { [%r{/attachments}] }
+  let(:env) { { 'PATH_INFO' => '/something' } }
 
   describe 'Custom class' do
     let(:klass){ double }
-    let(:options){ { killer: killer, klass: klass, reaction: reaction, anykey: anykey } }
+    let(:options) do
+      { killer: killer, klass: klass, reaction: reaction, anykey: anykey, inhibitions: inhibitions }
+    end
     subject{ described_class.new(app, **options) }
 
     it 'is expected to be initialized' do
@@ -19,7 +23,7 @@ RSpec.describe WorkerKiller::Middleware do
   end
 
   describe WorkerKiller::Middleware::RequestsLimiter do
-    let(:options){ { killer: killer, min: 3, max: 3 } }
+    let(:options){ { killer: killer, min: 3, max: 3, inhibitions: inhibitions } }
     subject{ described_class.new(app, **options) }
 
     it 'is expected to be initialized without reaction' do
@@ -30,7 +34,25 @@ RSpec.describe WorkerKiller::Middleware do
       expect(killer).to receive(:kill).with(Time).twice
 
       4.times do
-        subject.call({})
+        subject.call(env)
+      end
+    end
+
+
+    describe 'inhibitions' do
+      let(:env) { { 'PATH_INFO' => '/attachments' } }
+
+      it 'is expected to use inhibitions' do
+        expect(WorkerKiller::CountLimiter).to receive(:new).with(min: 3, max: 3).and_call_original
+        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
+
+        4.times do
+          subject.call(env)
+        end
       end
     end
 
@@ -44,36 +66,38 @@ RSpec.describe WorkerKiller::Middleware do
       expect(reaction).to receive(:call).with(subject.limiter, killer).twice
 
       4.times do
-        subject.call({})
+        subject.call(env)
       end
     end
   end
 
   describe WorkerKiller::Middleware::OOMLimiter do
-    let(:options){ { killer: killer, min: 2222, max: 2223 } }
+    let(:options){ { killer: killer, min: 2222, max: 2223, inhibitions: inhibitions } }
     subject{ described_class.new(app, **options) }
 
     it 'is expected to be initialized without reaction' do
-      expect(WorkerKiller::MemoryLimiter).to receive(:new).with(min: 2222, max: 2223).and_call_original
+      expect(WorkerKiller::MemoryLimiter).to receive(:new).with(min: 2222,
+                                                                max: 2223).and_call_original
       expect(subject.limiter).to be_an(WorkerKiller::MemoryLimiter)
       expect(subject.limiter.min).to eq(2222)
       expect(subject.limiter.max).to eq(2223)
       expect(killer).to receive(:kill).with(subject.limiter.started_at).once
       expect(subject.limiter).to receive(:check).and_return(true)
 
-      subject.call({})
+      subject.call(env)
     end
 
     it 'is expected to be initialized with reaction' do
       options[:reaction] = reaction
-      expect(WorkerKiller::MemoryLimiter).to receive(:new).with(min: 2222, max: 2223).and_call_original
+      expect(WorkerKiller::MemoryLimiter).to receive(:new).with(min: 2222,
+                                                                max: 2223).and_call_original
       expect(subject.limiter).to be_an(WorkerKiller::MemoryLimiter)
       expect(subject.limiter.min).to eq(2222)
       expect(subject.limiter.max).to eq(2223)
       expect(reaction).to receive(:call).with(subject.limiter, killer)
       expect(subject.limiter).to receive(:check).and_return(true)
 
-      subject.call({})
+      subject.call(env)
     end
   end
 end

data/spec/puma_plugin_ng_spec.rb

@@ -0,0 +1,65 @@
+RSpec.describe WorkerKiller::PumaPluginNg do
+  subject(:plugin){ described_class.send(:new) }
+  let(:dsl) { double }
+  let(:runner){ double }
+  let(:events) { double }
+  let(:launcher){ double('@runner' => runner, 'events' => events, log_writer: double(log: nil)) }
+  let(:worker){ double('booted?' => true, 'term?' => false) }
+
+  it {
+    is_expected.to have_attributes(killer:     ::WorkerKiller::Killer::Puma,
+                                   inhibited:  Hash,
+                                   kill_queue: Set)
+  }
+
+  context 'Puma initialization' do
+    it 'expected to register CB' do
+      expect(dsl).to receive(:before_worker_boot).and_yield(123)
+      expect(dsl).to receive(:out_of_band).and_yield
+      plugin.config(dsl)
+    end
+
+    it do
+      expect(plugin).to receive(:set_logger!).and_call_original
+      plugin.start(launcher)
+    end
+  end
+
+  context '#request_restart_server' do
+    it do
+      plugin.instance_variable_set('@worker_num', 99)
+      expect { plugin.request_restart_server(99) }.to change { plugin.kill_queue }.to([99])
+    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()
+      Thread.current.puma_server = puma_server
+      expect(puma_server).to receive(:begin_restart)
+
+      plugin.do_kill('test')
+    end
+  end
+end
+

data/spec/puma_plugin_spec.rb

@@ -1,9 +1,9 @@
 RSpec.describe WorkerKiller::PumaPlugin do
   subject(:plugin){ described_class.instance }
-  let(:puma) { double }
+  let(:dsl) { double }
   let(:runner){ double }
   let(:events) { double }
-  let(:launcher){ double('@runner' => runner, 'events' => events) }
+  let(:launcher){ double('@runner' => runner, 'events' => events, log_writer: double(log: nil)) }
   let(:worker){ double('booted?' => true, 'term?' => false) }
 
   it {
@@ -11,10 +11,17 @@ RSpec.describe WorkerKiller::PumaPlugin do
                                    killer:   ::WorkerKiller::Killer::Puma)
   }
 
+
   context 'Puma initialization' do
+    it 'expected to register CB' do
+      expect(dsl).to receive(:before_worker_boot).and_yield(123)
+      plugin.config(dsl)
+    end
+
     it do
-      expect(puma).to receive(:on_worker_boot)
-      plugin.config(puma)
+      expect(plugin).to receive(:set_logger!).and_call_original
+      expect(events).to receive(:on_booted)
+      plugin.start(launcher)
     end
 
     it do
@@ -30,5 +37,40 @@ RSpec.describe WorkerKiller::PumaPlugin do
       plugin.thread.join
     end
   end
+
+  context 'expect right signal order' do
+    let(:config) do
+      WorkerKiller::Configuration.new.tap do |c|
+        c.quit_attempts = 2
+        c.term_attempts = 2
+      end
+    end
+
+    let(:killer){ ::WorkerKiller::Killer::Puma.new(puma_plugin: plugin, worker_num: 99) }
+    let(:buffer) { StringIO.new }
+
+    around do |example|
+      prev = WorkerKiller.configuration
+      WorkerKiller.configuration = config
+      example.run
+    ensure
+      WorkerKiller.configuration = prev
+     end
+
+
+    it 'expect right signal order' do
+      expect(Socket).to receive(:unix).with(/puma_worker_.*socket/).and_yield(buffer).exactly(3).times
+      expect(Process).not_to receive(:kill)
+
+      killer.kill(Time.now)
+      expect(buffer.string.strip).to eq(99.to_s)
+
+      1.times { killer.kill(Time.now) } # 1 QUIT
+      2.times { killer.kill(Time.now) } # 1 TERM
+      5.times { killer.kill(Time.now) } # 5 KILL
+    end
+  end
+
+  
 end
 

data/spec/spec_helper.rb

@@ -31,6 +31,7 @@ SimpleCov.start
 require 'worker_killer'
 require 'worker_killer/delayed_job_plugin'
 require 'worker_killer/puma_plugin'
+require 'worker_killer/puma_plugin_ng'
 
 $root = File.join(File.dirname(__dir__), 'spec')
 Dir[File.join(__dir__, 'support', '**', '*.rb')].sort.each {|f| require f }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: worker_killer
 version: !ruby/object:Gem::Version
-  version: 1.1.0.214159
+  version: 1.2.0.338563
 platform: ruby
 authors:
 - Samoilenko Yuri
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-26 00:00:00.000000000 Z
+date: 2025-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: get_process_mem
@@ -136,7 +136,9 @@ files:
 - lib/worker_killer/memory_limiter.rb
 - lib/worker_killer/middleware.rb
 - lib/worker_killer/puma/plugin/worker_killer.rb
+- lib/worker_killer/puma/plugin/worker_killer_ng.rb
 - lib/worker_killer/puma_plugin.rb
+- lib/worker_killer/puma_plugin_ng.rb
 - lib/worker_killer/version.rb
 - spec/count_limiter_spec.rb
 - spec/delayed_job_plugin/jobs_limiter_spec.rb
@@ -148,6 +150,7 @@ files:
 - spec/killer_spec.rb
 - spec/memory_limiter_spec.rb
 - spec/middleware_spec.rb
+- spec/puma_plugin_ng_spec.rb
 - spec/puma_plugin_spec.rb
 - spec/spec_helper.rb
 - spec/support/logger.rb
@@ -156,7 +159,7 @@ homepage: https://github.com/RnD-Soft/worker_killer
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -171,22 +174,23 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.2.33
+signing_key:
 specification_version: 4
 summary: Kill any workers by memory and request counts or take custom reaction
 test_files:
-- spec/killer/signal_spec.rb
-- spec/killer/puma_spec.rb
+- spec/count_limiter_spec.rb
+- spec/delayed_job_plugin/jobs_limiter_spec.rb
+- spec/delayed_job_plugin/oom_limiter_spec.rb
 - spec/killer/delayed_job_spec.rb
 - spec/killer/passenger_spec.rb
-- spec/puma_plugin_spec.rb
+- spec/killer/puma_spec.rb
+- spec/killer/signal_spec.rb
 - spec/killer_spec.rb
-- spec/count_limiter_spec.rb
-- spec/worker_killer_spec.rb
-- spec/support/logger.rb
+- spec/memory_limiter_spec.rb
 - spec/middleware_spec.rb
+- spec/puma_plugin_ng_spec.rb
+- spec/puma_plugin_spec.rb
 - spec/spec_helper.rb
-- spec/delayed_job_plugin/oom_limiter_spec.rb
-- spec/delayed_job_plugin/jobs_limiter_spec.rb
-- spec/memory_limiter_spec.rb
+- spec/support/logger.rb
+- spec/worker_killer_spec.rb