worker_killer 1.0.5.213977 → 1.1.0.214146

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ac9af870733f50ff006c5a31d9c3030342d76ff3208b8e4193a2407ad8f264c
-  data.tar.gz: c222a1cada623f95f8668e61d15e4f32fa986fdf799572e1937365919bc651d4
+  metadata.gz: eabc2f6b314a0e9a0e81a078ac3954c5355e24017373fad26f4de4fbeea2f00f
+  data.tar.gz: deb1ebcf899be03574b4611aee0b3f8e08f4c6f57e5babddeaa2bc5d20f70ed7
 SHA512:
-  metadata.gz: 88918e5de623c64691e96fbfc4f34b6eb19669e3f370be011eed996ef6e9a13aee61997b66adfae929e39cb685396557c3802d9a00dcb0ebef0d54e5cf1193fb
-  data.tar.gz: bdb4e2fafb1da70554c3b73284538695bfd918b1b516a9a24f477b02056d721b69745f4ecfe6bfde044fb90815fa55f7178c08c33d9cfd283420754d0175ee69
+  metadata.gz: 80da7063d7ab1d3ce70baf42414e7dc6aea1310d85285cc10c95c9a09d980b0b8db98438985ffe422e82b20c4aab73ea05c717924dac47442c4aed1f257a1fae
+  data.tar.gz: 0e40fd946bb0a0f5e4cdb36e469738c195c555e4495e379f943a90fb336166f4f56e09a7a60ffafea782a597979db79d21123ded769c4412843d8f05397aa12d

data/README.md

@@ -17,7 +17,7 @@ Features:
 
 - generic middleware implementation
 - Phusion Passenger support(through `passenger-config detach-process <PID>`)
-- Puma phased-restart support(through `pumactl phased-restart`)
+- Puma support through native plugin
 - DelayedJob support
 - custom reaction hook
 
@@ -82,33 +82,26 @@ Add these lines to your `puma.rb` AND `application.rb`.
 ```ruby
   # puma.rb
 
-  on_worker_boot do |*args|
-    require 'worker_killer/killer'
-    require 'active_support/notifications'
-
-    ::ActiveSupport::Notifications.subscribe 'initialize.custom.rails' do |*eargs|
-      event = ActiveSupport::Notifications::Event.new(*eargs)
-      config = event.payload[:config]
-
-      killer = ::WorkerKiller::Killer::Puma.new
-      config.middleware.insert_before(
-        ::Rack::Runtime,
-        ::WorkerKiller::Middleware::RequestsLimiter, killer: killer, min: 3072, max: 4096
-      )
-
-      config.middleware.insert_before(
-        ::Rack::Runtime,
-        ::WorkerKiller::Middleware::OOMLimiter, killer: killer, min: nil, max: 0.5, verbose: true, check_cycle: 16
-      )
-    end
-  end
+  require 'worker_killer/puma/plugin/worker_killer'
+  plugin('worker_killer')
 
   # application.rb
+  if defined?(::Puma::Client)
+    killer = ::WorkerKiller::PumaPlugin.instance.killer
+
+    config.middleware.insert_before(
+      Rack::Runtime,
+      WorkerKiller::Middleware::OOMLimiter, killer: killer, min: nil, max: 0.5, verbose: false, check_cycle: 16
+    )
 
-  ActiveSupport::Notifications.instrument 'initialize.custom.rails', config: config
+    config.middleware.insert_before(
+      Rack::Runtime,
+      WorkerKiller::Middleware::RequestsLimiter, killer: killer, min: 3000, max: 4000, verbose: false
+    )
+  end
 ```
 
-This gem provides two modules: WorkerKiller::CountLimiter and WorkerKiller::MemoryLimiter, some Rack integration and DelayedJob plugin.
+This gem provides two modules: WorkerKiller::CountLimiter and WorkerKiller::MemoryLimiter, some Rack integration, DelayedJob plugin and Puma plugin.
 
 ### WorkerKiller::Middleware::RequestsLimiter and WorkerKiller::DelayedJobPlugin::JobsLimiter
 
