autoscaler 0.11.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c7c64a64f5b36a7615b3fc8587d78ef94f608649
-  data.tar.gz: bd6f84ada4beb4cd9a6d933809da089aeeee6ae7
+  metadata.gz: f7f8b0bdbb93db7c32f3b0c3f4fe3f55902eed07
+  data.tar.gz: 379df2b6120350848c660040c705c22e11c1d1c3
 SHA512:
-  metadata.gz: e5ae3abf03d4ce9dc2c1bf7d7510f4d4c1b132e5f180dac7882630bd9a0bcf36ba43baf43338896b980909215ee0cadd66687ea438561aa880f9ec84f702cedb
-  data.tar.gz: 6f26a32336472672ee927d55578c4ce1da108163d58ed4c7494b92ea5c3e2c027d6013d42dab4e05d151b1a7772f1d82e717e3f7ce80ad6794204842219c13bf
+  metadata.gz: 1f7c387a19bf6908ab7264aaff7566ca8b905c6957e7ffde3d55e6b77e27fa982434e872c66127cf980b618785dc1119ed49577f02574d937bd6e03f62e4b841
+  data.tar.gz: 6353aeb2213fc015299017b73c82b6a53b1f328b90dbe221593390c6ede3e3880c9b1884fefbd0c7aec118f937ea16cda48696ef80f2b2415b9c1ecdce984ad1

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 0.12.0
+
+- Rewrite ThreadServer use a singleton monitor thread; it was incorrectly creating one per middleware instance, which was per-job
+
 ## 0.11.0
 
 - Replace celluloid monitor with thread based middleware for Sidekiq 4.0
@@ -8,7 +12,7 @@
 ## 0.10.0
 
 - Require Sidekiq 3.5
-- You may use `HerokuPlatformScaler` and `HEROKU_ACCESS_TOKEN` in place of `HerkouScaler` and `HEROKU_API_KEY`
+- You may use `HerokuPlatformScaler` and `HEROKU_ACCESS_TOKEN` in place of `HerokuScaler` and `HEROKU_API_KEY`
 - QueueSystem#workers returns the number of engaged SK processes.
 - Linear Scaling Strategy will not scale down past number of active workers. Assumes 1-1 SK process/dyno mapping.
 - Calls the SideKiq quiet api when shutting down

data/README.md

