sidekiq-worker-killer 0.5.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: bfc7e3a75eba6f95fd48ee2c0fa604cddad8328f
-  data.tar.gz: 367eb4d8380b612dad3300829962cdcad40509fd
+SHA256:
+  metadata.gz: f40045c5805f35f8792f66c5dac896042c3b50b7b8c42f0f95e14827d4184a5a
+  data.tar.gz: 5721815ad342ec06d6231c005b60cb0bbda5300343a4bfb99b9b138fff8f6627
 SHA512:
-  metadata.gz: e26eae8384c0a43e2f57b792f094abb12b419ef58a47cfda9d2e42285ebfacf4ade437148cd20e742c5a6aaea9c1dc392e5272749aff2c1ad607e860325724a1
-  data.tar.gz: c347ad5878953ff5383508f0871d1beb12c1442970b2c2f6b4ff8b86a869002f75b928221506c176b395cf69b2419376e002340d70ecdfe82fb33f25c90c2d17
+  metadata.gz: 4db165333c1a8465b15e514af6b178aec3091bdb90a2ced38b8131b98706922518b25632f45a65fa33b923ac6d2a42c3379dee4e4fde1dde9dd20d9a49aab1e1
+  data.tar.gz: dd3e9e16d4bfbc5d753559e6b94c95b334ef2855864bcc7ef53f1577e40f6bc5122ad7040133c04d2c019ab37d532f012339fb18180e8efe74dc15274d427f49

data/README.md

@@ -36,11 +36,11 @@ The following options can be overrided.
 | Option | Defaults | Description |
 | ------- | ------- | ----------- |
 | max_rss | 0 MB (disabled) | max RSS in megabytes. Above this, shutdown will be triggered. |
-| grace_time | 900 seconds | when shutdown is triggered, the Sidekiq process will not accept new job and wait at most 15 minutes for running jobs to finish. If Float::INFINITY specified, will wait forever.  |
-| shutdown_wait | 30 seconds | when the grace time expires, still running jobs get 30 seconds to terminate. After that, kill signal is triggered.  |
-| kill_signal | SIGKILL | Signal to use kill Sidekiq process if it doesn't terminate.  |
-| gc | true | Try to run garbage collection before Sidekiq process terminate in case of max_rss exceeded.  |
-| skip_shutdown_if | Proc.new {false} | Executes a block of code after max_rss exceeds but before requesting shutdown. |
+| grace_time | 900 seconds | when shutdown is triggered, the Sidekiq process will not accept new job and wait at most 15 minutes for running jobs to finish. If Float::INFINITY specified, will wait forever. |
+| shutdown_wait | 30 seconds | when the grace time expires, still running jobs get 30 seconds to stop. After that, kill signal is triggered. |
+| kill_signal | SIGKILL | Signal to use to kill Sidekiq process if it doesn't stop. |
+| gc | true | Try to run garbage collection before Sidekiq process stops in case of exceeded max_rss. |
+| skip_shutdown_if | proc {false} | Executes a block of code after max_rss exceeds but before requesting shutdown. |
 
 *skip_shutdown_if* is expected to return anything other than `false` or `nil` to skip shutdown.
 

data/lib/sidekiq/worker_killer.rb

@@ -1,6 +1,7 @@
 require "get_process_mem"
 require "sidekiq"
 require "sidekiq/util"
+require "sidekiq/api"
 
 # Sidekiq server middleware. Kill worker when the RSS memory exceeds limit
 # after a given grace time.
@@ -9,15 +10,43 @@ class Sidekiq::WorkerKiller
 
   MUTEX = Mutex.new
 
+  # @param [Hash] options
+  # @option options [Integer] max_rss
+  #   Max RSS in MB. Above this, shutdown will be triggered.
+  #   (default: `0` (disabled))
+  # @option options [Integer] grace_time
+  #   When shutdown is triggered, the Sidekiq process will not accept new job
+  #   and wait at most 15 minutes for running jobs to finish.
+  #   If Float::INFINITY is specified, will wait forever. (default: `900`)
+  # @option options [Integer] shutdown_wait
+  #   when the grace time expires, still running jobs get 30 seconds to
+  #   stop. After that, kill signal is triggered. (default: `30`)
+  # @option options [String] kill_signal
+  #   Signal to use to kill Sidekiq process if it doesn't stop.
+  #   (default: `"SIGKILL"`)
+  # @option options [Boolean] gc
+  #   Try to run garbage collection before Sidekiq process stops in case
+  #   of exceeded max_rss. (default: `true`)
+  # @option options [Proc] skip_shutdown_if
+  #   Executes a block of code after max_rss exceeds but before requesting
+  #   shutdown. (default: `proc {false}`)
   def initialize(options = {})
     @max_rss         = options.fetch(:max_rss, 0)
     @grace_time      = options.fetch(:grace_time, 15 * 60)
     @shutdown_wait   = options.fetch(:shutdown_wait, 30)
     @kill_signal     = options.fetch(:kill_signal, "SIGKILL")
     @gc              = options.fetch(:gc, true)