@@ -128,6 +121,29 @@ The memory size check is done in every `check_cycle` requests.
 
 If `verbose` is set to true, then every memory size check will be shown in your logs. This logging is done at the `info` level.
 
+### WorkerKiller::PumaPlugin
+
+Works in Puma `Cluster Mode`. Work correctly with `phased-restart` and `fork_workers`, but has maximum effectivity (memory usage) in simple `Cluster Mode` with **preload_app!**.
+
+Example production config: 
+
+```ruby
+  port ENV.fetch('PUMA_PORT', 3000).to_i
+
+  environment ENV.fetch('RAILS_ENV', 'development')
+
+  pidfile ENV.fetch('PUMA_PIDFILE', 'tmp/pids/server.pid')
+
+  threads ENV.fetch('PUMA_THREADS', 4).to_i
+
+  workers ENV.fetch('PUMA_WORKERS', 3).to_i
+
+  require 'worker_killer/puma/plugin/worker_killer'
+  plugin('worker_killer')
+
+  preload_app!
+```
+
 # Special Thanks
 
 - [@hotchpotch](http://github.com/hotchpotch/) for the [original idea](https://gist.github.com/hotchpotch/1258681)

data/lib/worker_killer/count_limiter.rb

@@ -6,13 +6,19 @@ module WorkerKiller
     def initialize(min: 3072, max: 4096, verbose: false)
       @min = min
       @max = max
-      @limit = @min + WorkerKiller.randomize(@max - @min + 1)
-      @left = @limit
+      @limit = nil
+      @left = nil
       @verbose = verbose
     end
 
     def check
-      return nil if @limit <= 1
+      # initialize limits on first check
+      if @limit.nil?
+        @limit = min + WorkerKiller.randomize(max - min + 1)
+        @left = @limit
+      end
+
+      return nil if @limit < 1
 
       @started_at ||= Time.now
 

data/lib/worker_killer/delayed_job_plugin.rb

@@ -23,10 +23,10 @@ module WorkerKiller
 
     def configure_lifecycle(lifecycle)
       # Count condition after every job
-      lifecycle.after(:perform) do |worker, *_args|
+      lifecycle.after(:perform) do |_worker, *_args|
         @time_to_burn ||= limiter.check
       end
-      
+
       # Stop execution only after whole loop completed
       lifecycle.after(:loop) do |worker, *_args|
         @time_to_burn ||= limiter.check

data/lib/worker_killer/killer/passenger.rb

@@ -42,7 +42,7 @@ module WorkerKiller
       end
 
       def self.check_passenger_config! path
-        if path = check_passenger_config(path)
+        if (path = check_passenger_config(path))
           path
         else
           raise "Can't find passenger config at #{path.inspect}"

data/lib/worker_killer/killer/puma.rb

@@ -4,55 +4,25 @@ module ::WorkerKiller
   module Killer
     class Puma < ::WorkerKiller::Killer::Base
 
-      attr_accessor :type, :plugin_path, :num
+      attr_accessor :ipc_path, :worker_num
 
-      def initialize(type: :phased, path: nil, num: nil, **kwargs)
+      def initialize(ipc_path:, worker_num: nil, **kwargs)
         super(**kwargs)
-        @type = type
-        @plugin_path = path
-        @num = num
+        @ipc_path = ipc_path
+        @worker_num = worker_num
       end
 
-      def do_kill(sig, pid, alive_sec, **params)
-        if @type == :phased
-          do_phased_kill(sig, pid, alive_sec, **params)
-        elsif @type == :plugin
-          do_plugin_kill(sig, pid, alive_sec, **params)
-        end
-      end
-
-      def do_phased_kill(sig, pid, alive_sec, **_params)
-        cmd = 'pumactl phased-restart'
-
-        if sig == :KILL
-          logger.error "#{self} force to kill self (pid: #{pid}) alive: #{alive_sec} sec (trial #{kill_attempts})"
-          Process.kill sig, pid
-          return
-        end
-
-        return if @already_detached
-
-        logger.warn "#{self} run #{cmd.inspect} (pid: #{pid}) alive: #{alive_sec} sec (trial #{kill_attempts})"
-        @already_detached = true
-
-        Thread.new(cmd) do |command|
-          unless Kernel.system(command)
-            logger.warn "#{self} run #{command.inspect} failed: #{$?.inspect}"
-          end
-        end
-      end
-
-      def do_plugin_kill(sig, pid, alive_sec, **_params)
+      def do_kill(sig, pid, alive_sec, **_params)
         if sig == :KILL
-          logger.error "#{self} force to kill self (pid: #{pid}) alive: #{alive_sec} sec (trial #{kill_attempts})"
+          logger.error "#{self} force to kill self[#{worker_num}] (pid: #{pid}) alive: #{alive_sec} sec (trial #{kill_attempts})"
           Process.kill sig, pid
           return
         end
 
-        logger.warn "#{self} send #{num} to Puma Plugin (pid: #{pid}) alive: #{alive_sec} sec (trial #{kill_attempts})"
+        logger.warn "#{self} send #{worker_num} to Puma Plugin (pid: #{pid}) alive: #{alive_sec} sec (trial #{kill_attempts})"
 
-        Socket.unix(plugin_path) do |sock|
-          sock.puts num.to_s
+        Socket.unix(ipc_path) do |sock|
+          sock.puts Integer(worker_num).to_s
         end
       end
 

data/lib/worker_killer/killer.rb

@@ -2,7 +2,7 @@ module WorkerKiller
   module Killer
     class Base
 
-      attr_accessor :config, :kill_attempts, :logger
+      attr_accessor :config, :kill_attempts
 
       def initialize(logger: nil, **_kwargs)
         @logger = logger
@@ -27,7 +27,7 @@ module WorkerKiller
         raise 'Not Implemented'
       end
       # :nocov:
-      
+
       def logger
         @logger || WorkerKiller.configuration.logger
       end

data/lib/worker_killer/memory_limiter.rb

@@ -10,8 +10,6 @@ module WorkerKiller
         # set static memory limits
         @min = min
         @max = max
-        @limit = @min + WorkerKiller.randomize(@max - @min + 1)
-        @limit_mb = (@limit / 1024 / 1024).round(1)
       else
         # prepare for relative memory limits
         @max_percent = max
@@ -26,11 +24,19 @@ module WorkerKiller
       @started_at ||= Time.now
       @check_count += 1
 
+
       return nil if (@check_count % @check_cycle) != 0
 
       rss = GetProcessMem.new.bytes
+
       # initialize relative memory limits on first check
-      set_limits(rss, rss + rss * @max_percent) if min.nil?
+      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
 
       do_check(rss)
     end
@@ -52,7 +58,8 @@ module WorkerKiller
 
     def set_limits(min, max)
       @min = min
-      @limit = @max = max
+      @limit = max
+      @max ||= max
       @limit_mb = (@limit / 1024 / 1024).round(1)
     end
 

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

@@ -1,104 +1,13 @@
-require 'socket'
-require 'puma/plugin'
-require 'active_support/notifications'
-
-require 'worker_killer/killer'
-
-
-
-
-module WorkerKiller
-  module Puma
-    module Plugin
-      # Puma requires such plugin name and path :(
-      class WorkerKiller
-
-        def initialize(launcher, path)
-          @runner = launcher.instance_variable_get('@runner')
-
-          @thread = Thread.new do
-            Socket.unix_server_loop(path) do |sock, _client_addrinfo|
-              if (line = sock.gets)
-                worker_num = Integer(line.strip)
-                if (worker = find_worker(worker_num))
-                  log "Killing worker #{worker_num}"
-                  worker.term!
-                end
-              end
-            rescue StandardError => e
-              log("Exception: #{e.inspect}")
-            ensure
-              sock.close
-            end
-          end
-        end
-
-        def find_worker(worker_num)
-          worker = @runner.worker_at(worker_num)
-          unless worker
-            log "Unknown worker index: #{worker_num.inspect}. Skipping."
-            return nil
-          end
-
-          unless worker.booted?
-            log "Worker #{worker_num.inspect} is not booted yet. Skipping."
-            return nil
-          end
-
-          if worker.term?
-            log "Worker #{worker_num.inspect} already terminating. Skipping."
-            return nil
-          end
-
-          worker
-        end
-
-        def log(msg)
-          warn("#{self.class}: #{msg}")
-        end
-
-      end
-    end
-  end
-end
+require 'worker_killer'
+require 'worker_killer/puma_plugin'
 
 Puma::Plugin.create do
-  attr_reader :path
-
-  def config(c)
-    c.on_worker_boot do |num|
-
-      if @killer
-        puts "ON OTHER WORKER BOOT: #{num}"
-        @killer.num = num
-      else
-        puts "ON MAIN WORKER BOOT: #{num}"
-        ::ActiveSupport::Notifications.subscribe 'worker_killer.initialize' do |*eargs|
-          @killer = ::WorkerKiller::Killer::Puma.new(num: num, path: path, type: :plugin)
-          puts "ON WORKER BOOT INIT:#{num}"
-          event = ActiveSupport::Notifications::Event.new(*eargs)
-          config = event.payload[:config]
-
-          @register_killer&.call(self, config, @killer)
-        end
-      end
-    end
+  def config(cfg)
+    ::WorkerKiller::PumaPlugin.instance.config(cfg)
   end
 
   def start(launcher)
-    @path = File.join('tmp', "puma_worker_killer_#{Process.pid}.socket")
-
-    launcher.events.on_booted do
-      @controller ||= WorkerKiller::Puma::Plugin::WorkerKiller.new(launcher, path)
-    end
-  end
-
-  def configure(&block)
-    self.instance_eval(&block)
-  end
-
-  def register_killer(&block)
-    @register_killer = block
+    ::WorkerKiller::PumaPlugin.instance.start(launcher)
   end
 end
 

data/lib/worker_killer/puma_plugin.rb

@@ -1,56 +1,78 @@
+require 'singleton'
+
 require 'worker_killer/memory_limiter'
 require 'worker_killer/count_limiter'
-require 'puma/plugin'
 
-Puma::Plugin.create do
 
 module WorkerKiller
   class PumaPlugin
 
-    attr_reader :limiter, :killer, :reaction
-
-    def initialize(klass:, killer:, reaction: nil, **opts)
-      @killer = killer
+    include Singleton
 
-      @reaction = reaction || proc do |l, k, dj|
-        k.kill(l.started_at, dj: dj)
-      end
+    attr_accessor :ipc_path, :killer, :thread
 
-      @limiter = klass.new(**opts)
-      @time_to_burn = false
+    def initialize
+      @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 new(lifecycle = Delayed::Worker.lifecycle, *_args)
-      configure_lifecycle(lifecycle)
-    end
-
-    def configure_lifecycle(lifecycle)
-      # Count condition after every job
-      lifecycle.after(:perform) do |worker, *_args|
-        @time_to_burn ||= limiter.check
-      end
-      
-      # Stop execution only after whole loop completed
-      lifecycle.after(:loop) do |worker, *_args|
-        @time_to_burn ||= limiter.check
-        reaction.call(limiter, killer, worker) if @time_to_burn
+    def config(puma)
+      puma.on_worker_boot do |num|
+        log "Set worker_num: #{num}"
+        @killer.worker_num = num
       end
     end
 
-    class JobsLimiter < ::WorkerKiller::PumaPlugin
+    def start(launcher)
+      @runner = launcher.instance_variable_get('@runner')
 
-      def initialize(**opts)
-        super(klass: ::WorkerKiller::CountLimiter, **opts)
+      launcher.events.on_booted do
+        @thread ||= start_ipc_listener
       end
+    end
 
+    def start_ipc_listener
+      log 'Start IPC listener'
+      Thread.new do
+        Socket.unix_server_loop(ipc_path) do |sock, *args|
+          if (line = sock.gets)
+            worker_num = Integer(line.strip)
+            if (worker = find_worker(worker_num))
+              log "Killing worker #{worker_num}"
+              worker.term!
+            end
+          end
+        rescue StandardError => e
+          log("Exception: #{e.inspect}")
+        ensure
+          sock.close
+        end
+      end
     end
 
-    class OOMLimiter < ::WorkerKiller::PumaPlugin
+    def find_worker(worker_num)
+      worker = @runner.worker_at(worker_num)
+      unless worker
+        log "Unknown worker index: #{worker_num.inspect}. Skipping."
+        return nil
+      end
+
+      unless worker.booted?
+        log "Worker #{worker_num.inspect} is not booted yet. Skipping."
+        return nil
+      end
 
-      def initialize(**opts)
-        super(klass: ::WorkerKiller::MemoryLimiter, **opts)
+      if worker.term?
+        log "Worker #{worker_num.inspect} already terminating. Skipping."
+        return nil
       end
 
+      worker
+    end
+
+    def log(msg)
+      warn("#{self.class}[#{Process.pid}]: #{msg}")
     end
 
   end

data/lib/worker_killer/version.rb

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

data/spec/count_limiter_spec.rb

@@ -4,21 +4,30 @@ RSpec.describe WorkerKiller::CountLimiter do
   let(:max){ min + rand(100) }
   let(:options){ { min: min, max: max, verbose: true } }
 
-  it { is_expected.to have_attributes(min: min, max: max, limit: a_value_between(min, max), left: subject.limit) }
+  it { is_expected.to have_attributes(min: min, max: max, limit: nil, left: nil) }
 
-  it 'expect not to react while less than limit' do
-    (subject.limit - 1).times do
-      expect(subject.check).to be_falsey
-    end
-  end
+  context 'initialize limits after first check' do
+    before { subject.check }
+
+    it {
+      is_expected.to have_attributes(min: min, max: max,
+                                     limit: a_value_between(min, max), left: subject.limit - 1)
+    }
 
-  it 'expect call reaction when check succeded' do
-    (subject.limit - 1).times do
-      expect(subject.check).to be_falsey
+    it 'expect not to react while less than limit' do
+      (subject.limit - 2).times do
+        expect(subject.check).to be_falsey
+      end
     end
 
-    expect(subject.check).to be_truthy
-    expect(subject.check).to be_truthy
+    it 'expect call reaction when check succeded' do
+      (subject.limit - 2).times do
+        expect(subject.check).to be_falsey
+      end
+
+      expect(subject.check).to be_truthy
+      expect(subject.check).to be_truthy
+    end
   end
 end
 

data/spec/killer/puma_spec.rb

@@ -6,7 +6,9 @@ RSpec.describe WorkerKiller::Killer::Puma do
     end
   end
 
-  let(:killer){ described_class.new }
+  let(:ipc_path) { '/tmp/test_ipx.sock' }
+  let(:killer){ described_class.new(ipc_path: ipc_path, worker_num: 99) }
+  let(:buffer) { StringIO.new }
 
   describe '#kill' do
     around do |example|
@@ -18,11 +20,11 @@ RSpec.describe WorkerKiller::Killer::Puma do
     end
 
     it 'expect right signal order' do
-      expect(Kernel).to receive(:system).with('pumactl phased-restart').and_return(true)
+      expect(Socket).to receive(:unix).with(ipc_path).and_yield(buffer).exactly(4).times
       expect(Process).to receive(:kill).with(:KILL, anything).exactly(5).times
 
-      thread = killer.kill(Time.now)
-      thread.join
+      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

data/spec/memory_limiter_spec.rb

@@ -22,7 +22,7 @@ RSpec.describe WorkerKiller::MemoryLimiter do
     let(:min){ rand(50..100) * mb }
     let(:max){ min + rand(100) * mb }
 
-    it { is_expected.to have_attributes(min: min, max: max, limit: a_value_between(min, max)) }
+    it { is_expected.to have_attributes(min: min, max: max, limit: nil) }
 
     it 'expect to skip check while less than cycle count' do
       expect(GetProcessMem).not_to receive(:new)
@@ -30,6 +30,15 @@ RSpec.describe WorkerKiller::MemoryLimiter do
       skip_cycles(subject, check_cycle)
     end
 
+    it 'expect to initialize limits after cycle count' do
+      expect(memory).to receive(:bytes).and_return(min)
+      is_expected.to have_attributes(min: min, max: max, limit: nil)
+
+      skip_cycles(subject, check_cycle)
+      subject.check
+      is_expected.to have_attributes(min: min, max: max, limit: a_value_between(min, max))
+    end
+
     it 'expect to skip check after cycle count reached' do
       expect(memory).to receive(:bytes).and_return(min - 1)
 
@@ -38,8 +47,12 @@ RSpec.describe WorkerKiller::MemoryLimiter do
     end
 
     it 'expect call reaction when check succeded' do
-      expect(memory).to receive(:bytes).and_return(subject.limit + 1)
+      expect(memory).to receive(:bytes).and_return(min)
+
+      skip_cycles(subject, check_cycle)
+      subject.check
 
+      expect(memory).to receive(:bytes).and_return(subject.limit + 1)
       skip_cycles(subject, check_cycle)
       expect(subject.check).to be_truthy
     end

data/spec/puma_plugin_spec.rb

@@ -0,0 +1,34 @@
+RSpec.describe WorkerKiller::PumaPlugin do
+  subject(:plugin){ described_class.instance }
+  let(:puma) { double }
+  let(:runner){ double }
+  let(:events) { double }
+  let(:launcher){ double('@runner' => runner, 'events' => events) }
+  let(:worker){ double('booted?' => true, 'term?' => false) }
+
+  it {
+    is_expected.to have_attributes(ipc_path: /puma_worker_.*socket/,
+                                   killer:   ::WorkerKiller::Killer::Puma)
+  }
+
+  context 'Puma initialization' do
+    it do
+      expect(puma).to receive(:on_worker_boot)
+      plugin.config(puma)
+    end
+
+    it do
+      launcher.instance_variable_set('@runner', runner)
+
+      expect(Socket).to receive(:unix_server_loop).with(/puma_worker_.*socket/).and_yield(StringIO.new('99'))
+      expect(events).to receive(:on_booted).and_yield
+      expect(runner).to receive(:worker_at).with(99).and_return(worker)
+      expect(plugin).to receive(:find_worker).with(99).and_call_original
+      expect(worker).to receive(:term!)
+
+      plugin.start(launcher)
+      plugin.thread.join
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -30,6 +30,7 @@ SimpleCov.start
 
 require 'worker_killer'
 require 'worker_killer/delayed_job_plugin'
+require 'worker_killer/puma_plugin'
 
 $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.0.5.213977
+  version: 1.1.0.214146
 platform: ruby
 authors:
 - Samoilenko Yuri
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-02-22 00:00:00.000000000 Z
+date: 2024-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: get_process_mem
@@ -148,6 +148,7 @@ files:
 - spec/killer_spec.rb
 - spec/memory_limiter_spec.rb
 - spec/middleware_spec.rb
+- spec/puma_plugin_spec.rb
 - spec/spec_helper.rb
 - spec/support/logger.rb
 - spec/worker_killer_spec.rb
@@ -178,6 +179,7 @@ test_files:
 - spec/middleware_spec.rb
 - spec/killer_spec.rb
 - spec/spec_helper.rb
+- spec/puma_plugin_spec.rb
 - spec/delayed_job_plugin/oom_limiter_spec.rb
 - spec/delayed_job_plugin/jobs_limiter_spec.rb
 - spec/killer/passenger_spec.rb