@@ -17,7 +17,7 @@ This gem uses the [Heroku Platform-Api](https://github.com/heroku/platform-api)
     HEROKU_ACCESS_TOKEN=.....
     HEROKU_APP=....
 
-Support is still present for [Heroku-Api](https://github.com/heroku/heroku.rb) via `HerkouScaler` and `HEROKU_API_KEY`, but may be removed in a future major version.
+Support is still present for [Heroku-Api](https://github.com/heroku/heroku.rb) via `HerokuScaler` and `HEROKU_API_KEY`, but may be removed in a future major version.
 
 Install the middleware in your `Sidekiq.configure_` blocks
 

data/lib/autoscaler/sidekiq/thread_server.rb

@@ -6,7 +6,8 @@ require 'thread'
 module Autoscaler
   module Sidekiq
     # Sidekiq server middleware
-    # spawns a thread to monitor the sidekiq server for scale-down
+    # Sidekiq creates a new instance of the middleware for each worker
+    # spawns a Monitor thread to monitor the sidekiq server for scale-down
     class ThreadServer
       # @param [scaler] scaler object that actually performs scaling operations (e.g. {HerokuPlatformScaler})
       # @param [Strategy,Numeric] timeout strategy object that determines target workers, or a timeout  in seconds to be passed to {DelayedShutdown}+{BinaryScalingStrategy}
@@ -15,76 +16,101 @@ module Autoscaler
         @scaler = scaler
         @strategy = strategy(timeout)
         @system = QueueSystem.new(specified_queues)
-        @mutex = Mutex.new
-        @done = false
       end
 
       # Sidekiq middleware api entry point
       def call(worker, msg, queue, _ = nil)
         yield
       ensure
-        active_now!
-        wait_for_downscale
+        monitor.active_now!
+        monitor.wait_for_downscale(@scaler, @strategy, @system)
       end
 
-      # Start the monitoring thread if it's not running
-      def wait_for_downscale
-        @thread ||= Thread.new do
-          begin
-            run
-          rescue
-            @thread = nil
-          end
+      private
+
+      def strategy(timeout)
+        if timeout.respond_to?(:call)
+          timeout
+        else
+          DelayedShutdown.new(BinaryScalingStrategy.new, timeout)
         end
       end
 
-      # Thread core loop
-      # Periodically update the desired number of workers
-      # @param [Numeric] interval polling interval, mostly for testing
-      def run(interval = 15)
-        active_now!
+      # Manages the single thread that watches for scaledown
+      # Singleton (see bottom) but instanceable for testing
+      class Monitor
+        def initialize
+          @mutex = Mutex.new
+          @done = false
+        end
+
+        # Start the monitoring thread if it's not running
+        # @param [scaler] scaler object that actually performs scaling operations (e.g. {HerokuPlatformScaler})
+        # @param [Strategy] strategy object that determines target workers
+        # @param [QueueSystem] system queue system that determines which sidekiq queues are watched
+        def wait_for_downscale(scaler, strategy, system)
+          @thread ||= Thread.new do
+            begin
+              run(scaler, strategy, system)
+            rescue
+              @thread = nil
+            end
+          end
+        end
 
-        workers = :unknown
+        # Thread core loop
+        # Periodically update the desired number of workers
+        # @param [scaler] scaler object that actually performs scaling operations (e.g. {HerokuPlatformScaler})
+        # @param [Strategy] strategy object that determines target workers
+        # @param [QueueSystem] system queue system that determines which sidekiq queues are watched
+        # @param [Numeric] interval polling interval, mostly for testing
+        def run(scaler, strategy, system, interval = 15)
+          active_now!
 
-        begin
-          sleep(interval)
-          target_workers = @strategy.call(@system, idle_time)
-          workers = @scaler.workers = target_workers unless workers == target_workers
-        end while !@done && workers > 0
-        ::Sidekiq::ProcessSet.new.each(&:quiet!)
-      end
+          workers = :unknown
 
-      # Shut down the thread, pause until complete
-      def terminate
-        @done = true
-        if @thread
-          t = @thread
-          @thread = nil
-          t.value
+          begin
+            sleep(interval)
+            target_workers = strategy.call(system, idle_time)
+            workers = scaler.workers = target_workers unless workers == target_workers
+          end while !@done && workers > 0
+          ::Sidekiq::ProcessSet.new.each(&:quiet!)
         end
-      end
 
-      private
+        # Shut down the thread, pause until complete
+        def terminate
+          @done = true
+          if @thread
+            t = @thread
+            @thread = nil
+            t.value
+          end
+        end
 
-      def active_now!
-        @mutex.synchronize do
-          @activity = Time.now
+        # Record last active time
+        def active_now!
+          @mutex.synchronize do
+            @activity = Time.now
+          end
         end
-      end
 
-      def idle_time
-        @mutex.synchronize do
-          Time.now - @activity
+        private
+
+        def idle_time
+          @mutex.synchronize do
+            Time.now - @activity
+          end
         end
       end
 
-      def strategy(timeout)
-        if timeout.respond_to?(:call)
-          timeout
-        else
-          DelayedShutdown.new(BinaryScalingStrategy.new, timeout)
-        end
+      Singleton = Monitor.new
+
+      def monitor
+        Singleton
       end
+
+      private_constant :Monitor
+      private_constant :Singleton
     end
   end
 end

data/lib/autoscaler/version.rb

@@ -1,4 +1,4 @@
 module Autoscaler
   # version number
-  VERSION = "0.11.0"
+  VERSION = "0.12.0"
 end

data/spec/autoscaler/sidekiq/thread_server_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'autoscaler/sidekiq/queue_system'
 require 'autoscaler/sidekiq/thread_server'
 require 'timeout'
 
@@ -8,35 +9,55 @@ describe Autoscaler::Sidekiq::ThreadServer do
     Sidekiq.redis {|c| c.flushdb }
   end
 
-  let(:cut) {Autoscaler::Sidekiq::ThreadServer}
+  let(:middleware) {Autoscaler::Sidekiq::ThreadServer}
+  let(:monitor) {Autoscaler::Sidekiq::ThreadServer.const_get(:Monitor)}
   let(:scaler) {TestScaler.new(1)}
+  let(:strategy0) {lambda{|s,t| 0}}
+  let(:strategy1) {lambda{|s,t| 1}}
+  let(:system) {Autoscaler::Sidekiq::QueueSystem.new}
 
   describe "thread core" do
     it "scales with no work" do
-      server = cut.new(scaler, lambda{|s,t| 0})
-      Timeout.timeout(1) { server.run(0.5) }
+      server = monitor.new
+      Timeout.timeout(1) { server.run(scaler, strategy0, system, 0.5) }
       expect(scaler.workers).to eq 0
       server.terminate
     end
 
     it "does not scale with pending work" do
-      server = cut.new(scaler, lambda{|s,t| 1})
-      expect {Timeout.timeout(1) { server.run(0.5) }}.to raise_error Timeout::Error
+      server = monitor.new
+      expect {Timeout.timeout(1) { server.run(scaler, strategy1, system, 0.5) }}.to raise_error Timeout::Error
       expect(scaler.workers).to eq 1
       server.terminate
     end
 
     it "will downscale with initial workers zero" do
       scaler = TestScaler.new(0)
-      server = cut.new(scaler, lambda{|s,t| 0})
-      Timeout.timeout(1) { server.run(0.5) }
+      server = monitor.new
+      Timeout.timeout(1) { server.run(scaler, strategy0, system, 0.5) }
       expect(scaler.workers).to eq 0
       server.terminate
     end
+
+    it "only starts a single thread " do
+      scaler = TestScaler.new(0)
+      mon = monitor.new
+      $counter = 0
+      def mon.run(a, b, c, i = 15)
+        $counter += 1
+      end
+      t1 = Thread.new { mon.wait_for_downscale(scaler, strategy0, system) }
+      t2 = Thread.new { mon.wait_for_downscale(scaler, strategy0, system) }
+      sleep(0.1)
+      t1.value
+      t2.value
+      expect($counter).to eq 1
+      mon.terminate
+    end
   end
 
   describe "Middleware interface" do
-    let(:server) {cut.new(scaler, 0, ['queue'])}
+    let(:server) {middleware.new(scaler, 0, ['queue'])}
 
     it('yields') {expect(server.call(Object.new, {}, 'queue') {:foo}).to eq :foo}
     it('yields with a redis pool') {expect(server.call(Object.new, {}, 'queue', Sidekiq.method(:redis)) {:foo}).to eq :foo}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: autoscaler
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.12.0
 platform: ruby
 authors:
 - Justin Love
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-17 00:00:00.000000000 Z
+date: 2016-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq