worker_killer 1.0.2.187852 → 1.0.3.189564

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0cde26e5d9705270605884443084f3dada5182e12ce9cba38c91ef5206837ced
-  data.tar.gz: 8ebe3a9edafa87bafb84edd1f52277bb62dc9db7484fa4f0515ec0acaaf5d9ac
+  metadata.gz: 8de386a9112f6941110e0cc8f75d2276c859ca36d9cff4e5eadfb39dd33013fe
+  data.tar.gz: 7a1f7f3b042a3603db7e0a51a30cdb99f872bfb1288d8545c1b893241a1118f8
 SHA512:
-  metadata.gz: 8bb89c7851d4dd6a127fa33273ca6c64e899c1d03d7e44709435a940944e7dff074a2f56f794221790464836d174fbb2dfa02f1ee08cf333a4b05342c6b0e1d7
-  data.tar.gz: ca33356f8884b182c7ad06883b337168b563f105829f5f587471b87972d76b3738e97f5bb7e6cbcfe335d630cf386cb2026d805eb1ff1a264d60961ae5d27735
+  metadata.gz: a6397322a93eb40332f728b0b0bf5114aec40571f76ee3a6a64b1125be8fa7d9221f3158be4b1960fcd8c28b26cebe2b500cb582ebee39876414a881e709a0ed
+  data.tar.gz: 39bafdacf68392a4c1c05ac5b600d821a7e3cd368acbe3b585d855b1527e08b3898c53b17f458a74207c0987c2d93e9689302ce5c1a3b0d4b5c9138e8a382a67

data/lib/worker_killer/delayed_job_plugin.rb

@@ -24,11 +24,12 @@ module WorkerKiller
     def configure_lifecycle(lifecycle)
       # Count condition after every job
       lifecycle.after(:perform) do |worker, *_args|
-        @time_to_burn = limiter.check
+        @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
       end
     end

data/lib/worker_killer/memory_limiter.rb

@@ -5,36 +5,57 @@ module WorkerKiller
 
     attr_reader :min, :max, :limit, :started_at, :check_cycle
 
-    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)
+    def initialize(min:, max:, check_cycle: 16, verbose: false)
+      if min
+        # 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
+      end
+
       @check_cycle = check_cycle
       @check_count = 0
       @verbose = verbose
     end
 
     def check
-      return nil if @limit <= 1024**2
-
       @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?
+
+      do_check(rss)
+    end
+
+    def do_check(rss)
+      rss_mb = (rss / 1024 / 1024).round(1)
+
       if @verbose
-        logger.info "#{self.class}: worker (pid: #{Process.pid}) using #{rss} bytes(#{rss / 1024 / 1024}mb)."
+        logger.info "#{self.class}: worker (pid: #{Process.pid}) using #{rss_mb} MB (of #{@limit_mb} MB)"
       end
       @check_count = 0
 
       return false if rss <= @limit
 
-      logger.warn "#{self.class}: worker (pid: #{Process.pid}) exceeds memory limit (#{rss} bytes > #{@limit} bytes)"
+      logger.warn "#{self.class}: worker (pid: #{Process.pid}) exceeds memory limit (#{rss_mb} MB > #{@limit_mb} MB)"
 
       true
     end
 
+    def set_limits(min, max)
+      @min = min
+      @limit = @max = max
+      @limit_mb = (@limit / 1024 / 1024).round(1)
+    end
+
     def logger
       WorkerKiller.configuration.logger
     end

data/lib/worker_killer/version.rb

@@ -2,7 +2,7 @@
 
 module WorkerKiller
 
-  VERSION = '1.0.2'
+  VERSION = '1.0.3'
 
 end
 

data/spec/delayed_job_plugin/jobs_limiter_spec.rb

@@ -1,13 +1,12 @@
 RSpec.describe WorkerKiller::DelayedJobPlugin::JobsLimiter do
-
-  let(:killer) {double}
+  let(:killer) { double }
   subject(:plugin){ described_class.new(killer: killer) }
 
   context 'DelayedJob initialization' do
     let(:lifecycle) { double }
     subject(:instance) { plugin.new(lifecycle) }
-    
-    it  do
+
+    it do
       expect(lifecycle).to receive(:after).with(:perform).and_yield
       expect(lifecycle).to receive(:after).with(:loop).and_yield
       instance

data/spec/delayed_job_plugin/oom_limiter_spec.rb

@@ -1,13 +1,12 @@
 RSpec.describe WorkerKiller::DelayedJobPlugin::OOMLimiter do
