worker_killer 0.1.0.19841 → 0.1.1.39838

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a4f8d758bb16cf1e884b1d1fc6964a6f5ad2a2692d8417219b1d033c7aaad27c
-  data.tar.gz: e5446b1e1752e854d5aad4e89952da86f66367c91f9a025b22da02f38b2a7622
+  metadata.gz: 92604c2f0b3b1fbd27a647f8c72556abbd2c6a38d3e57a120697118db1921b44
+  data.tar.gz: e22fb98b3d5dd0781e79eaba94213e7cca03c728f0f64ab0fe391b4f536de850
 SHA512:
-  metadata.gz: 8e3619486be2275fef2f14de93829efc4b70bb9befa0e848a3040debb27be6e9945c8e542dd5f74e172166fa4af57323f6ad5bed0e36eb8a2c239e7c983af0ee
-  data.tar.gz: 7a8470831118f1bbb7f56bb0b04ee1cd4a87ad2d31682558eadd3ff4d02da9387a9fe26c4902bf51e0a4caa475e9ec58c95dae2445ca7fff5160e19fd2bde020
+  metadata.gz: acabb632791e185856f983c44b3f7ae151e5798508e846c669b8699ec6bf06bd435c6a4a9fe551e94033e5a577ab252a8a3aaaffb09733ee52a27422faf0de0a
+  data.tar.gz: 253ae056f4b4d107458a85a897c3ad16a6ec532282bf7e9781fed06cfde943f177b23c6c3f96c3c513fe6f4a01ed92604c84eaca31bc64dca05ccfe2ba9c902e

data/README.md

@@ -1,13 +1,23 @@
 # worker-killer
 
