worker_killer 1.0.5.213889 → 1.1.0.214146

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d0558051a55e944e97bb26729239a97d7f150fb37885af8761246f78db4e280
-  data.tar.gz: 417bb8c4f0c4818d4e2a19ad4f2cb8cc5e3ca82621b925c81c2e4b33102803fb
+  metadata.gz: eabc2f6b314a0e9a0e81a078ac3954c5355e24017373fad26f4de4fbeea2f00f
+  data.tar.gz: deb1ebcf899be03574b4611aee0b3f8e08f4c6f57e5babddeaa2bc5d20f70ed7
 SHA512:
-  metadata.gz: 855f6852cb2c7c8115388038f07d234958a6183c008d21b28ad8867a34a53dcfd713f34645c1b0f435fafc67f5f7ad0c1272b7b4f94f2d91b170ca91c0f97133
-  data.tar.gz: 8699bc63da513186e47cb1ef626f732e61cfe7a603231370223cbcea5ec3b6d8897a314ed5fe8dee9a23765822b4c20aa43ddc6fda7b02bb775f01aa1f838a7e
+  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

@@ -1,29 +1,28 @@
+require 'socket'
+
 module ::WorkerKiller
   module Killer
     class Puma < ::WorkerKiller::Killer::Base
 
-      def initialize **kwrags
-        super
+      attr_accessor :ipc_path, :worker_num
+
+      def initialize(ipc_path:, worker_num: nil, **kwargs)
+        super(**kwargs)
+        @ipc_path = ipc_path
+        @worker_num = worker_num
       end
 
       def do_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})"
+          logger.error "#{self} force to kill self[#{worker_num}] (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
+        logger.warn "#{self} send #{worker_num} to Puma Plugin (pid: #{pid}) alive: #{alive_sec} sec (trial #{kill_attempts})"
 
-        Thread.new(cmd) do |command|
-          unless Kernel.system(command)
-            logger.warn "#{self} run #{command.inspect} failed: #{$?.inspect}"
-          end
+        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

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

data/lib/worker_killer/puma_plugin.rb

@@ -0,0 +1,80 @@
+require 'singleton'
+
+require 'worker_killer/memory_limiter'
+require 'worker_killer/count_limiter'
+
+
+module WorkerKiller
+  class PumaPlugin
+
+    include Singleton
+
+    attr_accessor :ipc_path, :killer, :thread
+
+    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 config(puma)
+      puma.on_worker_boot do |num|
+        log "Set worker_num: #{num}"
+        @killer.worker_num = num
+      end
+    end
+
+    def start(launcher)
+      @runner = launcher.instance_variable_get('@runner')
+
+      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
+
+    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}[#{Process.pid}]: #{msg}")
+    end
+
+  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.213889
+  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
@@ -135,6 +135,8 @@ files:
 - lib/worker_killer/killer/signal.rb
 - lib/worker_killer/memory_limiter.rb
 - lib/worker_killer/middleware.rb
+- lib/worker_killer/puma/plugin/worker_killer.rb
+- lib/worker_killer/puma_plugin.rb
 - lib/worker_killer/version.rb
 - spec/count_limiter_spec.rb
 - spec/delayed_job_plugin/jobs_limiter_spec.rb
@@ -146,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
@@ -173,16 +176,17 @@ 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/killer/delayed_job_spec.rb
-- spec/killer/passenger_spec.rb
-- spec/killer_spec.rb
-- spec/count_limiter_spec.rb
-- spec/worker_killer_spec.rb
-- spec/support/logger.rb
 - 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
+- spec/killer/puma_spec.rb
+- spec/killer/signal_spec.rb
+- spec/killer/delayed_job_spec.rb
 - spec/memory_limiter_spec.rb
+- spec/support/logger.rb
+- spec/worker_killer_spec.rb
+- spec/count_limiter_spec.rb