-    @skip_shutdown   = options.fetch(:skip_shutdown_if, Proc.new { false })
+    @skip_shutdown   = options.fetch(:skip_shutdown_if, proc { false })
   end
 
+  # @param [String, Class] worker_class
+  #   the string or class of the worker class being enqueued
+  # @param [Hash] job
+  #   the full job payload
+  #   @see https://github.com/mperham/sidekiq/wiki/Job-Format
+  # @param [String] queue
+  #   the name of the queue the job was pulled from
+  # @yield the next middleware in the chain or the enqueuing of the job
   def call(worker, job, queue)
     yield
     # Skip if the max RSS is not exceeded
@@ -25,8 +54,9 @@ class Sidekiq::WorkerKiller
     return unless current_rss > @max_rss
     GC.start(full_mark: true, immediate_sweep: true) if @gc
     return unless current_rss > @max_rss
-    if @skip_shutdown.respond_to?(:call) && @skip_shutdown.call(worker, job, queue)
-      warn "current RSS #{current_rss} exceeds maximum RSS #{@max_rss}, however shutdown will be ignored"
+    if skip_shutdown?(worker, job, queue)
+      warn "current RSS #{current_rss} exceeds maximum RSS #{@max_rss}, " \
+           "however shutdown will be ignored"
       return
     end
 
@@ -37,6 +67,10 @@ class Sidekiq::WorkerKiller
 
   private
 
+  def skip_shutdown?(worker, job, queue)
+    @skip_shutdown.respond_to?(:call) && @skip_shutdown.call(worker, job, queue)
+  end
+
   def request_shutdown
     # In another thread to allow undelying job to finish
     Thread.new do
@@ -47,32 +81,28 @@ class Sidekiq::WorkerKiller
   end
 
   def shutdown
-    warn "sending #{quiet_signal} to #{identity}"
-    signal(quiet_signal, pid)
+    warn "sending quiet to #{identity}"
+    sidekiq_process.quiet!
 
     sleep(5) # gives Sidekiq API 5 seconds to update ProcessSet
 
     warn "shutting down #{identity} in #{@grace_time} seconds"
     wait_job_finish_in_grace_time
 
-    warn "sending SIGTERM to #{identity}"
-    signal("SIGTERM", pid)
+    warn "stopping #{identity}"
+    sidekiq_process.stop!
 
     warn "waiting #{@shutdown_wait} seconds before sending " \
           "#{@kill_signal} to #{identity}"
     sleep(@shutdown_wait)
 
     warn "sending #{@kill_signal} to #{identity}"
-    signal(@kill_signal, pid)
+    ::Process.kill(@kill_signal, ::Process.pid)
   end
 
   def wait_job_finish_in_grace_time
     start = Time.now
-    loop do
-      break if grace_time_exceeded?(start)
-      break if no_jobs_on_quiet_processes?
-      sleep(1)
-    end
+    sleep(1) until grace_time_exceeded?(start) || jobs_finished?
   end
 
   def grace_time_exceeded?(start)
@@ -81,35 +111,18 @@ class Sidekiq::WorkerKiller
     start + @grace_time < Time.now
   end
 
-  def no_jobs_on_quiet_processes?
-    Sidekiq::ProcessSet.new.each do |process|
-      return false if process["busy"] != 0 && process["quiet"] == "true"
-    end
-    true
+  def jobs_finished?
+    sidekiq_process.stopping? && sidekiq_process["busy"] == 0
   end
 
   def current_rss
     ::GetProcessMem.new.mb
   end
 
-  def signal(signal, pid)
-    ::Process.kill(signal, pid)
-  end
-
-  def pid
-    ::Process.pid
-  end
-
-  def identity
-    "#{hostname}:#{pid}"
-  end
-
-  def quiet_signal
-    if Gem::Version.new(Sidekiq::VERSION) >= Gem::Version.new("5.0")
-      "TSTP"
-    else
-      "USR1"
-    end
+  def sidekiq_process
+    Sidekiq::ProcessSet.new.find do |process|
+      process["identity"] == identity
+    end || raise("No sidekiq worker with identity #{identity} found")
   end
 
   def warn(msg)

data/lib/sidekiq/worker_killer/version.rb

@@ -1,7 +1,7 @@
 # rubocop:disable Style/ClassAndModuleChildren
 module Sidekiq
   class WorkerKiller