-Kill any workers by memory and request counts or take custom reaction. Inspired by [unicorn-worker-killer](https://github.com/kzk/unicorn-worker-killer).
+[![Gem Version](https://badge.fury.io/rb/worker_killer.svg)](https://rubygems.org/gems/worker_killer)
+[![Gem](https://img.shields.io/gem/dt/worker_killer.svg)](https://rubygems.org/gems/worker_killer/versions)
+[![YARD](https://badgen.net/badge/YARD/doc/blue)](http://www.rubydoc.info/gems/worker_killer)
+
+[![Coverage](https://lysander.x.rnds.pro/api/v1/badges/wkiller_coverage.svg)](https://lysander.x.rnds.pro/api/v1/badges/wkiller_coverage.html)
+[![Quality](https://lysander.x.rnds.pro/api/v1/badges/wkiller_quality.svg)](https://lysander.x.rnds.pro/api/v1/badges/wkiller_quality.html)
+[![Outdated](https://lysander.x.rnds.pro/api/v1/badges/wkiller_outdated.svg)](https://lysander.x.rnds.pro/api/v1/badges/wkiller_outdated.html)
+[![Vulnerabilities](https://lysander.x.rnds.pro/api/v1/badges/wkiller_vulnerable.svg)](https://lysander.x.rnds.pro/api/v1/badges/wkiller_vulnerable.html)
+
+Kill any workers by memory and/or request counts or take custom reaction. Inspired by [unicorn-worker-killer](https://github.com/kzk/unicorn-worker-killer).
 
 `worker-killer` gem provides automatic restart of Web-server based on 1) max number of requests, and 2) process memory size (RSS). This will greatly improves site's stability by avoiding unexpected memory exhaustion at the application nodes.
 
 Features:
 
 * generic middleware implementation
-* custom reactin hook
+* Phusion Passenger support(through `passenger-config detach-process <PID>`)
+* custom reaction hook
 
 Planned:
 
@@ -39,7 +49,7 @@ This gem provides two modules: WorkerKiller::CountLimiter and WorkerKiller::Memo
 
 ### WorkerKiller::Middleware::RequestsLimiter
 
-This module automatically restarts the kill workers, based on the number of requests which worker processed.
+This module automatically restarts/kills the workers, based on the number of requests which worker processed.
 
 `min` and `max` specify the min and max of maximum requests per worker. The actual limit is decided by rand() between `min` and `max` per worker, to prevent all workers to be dead at the same time. Once the number exceeds the limit, that worker is automatically restarted.
 
@@ -47,7 +57,7 @@ If `verbose` is set to true, then after every request, your log will show the re
 
 ### WorkerKiller::Middleware::OOMLimiter
 
-This module automatically restarts the Unicorn workers, based on its memory size.
+This module automatically restarts/kills the workers, based on its memory size.
 
 `min` and `max` specify the min and max of maximum memory in bytes per worker. The actual limit is decided by rand() between `min` and `max` per worker, to prevent all workers to be dead at the same time.  Once the memory size exceeds `memory_size`, that worker is automatically restarted.
 

data/lib/worker_killer.rb

@@ -3,6 +3,7 @@ require 'worker_killer/configuration'
 require 'worker_killer/count_limiter'
 require 'worker_killer/memory_limiter'
 require 'worker_killer/middleware'
+require 'worker_killer/killer'
 
 module WorkerKiller
 
@@ -27,25 +28,45 @@ module WorkerKiller
   # the process isn't killed after `configuration.quit_attempts` QUIT signals,
   # send TERM signals until `configuration.kill_attempts`. Finally, send a KILL
   # signal. A single signal is sent per request.
-  def self.kill_self(logger, start_time)
-    alive_sec = (Time.now - start_time).round
-    self_pid = Process.pid
-
-    @kill_attempts ||= 0
-    @kill_attempts += 1
-
-    if configuration.use_quit
-      sig = :QUIT
-      sig = :TERM if @kill_attempts > configuration.quit_attempts
-      sig = :KILL if @kill_attempts > (configuration.quit_attempts + configuration.kill_attempts)
-    else
-      sig = :TERM
-      sig = :KILL if @kill_attempts > configuration.kill_attempts
-    end
-
-    logger.warn "#{self} send SIG#{sig} (pid: #{self_pid}) alive: #{alive_sec} sec (trial #{@kill_attempts})"
-    Process.kill sig, self_pid
-  end
+  # def self.kill_self(logger, start_time)
+  #   alive_sec = (Time.now - start_time).round
+
+  #   @kill_attempts ||= 0
+  #   @kill_attempts += 1
+
+  #   if configuration.use_quit
+  #     sig = :QUIT
+  #     sig = :TERM if @kill_attempts > configuration.quit_attempts
+  #     sig = :KILL if @kill_attempts > (configuration.quit_attempts + configuration.term_attempts)
+  #   else
+  #     sig = :TERM
+  #     sig = :KILL if @kill_attempts > configuration.term_attempts
+  #   end
+
+  #   if sig == :QUIT && configuration.passenger?
+  #     kill_by_passenger(logger, alive_sec, configuration.passenger_config, Process.pid)
+  #   else
+  #     kill_by_signal(logger, alive_sec, sig, Process.pid)
+  #   end
+  # end
+
+  # def self.kill_by_signal(logger, alive_sec, signal, pid)
+  #   logger.warn "#{self} send SIG#{signal} (pid: #{pid}) alive: #{alive_sec} sec (trial #{@kill_attempts})"
+  #   Process.kill signal, pid
+  # end
+
+  # def self.kill_by_passenger(logger, alive_sec, passenger, pid)
+  #   return if @already_detached
+  #   @already_detached = true
+
+  #   cmd = "#{passenger} detach-process #{pid}"
+  #   logger.warn "#{self} run #{cmd.inspect} (pid: #{pid}) alive: #{alive_sec} sec (trial #{@kill_attempts})"
+  #   Thread.new(cmd) do |command|
+  #     unless Kernel.system(command)
+  #       logger.warn "#{self} run #{cmd.inspect} failed: #{$?.inspect}"
+  #     end
+  #   end
+  # end
 
 end
 

data/lib/worker_killer/configuration.rb

@@ -4,13 +4,12 @@ module WorkerKiller
   # Methods for configuring WorkerKiller
   class Configuration
 
-    attr_accessor :logger, :quit_attempts, :kill_attempts, :use_quit
+    attr_accessor :logger, :quit_attempts, :term_attempts
 
     # Override defaults for configuration
-    def initialize(quit_attempts: 5, kill_attempts: 10, use_quit: true)
+    def initialize(quit_attempts: 10, term_attempts: 50)
       @quit_attempts = quit_attempts
-      @kill_attempts = kill_attempts
-      @use_quit = use_quit
+      @term_attempts = term_attempts
       @logger = Logger.new(STDOUT, level: Logger::INFO, progname: 'WorkerKiller')
     end
 

data/lib/worker_killer/count_limiter.rb

@@ -2,15 +2,13 @@ module WorkerKiller
   class CountLimiter
 
     attr_reader :min, :max, :left, :limit, :started_at
-    attr_accessor :reaction
 
-    def initialize(min: 3072, max: 4096, verbose: false, &block)
+    def initialize(min: 3072, max: 4096, verbose: false)
       @min = min
       @max = max
       @limit = @min + WorkerKiller.randomize(@max - @min + 1)
       @left = @limit
       @verbose = verbose
-      @reaction = block
     end
 
     def check
@@ -25,7 +23,6 @@ module WorkerKiller
       return false if (@left -= 1) > 0
 
       logger.warn "#{self}: worker (pid: #{Process.pid}) exceeds max number of requests (limit: #{@limit})"
-      @reaction.call(self)
 
       true
     end

data/lib/worker_killer/delayed_job_plugin.rb

@@ -0,0 +1,31 @@
+require 'worker_killer/memory_limiter'
+require 'worker_killer/count_limiter'
+
+module WorkerKiller
+  class DelayedJobPlugin
+
+    attr_reader :limiter, :killer, :reaction
+
+    def initialize(klass:, killer:, reaction: nil, **opts)
+      @killer = killer
+
+      @reaction = reaction || proc do |l, k, dj|
+        k.kill(l.started_at, dj: dj)
+      end
+
+      @limiter = klass.new(opts)
+    end
+
+    def new(*_args)
+      configure_lifecycle(Delayed::Worker.lifecycle)
+    end
+
+    def configure_lifecycle(lifecycle)
+      lifecycle.after(:perform) do |worker, *_args|
+        reaction.call(limiter, killer, worker) if limiter.check
+      end
+    end
+
+  end
+end
+

data/lib/worker_killer/killer.rb

@@ -0,0 +1,38 @@
+module WorkerKiller
+  module Killer
+    class Base
+
+      attr_accessor :config, :kill_attempts, :logger
+
+      def initialize(logger: WorkerKiller.configuration.logger, **_kwargs)
+        @logger = logger
+        @config = WorkerKiller.configuration
+        @kill_attempts = 0
+      end
+
+      def kill(start_time, **params)
+        alive_sec = (Time.now - start_time).round
+
+        @kill_attempts += 1
+
+        sig = :QUIT
+        sig = :TERM if kill_attempts > config.quit_attempts
+        sig = :KILL if kill_attempts > (config.quit_attempts + config.term_attempts)
+
+        do_kill(sig, Process.pid, alive_sec, **params)
+      end
+
+      # :nocov:
+      def do_kill(*_args)
+        raise 'Not Implemented'
+      end
+      # :nocov:
+
+    end
+  end
+end
+
+require_relative 'killer/signal'
+require_relative 'killer/passenger'
+require_relative 'killer/delayed_job'
+

data/lib/worker_killer/killer/delayed_job.rb

@@ -0,0 +1,27 @@
+module WorkerKiller
+  module Killer
+    class DelayedJob < ::WorkerKiller::Killer::Base
+
+      def do_kill(sig, pid, alive_sec, dj:, **_params)
+        if sig == :KILL
+          logger.error "#{self} force to #{sig} self (pid: #{pid}) alive: #{alive_sec} sec (trial #{kill_attempts})"
+          Process.kill sig, pid
+          return
+        end
+
+        dj.stop
+
+        return if sig != :TERM
+
+        if @termination
+          logger.warn "#{self} force to #{sig} self (pid: #{pid}) alive: #{alive_sec} sec (trial #{kill_attempts})"
+          Process.kill sig, pid
+        else
+          @termination = true
+        end
+      end
+
+    end
+  end
+end
+

data/lib/worker_killer/killer/passenger.rb

@@ -0,0 +1,55 @@
+module WorkerKiller
+  module Killer
+    class Passenger < ::WorkerKiller::Killer::Base
+
+      attr_reader :passenger_config
+
+      def initialize path: nil, **kwrags
+        super
+        @passenger_config = if path.nil? || path.empty?
+          self.class.check_passenger_config(`which passenger-config`)
+        else
+          self.class.check_passenger_config!(path)
+        end
+      end
+
+      def do_kill(sig, pid, alive_sec, **params)
+        cmd = "#{passenger_config} detach-process #{pid}"
+        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 self.check_passenger_config path
+        path.strip!
+        help = `#{path} detach-process --help 2> /dev/null`
+        return path if help['Remove an application process from the Phusion Passenger process pool']
+      rescue StandardError => e
+        nil
+      end
+
+      def self.check_passenger_config! path
+        if path = check_passenger_config(path)
+          path
+        else
+          raise "Can't find passenger config at #{path.inspect}"
+        end
+      end
+
+    end
+  end
+end
+

data/lib/worker_killer/killer/signal.rb

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

data/lib/worker_killer/memory_limiter.rb

@@ -4,16 +4,14 @@ module WorkerKiller
   class MemoryLimiter
 
     attr_reader :min, :max, :limit, :started_at, :check_cycle
-    attr_accessor :reaction
 
-    def initialize(min: (1024**3), max: (2 * (1024**3)), check_cycle: 16, verbose: false, &block)
+    def initialize(min: (1024**3), max: (2 * (1024**3)), check_cycle: 16, verbose: false)
       @min = min
       @max = max
       @limit = @min + WorkerKiller.randomize(@max - @min + 1)
       @check_cycle = check_cycle
       @check_count = 0
       @verbose = verbose
-      @reaction = block
     end
 
     def check
@@ -33,7 +31,6 @@ module WorkerKiller
       return false if rss <= @limit
 
       logger.warn "#{self}: worker (pid: #{Process.pid}) exceeds memory limit (#{rss} bytes > #{@limit} bytes)"
-      @reaction.call(self)
 
       true
     end

data/lib/worker_killer/middleware.rb

@@ -4,21 +4,22 @@ require 'worker_killer/count_limiter'
 module WorkerKiller
   class Middleware
 
-    attr_reader :limiter
+    attr_reader :limiter, :killer, :reaction
 
-    def initialize(app, klass:, reaction: nil, **opts)
+    def initialize(app, killer:, klass:, reaction: nil, **opts)
       @app = app
+      @killer = killer
 
-      reaction ||= proc do |limiter|
-        WorkerKiller.kill_self(limiter.logger, limiter.started_at)
+      @reaction = reaction || proc do |l, k|
+        k.kill(l.started_at)
       end
 
-      @limiter = klass.new(opts, &reaction)
+      @limiter = klass.new(opts)
     end
 
     def call(env)
       response = @app.call(env)
-      @limiter.check
+      reaction.call(limiter, killer) if limiter.check
       response
     end
 

data/lib/worker_killer/version.rb

@@ -2,7 +2,7 @@
 
 module WorkerKiller
 
-  VERSION = '0.1.0'
+  VERSION = '0.1.1'
 
 end
 

data/spec/count_limiter_spec.rb

@@ -1,20 +1,15 @@
 RSpec.describe WorkerKiller::CountLimiter do
-  let(:logger){ Logger.new(nil) }
-
   subject{ described_class.new(options) }
   let(:min){ rand(50..100) }
   let(:max){ min + rand(100) }
-  let(:options){ { min: min, max: max } }
+  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 'expect not to react while less than limit' do
-    expect do |b|
-      subject.reaction = b.to_proc
-      (subject.limit - 1).times do
-        expect(subject.check).to be_falsey
-      end
-    end.not_to yield_control
+    (subject.limit - 1).times do
+      expect(subject.check).to be_falsey
+    end
   end
 
   it 'expect call reaction when check succeded' do
@@ -22,11 +17,8 @@ RSpec.describe WorkerKiller::CountLimiter do
       expect(subject.check).to be_falsey
     end
 
-    expect do |b|
-      subject.reaction = b.to_proc
-      expect(subject.check).to be_truthy
-      expect(subject.check).to be_truthy
-    end.to yield_control.exactly(2).times
+    expect(subject.check).to be_truthy
+    expect(subject.check).to be_truthy
   end
 end
 

data/spec/killer/delayed_job_spec.rb

@@ -0,0 +1,34 @@
+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(:killer){ described_class.new() }
+  let(:dj){ double }
+
+  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
+
+        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
+    end
+  end
+end
+

data/spec/killer/passenger_spec.rb

@@ -0,0 +1,43 @@
+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() }
+
+  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
+
+      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
+
+  describe '#check_passenger_config!' do
+    it do
+      expect{ described_class.check_passenger_config!('nonenone') }.to raise_error(/Can't find passenger/)
+    end
+  end
+end
+

data/spec/killer/signal_spec.rb

@@ -0,0 +1,33 @@
+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() }
+
+  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
+
+        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
+    end
+  end
+end
+

data/spec/killer_spec.rb

@@ -0,0 +1,34 @@
+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() }
+
+  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(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
+
+        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
+    end
+
+  end
+end
+

data/spec/memory_limiter_spec.rb

@@ -6,7 +6,7 @@ RSpec.describe WorkerKiller::MemoryLimiter do
   let(:min){ rand(50..100) * mb }
   let(:max){ min + rand(100) * mb }
   let(:check_cycle){ 5 }
-  let(:options){ { min: min, max: max, check_cycle: check_cycle } }
+  let(:options){ { min: min, max: max, check_cycle: check_cycle, verbose: true} }
 
   it { is_expected.to have_attributes(min: min, max: max, limit: a_value_between(min, max)) }
 
@@ -19,10 +19,7 @@ RSpec.describe WorkerKiller::MemoryLimiter do
   it 'expect to skip check while less than cycle count' do
     expect(GetProcessMem).not_to receive(:new)
 
-    expect do |b|
-      subject.reaction = b.to_proc
-      skip_cycles(subject, check_cycle)
-    end.not_to yield_control
+    skip_cycles(subject, check_cycle)
   end
 
   it 'expect to skip check after cycle count reached' do
@@ -30,11 +27,8 @@ RSpec.describe WorkerKiller::MemoryLimiter do
     expect(memory).to receive(:bytes).and_return(min - 1)
     expect(GetProcessMem).to receive(:new).and_return(memory)
 
-    expect do |b|
-      subject.reaction = b.to_proc
-      skip_cycles(subject, check_cycle)
-      expect(subject.check).to be_falsey
-    end.not_to yield_control
+    skip_cycles(subject, check_cycle)
+    expect(subject.check).to be_falsey
   end
 
   it 'expect call reaction when check succeded' do
@@ -42,11 +36,8 @@ RSpec.describe WorkerKiller::MemoryLimiter do
     expect(memory).to receive(:bytes).and_return(subject.limit + 1)
     expect(GetProcessMem).to receive(:new).and_return(memory)
 
-    expect do |b|
-      subject.reaction = b.to_proc
-      skip_cycles(subject, check_cycle)
-      expect(subject.check).to be_truthy
-    end.to yield_control.exactly(1).times
+    skip_cycles(subject, check_cycle)
+    expect(subject.check).to be_truthy
   end
 end
 

data/spec/middleware_spec.rb

@@ -1,44 +1,79 @@
 require 'securerandom'
 
 RSpec.describe WorkerKiller::Middleware do
-  let(:logger){ Logger.new(nil) }
-
-  let(:app){ double }
-  let(:reaction){ ->{} }
+  let(:app){ double(call: {}) }
+  let(:killer) { double }
+  let(:reaction){ double }
   let(:anykey){ SecureRandom.hex(8) }
 
   describe 'Custom class' do
     let(:klass){ double }
-    let(:options){ { klass: klass, reaction: reaction, anykey: anykey } }
+    let(:options){ { killer: killer, klass: klass, reaction: reaction, anykey: anykey } }
     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(subject.limiter).to eq(99)
+      expect(subject.killer).to eq(killer)
     end
   end
 
   describe WorkerKiller::Middleware::RequestsLimiter do
-    let(:options){ { reaction: reaction, min: 1111 } }
+    let(:options){ { killer: killer, min: 3, max: 3 } }
     subject{ described_class.new(app, options) }
 
+    it 'is expected to be initialized without reaction' 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
+
+      4.times do
+        subject.call({})
+      end
+    end
+
     it 'is expected to be initialized with reaction' do
-      expect(WorkerKiller::CountLimiter).to receive(:new).with(min: 1111).and_call_original
+      options[:reaction] = reaction
+
+      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(1111)
-      expect(subject.limiter.reaction).to eq(reaction)
+      expect(subject.limiter.min).to eq(3)
+      expect(subject.limiter.max).to eq(3)
+      expect(reaction).to receive(:call).with(subject.limiter, killer).twice
+
+      4.times do
+        subject.call({})
+      end
     end
   end
 
   describe WorkerKiller::Middleware::OOMLimiter do
-    let(:options){ { reaction: reaction, min: 2222 } }
+    let(:options){ { killer: killer, min: 2222, max: 2223 } }
     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(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({})
+    end
+
     it 'is expected to be initialized with reaction' do
-      expect(WorkerKiller::MemoryLimiter).to receive(:new).with(min: 2222).and_call_original
+      options[:reaction] = reaction
+      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.reaction).to eq(reaction)
+      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({})
     end
   end
 end

data/spec/spec_helper.rb

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

data/spec/support/logger.rb

@@ -0,0 +1,12 @@
+RSpec.configure do |config|
+  config.before(:suite) do
+    $logger = Logger.new(STDOUT).tap do |logger|
+      logger.progname = "WorkerKille"
+      logger.level = "ERROR"
+    end
+    WorkerKiller.configure do |cfg|
+      cfg.logger = $logger
+    end
+  end
+end
+

data/spec/worker_killer_spec.rb

@@ -1,15 +1,5 @@
 RSpec.describe WorkerKiller do
   let(:logger){ Logger.new(nil) }
-  let(:config) do
-    WorkerKiller::Configuration.new.tap do |c|
-      c.quit_attempts = 2
-      c.kill_attempts = 2
-    end
-  end
-
-  before do
-    WorkerKiller.instance_variable_set('@kill_attempts', nil)
-  end
 
   describe '#randomize' do
     [1, 5, 25, 125, 5000, 10_000].each do |max|
@@ -22,45 +12,5 @@ RSpec.describe WorkerKiller do
       end
     end
   end
-
-  describe '#kill_self' do
-    context 'with use_quit TRUE' do
-      around do |example|
-        prev = WorkerKiller.configuration
-        config.use_quit = true
-        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(2).times
-        expect(Process).to receive(:kill).with(:TERM, anything).exactly(2).times
-        expect(Process).to receive(:kill).with(:KILL, anything).exactly(5).times
-        2.times { WorkerKiller.kill_self(logger, Time.now) } # 2 QUIT
-        2.times { WorkerKiller.kill_self(logger, Time.now) } # 2 TERM
-        5.times { WorkerKiller.kill_self(logger, Time.now) } # other - KILL
-      end
-    end
-
-    context 'with use_quit FALSE' do
-      around do |example|
-        prev = WorkerKiller.configuration
-        config.use_quit = false
-        WorkerKiller.configuration = config
-        example.run
-      ensure
-        WorkerKiller.configuration = prev
-      end
-
-      it 'expect right signal order' do
-        expect(Process).to receive(:kill).with(:TERM, anything).exactly(2).times
-        expect(Process).to receive(:kill).with(:KILL, anything).exactly(5).times
-        2.times { WorkerKiller.kill_self(logger, Time.now) } # 2 TERM
-        5.times { WorkerKiller.kill_self(logger, Time.now) } # other - KILL
-      end
-    end
-  end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: worker_killer
 version: !ruby/object:Gem::Version
-  version: 0.1.0.19841
+  version: 0.1.1.39838
 platform: ruby
 authors:
 - Samoilenko Yuri
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-11-28 00:00:00.000000000 Z
+date: 2020-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: get_process_mem
@@ -127,13 +127,23 @@ files:
 - lib/worker_killer.rb
 - lib/worker_killer/configuration.rb
 - lib/worker_killer/count_limiter.rb
+- lib/worker_killer/delayed_job_plugin.rb
+- lib/worker_killer/killer.rb
+- lib/worker_killer/killer/delayed_job.rb
+- lib/worker_killer/killer/passenger.rb
+- lib/worker_killer/killer/signal.rb
 - lib/worker_killer/memory_limiter.rb
 - lib/worker_killer/middleware.rb
 - lib/worker_killer/version.rb
 - spec/count_limiter_spec.rb
+- spec/killer/delayed_job_spec.rb
+- spec/killer/passenger_spec.rb
+- spec/killer/signal_spec.rb
+- spec/killer_spec.rb
 - spec/memory_limiter_spec.rb
 - spec/middleware_spec.rb
 - spec/spec_helper.rb
+- spec/support/logger.rb
 - spec/worker_killer_spec.rb
 homepage: https://github.com/RnD-Soft/worker_killer
 licenses:
@@ -160,7 +170,12 @@ specification_version: 4
 summary: Kill any workers by memory and request counts or take custom reaction
 test_files:
 - spec/middleware_spec.rb
+- spec/killer_spec.rb
 - spec/spec_helper.rb
+- spec/killer/passenger_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