-
-  let(:killer) {double}
-  subject(:plugin){ described_class.new(killer: killer) }
+  let(:killer) { double }
+  subject(:plugin){ described_class.new(min: (1024**3), max: (2 * (1024**3)), killer: killer) }
 
   context 'DelayedJob initialization' do
     let(:lifecycle) { double }
     subject(:instance) { plugin.new(lifecycle) }
-    
-    it  do
+
+    it do
       expect(lifecycle).to receive(:after).with(:perform).and_yield
       expect(lifecycle).to receive(:after).with(:loop).and_yield
       instance

data/spec/memory_limiter_spec.rb

@@ -2,13 +2,10 @@ RSpec.describe WorkerKiller::MemoryLimiter do
   let(:logger){ Logger.new(nil) }
 
   subject{ described_class.new(**options) }
-  let(:mb){ 1024 * 1024 }
-  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, verbose: true} }
+  let(:options){ { min: min, max: max, check_cycle: check_cycle, verbose: true } }
+  let(:memory) { instance_double(GetProcessMem) }
 
-  it { is_expected.to have_attributes(min: min, max: max, limit: a_value_between(min, max)) }
 
   def skip_cycles(object, cycles)
     (cycles - 1).times do
@@ -16,28 +13,68 @@ RSpec.describe WorkerKiller::MemoryLimiter do
     end
   end
 
-  it 'expect to skip check while less than cycle count' do
-    expect(GetProcessMem).not_to receive(:new)
-
-    skip_cycles(subject, check_cycle)
+  before do
+    allow(GetProcessMem).to receive(:new).and_return(memory)
   end
 
-  it 'expect to skip check after cycle count reached' do
-    memory = instance_double(GetProcessMem)
-    expect(memory).to receive(:bytes).and_return(min - 1)
-    expect(GetProcessMem).to receive(:new).and_return(memory)
+  context 'fixed memory limit' do
+    let(:mb){ 1024 * 1024 }
+    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 'expect to skip check while less than cycle count' do
+      expect(GetProcessMem).not_to receive(:new)
+
+      skip_cycles(subject, check_cycle)
+    end
+
+    it 'expect to skip check after cycle count reached' do
+      expect(memory).to receive(:bytes).and_return(min - 1)
+
+      skip_cycles(subject, check_cycle)
+      expect(subject.check).to be_falsey
+    end
 
-    skip_cycles(subject, check_cycle)
-    expect(subject.check).to be_falsey
+    it 'expect call reaction when check succeded' do
+      expect(memory).to receive(:bytes).and_return(subject.limit + 1)
+
+      skip_cycles(subject, check_cycle)
+      expect(subject.check).to be_truthy
+    end
   end
 
-  it 'expect call reaction when check succeded' do
-    memory = instance_double(GetProcessMem)
-    expect(memory).to receive(:bytes).and_return(subject.limit + 1)
-    expect(GetProcessMem).to receive(:new).and_return(memory)
+  context 'relative memory limit' do
+    let(:min){ nil }
+    let(:max){ 0.5 }
+    let(:rss) { 100 * 1024 * 1024 }
+    let(:min_expected) { rss }
+    let(:max_expected) { min_expected + min_expected * max }
 
-    skip_cycles(subject, check_cycle)
-    expect(subject.check).to be_truthy
+    it { is_expected.to have_attributes(min: nil, max: nil, limit: nil) }
+
+    it 'expect to initialize limits on first check' do
+      expect(memory).to receive(:bytes).and_return(rss)
+
+      skip_cycles(subject, check_cycle)
+      is_expected.to have_attributes(min: nil, max: nil, limit: nil)
+
+      expect(subject.check).to be_falsey
+
+      is_expected.to have_attributes(min: min_expected, max: max_expected, limit: max_expected)
+    end
+
+    it 'expect call reaction when check succeded' do
+      expect(memory).to receive(:bytes).and_return(rss)
+
+      skip_cycles(subject, check_cycle)
+      expect(subject.check).to be_falsey
+
+      expect(memory).to receive(:bytes).and_return(subject.limit + 1)
+      skip_cycles(subject, check_cycle)
+      expect(subject.check).to be_truthy
+    end
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: worker_killer
 version: !ruby/object:Gem::Version
-  version: 1.0.2.187852
+  version: 1.0.3.189564
 platform: ruby
 authors:
 - Samoilenko Yuri
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-09-28 00:00:00.000000000 Z
+date: 2023-10-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: get_process_mem
@@ -171,15 +171,15 @@ signing_key:
 specification_version: 4
 summary: Kill any workers by memory and request counts or take custom reaction
 test_files:
-- spec/middleware_spec.rb
+- spec/killer/signal_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/spec_helper.rb
 - spec/delayed_job_plugin/oom_limiter_spec.rb
 - spec/delayed_job_plugin/jobs_limiter_spec.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