-    VERSION = "0.5.0".freeze
+    VERSION = "1.0.0".freeze
   end
 end
 # rubocop:enable Style/ClassAndModuleChildren

data/spec/sidekiq/worker_killer_spec.rb

@@ -1,30 +1,42 @@
 require "spec_helper"
 
 describe Sidekiq::WorkerKiller do
+  let(:sidekiq_process_set) { instance_double(Sidekiq::ProcessSet) }
+  let(:sidekiq_process) { instance_double(Sidekiq::Process) }
 
   before do
     allow(subject).to receive(:warn) # silence "warn" logs
     allow(subject).to receive(:sleep) # reduces tests running time
+    allow(Sidekiq::ProcessSet).to receive(:new) { sidekiq_process_set }
+    allow(sidekiq_process_set).to receive(:find) { sidekiq_process }
+    allow(sidekiq_process).to receive(:quiet!)
+    allow(sidekiq_process).to receive(:stop!)
+    allow(sidekiq_process).to receive(:stopping?)
   end
 
   describe "#call" do
     let(:worker){ double("worker") }
     let(:job){ double("job") }
     let(:queue){ double("queue") }
+
     it "should yield" do
       expect { |b|
         subject.call(worker, job, queue, &b)
       }.to yield_with_no_args
     end
+
     context "when current rss is over max rss" do
       subject{ described_class.new(max_rss: 2) }
+
       before do
         allow(subject).to receive(:current_rss).and_return(3)
       end
+
       it "should request shutdown" do
         expect(subject).to receive(:request_shutdown)
         subject.call(worker, job, queue){}
       end
+
       it "should call garbage collect" do
         allow(subject).to receive(:request_shutdown)
         expect(GC).to receive(:start).with(full_mark: true, immediate_sweep: true)
@@ -75,6 +87,7 @@ describe Sidekiq::WorkerKiller do
           subject.call(worker, job, queue){}
         end
       end
+
       context "but max rss is 0" do
         subject{ described_class.new(max_rss: 0) }
         it "should not request shutdown" do
@@ -115,12 +128,13 @@ describe Sidekiq::WorkerKiller do
           original_request_shutdown.call
         end
 
-        # track when the SIGTERM signal is sent
-        allow(Process).to receive(:kill) do |*args|
-          shutdown_time = Time.now if args[0] == 'SIGTERM'
+        # track when the process has been required to stop
+        expect(sidekiq_process).to receive(:stop!) do |*args|
+          shutdown_time = Time.now
         end
 
-        allow(subject).to receive(:pid).and_return(99)
+        allow(Process).to receive(:kill)
+        allow(Process).to receive(:pid).and_return(99)
 
         subject.send(:request_shutdown).join
 
@@ -135,29 +149,14 @@ describe Sidekiq::WorkerKiller do
     context "grace time is Float::INFINITY" do
       subject{ described_class.new(max_rss: 2, grace_time: Float::INFINITY, shutdown_wait: 0) }
       it "call signal only on jobs" do
-        allow(subject).to receive(:no_jobs_on_quiet_processes?).and_return(true)
-        allow(subject).to receive(:pid).and_return(99)
-        expect(Process).to receive(:kill).with('TSTP', 99)
-        expect(Process).to receive(:kill).with('SIGTERM', 99)
+        allow(subject).to receive(:jobs_finished?).and_return(true)
+        allow(Process).to receive(:pid).and_return(99)
+        expect(sidekiq_process).to receive(:quiet!)
+        expect(sidekiq_process).to receive(:stop!)
         expect(Process).to receive(:kill).with('SIGKILL', 99)
 
         subject.send(:request_shutdown).join
       end
     end
   end
-
-  describe "#quiet_signal" do
-    it "should give TSTP if Sidekiq version is > 5.0" do
-      stub_const("Sidekiq::VERSION", "5.0")
-      expect(subject.send :quiet_signal).to eq "TSTP"
-      stub_const("Sidekiq::VERSION", "5.2.1")
-      expect(subject.send :quiet_signal).to eq "TSTP"
-    end
-    it "should give USR1 if Sidekiq version is < 5.0" do
-      stub_const("Sidekiq::VERSION", "3.0")
-      expect(subject.send :quiet_signal).to eq "USR1"
-      stub_const("Sidekiq::VERSION", "4.6.7")
-      expect(subject.send :quiet_signal).to eq "USR1"
-    end
-  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-worker-killer
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Cyrille Courtiere
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-29 00:00:00.000000000 Z
+date: 2020-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: get_process_mem
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3'
+        version: '5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3'
+        version: '5'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -96,8 +96,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2.3
+rubygems_version: 3.1.0.pre3
 signing_key: 
 specification_version: 4
 summary: Sidekiq worker killer