resque_stuck_queue 0.0.11 → 0.0.13

checksums.yaml

@@ -1,7 +1,7 @@
 --- 
-SHA512: 
-  metadata.gz: df4e25ba257df91726f7c92cfe1a92f1a04b2afecb0106a4a80d0da12b494c67672fd5c40a981c813b4e18ede7d18b5e2aba3c8a445692e910acc17b9adc360e
-  data.tar.gz: 22f4307be4f19c7e3b138c4d18013ac8fefc3a7a4d53a4071c6a6f8c1f32ec9dce2f187db9476e12d4f871a332ba6d9842fd6eb6d2ac6bf576dad79522eae783
 SHA1: 
-  metadata.gz: ff579897e68c118a67fe037962f318c2a265e851
-  data.tar.gz: a82bad8bbf4ce498aac49d8b1f54c42047ee6b15
+  metadata.gz: 5d18f8d4224a9e8a9d30495ae0c7b6f3f0901f63
+  data.tar.gz: fd796adf7d09bb92e76c4806df3f725106d04d7a
+SHA512: 
+  metadata.gz: 476f6beaff11089bcd25c08428bdf6e7355af941ca5500c7e941c70addc5ed542e61a2f9d7d5df09970270a7401a880a0e3e58939139f00d3c5879222bc3d4f9
+  data.tar.gz: 6325fd7e73422455a97ea5479c82d36ef131ad5ba05a982db92d106bf088cd4804dd1126391c377bba7c8a538b56059164a303596123ab3f742c3c719ea71b87

data/README.md

@@ -20,42 +20,41 @@ It will trigger a pre-defined proc (see below) if the last time the hearbeat job
 
 ## Usage
 
-Configure it first:
+Configure it first. Optional settings are below. You'll most likely at the least want to tune `:handler`,`:heartbeat` and `:trigger_timeout` settings.
 
 <pre>
-# how often to push that 'heartbeat' job to refresh the latest time it worked.
-Resque::StuckQueue.config[:heartbeat] = 5.minutes
+handler:
+	set to what gets triggered when resque-stuck-queue will detect the latest heartbeat is older than the trigger_timeout time setting.
+	Example:
+	Resque::StuckQueue.config[:handler] = proc { |queue_name, lagtime| send_email('queue #{queue_name} isnt working, aaah the daemons') }
 
-# since there is an realistic and acceptable lag for job queues, set this to how much you're
-# willing to accept between the current time and when the last hearbeat job went through.
-#
-# take the heartbeat into consideration when setting this (it will fire 10 hours + 5 minutes with above heartbeat).
-Resque::StuckQueue.config[:trigger_timeout] = 10.hours
+heartbeat:
+	set to how often to push that 'heartbeat' job to refresh the latest time it worked.
+	Example:
+	Resque::StuckQueue.config[:heartbeat] = 5.minutes
 
-# what gets triggered when resque-stuck-queue will detect the latest heartbeat is older than the trigger_timeout time set above.
-#
-# triggering will update the key, so you'll have to wait the trigger_timeout again
-# in order for it to trigger again even if workers are still stale.
-Resque::StuckQueue.config[:handler] = proc { |queue_name| send_email("queue #{queue_name} isnt working, aaah the daemons") }
+trigger_timeout:
+	set to how much of a resque work lag you are willing to accept before being notified. note: take the :heartbeat setting into account when setting this timeout.
+	Example:
+	Resque::StuckQueue.config[:trigger_timeout] = 55.minutes
 
-# optional, in case you want to set your own name for the key that will be used as the last good hearbeat time
-# note this will be namespaced under the specific queue it's monitoring, for eg "app:name-the-refresh-key-as-you-please"
-Resque::StuckQueue.config[:global_key] = "name-the-refresh-key-as-you-please"
+redis:
+	set the Redis instance StuckQueue will use
 
-# optional, monitor specific queues you want to send a heartbeat/monitor
-Resque::StuckQueue.config[:queues] = [:app, :high, :my_custom_queue_name]
+heartbeat_key:
+	optional, name of keys to keep track of the last good resque heartbeat time
 
-# optional, if you want the resque-stuck-queue threads to explicitly raise, default is false
-Resque::StuckQueue.config[:abort_on_exception] = true
+logger:
+	optional, pass a Logger. Default a ruby logger will be instantiated. Needs to respond to that interface.
 
-# optional, pass a logger. Default a ruby logger will be instantiated. Needs to respond to that interface.
-Resque::StuckQueue.config[:logger] = Logger.new($stdout)
+queues:
+	optional, monitor specific queues you want to send a heartbeat/monitor to. default is :app
 
-# optional, pass a redis. 
-Resque::StuckQueue.config[:redis] = Redis.new
+abort_on_exception:
+	optional, if you want the resque-stuck-queue threads to explicitly raise, default is false
 
-# optional, your own custom refresh job. below has an example.
-Resque::StuckQueue.config[:refresh_job] = proc { your_own_enqueue_refreshing_global_key }
+refresh_job:
+	optional, your own custom refreshing job. if you are using something other than resque
 </pre>
 
 Then start it:
@@ -110,7 +109,7 @@ $ bundle exec rake --trace resque:stuck_queue
 
 ## Sidekiq/Other redis-based job queues
 
-If you have trouble with other queues you can use this lib by setting your own custom refresh job (aka, the job that refreshes your queue specific global_key). The one thing you need to take care of is ensure whatever and however you enque your own custom job, it sets the global_key to Time.now:
+If you have trouble with other queues you can use this lib by setting your own custom refresh job (aka, the job that refreshes your queue specific heartbeat_key). The one thing you need to take care of is ensure whatever and however you enque your own custom job, it sets the heartbeat_key to Time.now:
 
 <pre>
 
@@ -118,7 +117,7 @@ class CustomJob
   include Sidekiq::Worker
   def perform
     # ensure you're setting the key in the redis the job queue is using
-    $redis.set(Resque::StuckQueue.global_key_for(queue_name), Time.now.to_i)
+    $redis.set(Resque::StuckQueue.heartbeat_key_for(queue_name), Time.now.to_i)
   end
 end
 

data/THOUGHTS

@@ -14,3 +14,10 @@ add a trap{} to force_stop. ok for overwriting process's trap handlers? use conf
 
 fix skeleton recipe https://github.com/shaiguitar/resque_stuck_queue/blame/master/README.md#L103
   raise appname, => :environment, log path
+
+set a redis key instead of doing a manual refresh and have a recover handler. also pass the lag time into the handlers/procs (same semantics)
+investigate: why is temple getting triggered? how often? is the enqueing/checking taking too much time?
+also, if one queue is bad, does it trigger other queue's handlers? write some tests, asshole.
+woes of redis namespace, in regards to Awsm.redis != Resque.redis etc. (which is important for setting the key through @redis)
+
+with lag time, it will continue to trigger, for every heartbeat time it's supposed to tick, find some way to do that, and then maybe add some resolved handler/proc?

data/lib/resque_stuck_queue.rb

@@ -1,4 +1,5 @@
 require "resque_stuck_queue/version"
+require "resque_stuck_queue/config"
 
 # TODO move this require into a configurable?
 require 'resque'
@@ -11,35 +12,12 @@ require 'logger'
 module Resque
   module StuckQueue
 
-    GLOBAL_KEY        = "resque-stuck-queue"
-    HEARTBEAT         = 60 * 60 # check/refresh every hour
-    TRIGGER_TIMEOUT   = 5 * 60 * 60 # warn/trigger 5 hours
-    HANDLER           = proc { |queue_name| $stdout.puts("Shit gone bad with them queues...on #{queue_name}.") }
-
     class << self
 
       attr_accessor :config
 
-      # # how often we refresh the key
-      # :heartbeat  = 5 * 60
-      #
-      # # this could just be :heartbeat but it's possible there's an acceptable lag/bottleneck
-      # # in the queue that we want to allow to be before we think it's bad.
-      # :trigger_timeout = 10 * 60
-      #
-      # # The global key that will be used to check the latest time
-      # :global_key  = "resque-stuck-queue"
-      #
-      # # for threads involved here. default is false
-      # :abort_on_exception 
-      #
-      # # default handler
-      # config[:handler] = proc { |queue_name| send_mail }
-      #
-      # # explicit redis
-      # config[:redis] = Redis.new
       def config
-        @config ||= {}
+        @config ||= Config.new
       end
 
       def logger
@@ -56,12 +34,16 @@ module Resque
         Resque.redis = @redis
       end
 
-      def global_key_for(under_queue)
-        "#{under_queue}:#{config[:global_key] || GLOBAL_KEY}"
+      def heartbeat_key_for(queue)
+        "#{queue}:#{config[:heartbeat_key] || HEARTBEAT_KEY}"
+      end
+
+      def triggered_key_for(queue)
+        "#{queue}:#{config[:triggered_key] || TRIGGERED_KEY}"
       end
 
-      def global_keys
-        queues.map{|q| global_key_for(q) }
+      def heartbeat_keys
+        queues.map{|q| heartbeat_key_for(q) }
       end
 
       def queues
@@ -130,7 +112,7 @@ module Resque
           while @running
             # we want to go through resque jobs, because that's what we're trying to test here:
             # ensure that jobs get executed and the time is updated!
-            logger.info("Sending refresh job")
+            logger.info("Sending refresh jobs")
             enqueue_jobs
             wait_for_it
           end
@@ -143,7 +125,7 @@ module Resque
           config[:refresh_job].call
         else
           queues.each do |queue_name|
-            Resque.enqueue_to(queue_name, RefreshLatestTimestamp, [global_key_for(queue_name), redis.client.host, redis.client.port])
+            Resque.enqueue_to(queue_name, RefreshLatestTimestamp, [heartbeat_key_for(queue_name), redis.client.host, redis.client.port])
           end
         end
       end
@@ -157,8 +139,11 @@ module Resque
             if mutex.lock
               begin
                 queues.each do |queue_name|
-                  if Time.now.to_i - last_time_worked(queue_name) > max_wait_time
-                    logger.info("Triggering handler for #{queue_name} at #{Time.now} (pid: #{Process.pid})")
+                  logger.info("Checking if queue #{queue_name} is lagging")
+                  # else TODO recovered?
+                  if should_trigger?(queue_name)
+                    logger.info("Triggering handler for #{queue_name} at #{Time.now}.")
+                    logger.info("Lag time for #{queue_name} is #{lag_time(queue_name)} seconds.")
                     trigger_handler(queue_name)
                   end
                 end
@@ -171,35 +156,77 @@ module Resque
         end
       end
 
-      def last_time_worked(queue_name)
-        time_set = read_from_redis(queue_name)
+      #def recovered?
+        # already triggered once (last_trigger is not nil), but lag time is ok.
+        # then over here we'll rm last_triggered
+        # and fire a recovered handler. by rm the last_triggered the next time
+        # there is a problem, should_trigger? should return true
+      #end
+
+      def last_successful_heartbeat(queue_name)
+        time_set = read_from_redis(heartbeat_key_for(queue_name))
         if time_set
           time_set
         else
+          # the first time this is being used, key wont be there
+          # so just start now.
           manual_refresh(queue_name)
          end.to_i
       end
 
-      def manual_refresh(queue_name)
-         time = Time.now.to_i
-         redis.set(global_key_for(queue_name), time)
-         time
+      def manual_refresh(queue_name, type = :first_time)
+        if type == :triggered
+          time = Time.now.to_i
+          redis.set(triggered_key_for(queue_name), time)
+          time
+        elsif type == :first_time
+          time = Time.now.to_i
+          redis.set(heartbeat_key_for(queue_name), time)
+          time
+        end
+      end
+
+      def lag_time(queue_name)
+        Time.now.to_i - last_successful_heartbeat(queue_name)
+      end
+
+      def last_triggered(queue_name)
+        time_set = read_from_redis(triggered_key_for(queue_name))
+        if !time_set.nil?
+          Time.now.to_i - time_set.to_i
+        end
+      end
+
+      def should_trigger?(queue_name)
+        if lag_time(queue_name) > max_wait_time
+          last_trigger = last_triggered(queue_name)
+
+          if last_trigger.nil?
+            return true
+          elsif last_trigger > max_wait_time
+            return true
+          else
+            # if we've already triggered, the next trigger should be on the next iteration of max_wait_time.
+            return false
+          end
+        end
       end
 
       def trigger_handler(queue_name)
-        (config[:handler] || HANDLER).call(queue_name)
-        manual_refresh(queue_name)
+        (config[:handler] || HANDLER).call(queue_name, lag_time(queue_name))
+        manual_refresh(queue_name, :triggered)
       rescue => e
         logger.info("handler for #{queue_name} crashed: #{e.inspect}")
+        logger.info("\n#{e.backtrace.join("\n")}")
         force_stop!
       end
 
-      def read_from_redis(queue_name)
-        redis.get(global_key_for(queue_name))
+      def read_from_redis(keyname)
+        redis.get(keyname)
       end
 
       def wait_for_it
-        sleep config[:heartbeat] || HEARTBEAT
+        sleep config[:heartbeat] || HEARTBEAT_TIMEOUT
       end
 
       def max_wait_time

data/lib/resque_stuck_queue/config.rb

@@ -0,0 +1,60 @@
+module Resque
+  module StuckQueue
+
+    # defaults
+    HEARTBEAT_KEY        = "resque-stuck-queue"
+    TRIGGERED_KEY        = "resque-stuck-queue-last-triggered"
+    HEARTBEAT_TIMEOUT    = 20 * 60                  # check/refresh every 20 mins.
+    TRIGGER_TIMEOUT      = 40 * 60                  # warn/trigger after an hour (with 20 min heartbeat time).
+    HANDLER              = proc { |queue_name, lag| $stdout.puts("Shit gone bad with them queues...on #{queue_name}. Lag time is #{lag}") }
+
+    class Config < Hash
+
+      OPTIONS_DESCRIPTIONS = {
+        :handler            => "set to what gets triggered when resque-stuck-queue will detect the latest heartbeat is older than the trigger_timeout time setting.\n\tExample:\n\tResque::StuckQueue.config[:handler] = proc { |queue_name, lagtime| send_email('queue \#{queue_name} isnt working, aaah the daemons') }",
+        :heartbeat          => "set to how often to push that 'heartbeat' job to refresh the latest time it worked.\n\tExample:\n\tResque::StuckQueue.config[:heartbeat] = 5.minutes",
+        :trigger_timeout    => "set to how much of a resque work lag you are willing to accept before being notified. note: take the :heartbeat setting into account when setting this timeout.\n\tExample:\n\tResque::StuckQueue.config[:trigger_timeout] = 55.minutes",
+        :redis              => "set the Redis instance StuckQueue will use",
+        :heartbeat_key      => "optional, name of keys to keep track of the last good resque heartbeat time",
+        :triggered_key      => "optional, name of keys to keep track of the last trigger time",
+        :logger             => "optional, pass a Logger. Default a ruby logger will be instantiated. Needs to respond to that interface.",
+        :queues             => "optional, monitor specific queues you want to send a heartbeat/monitor to. default is :app",
+        :abort_on_exception => "optional, if you want the resque-stuck-queue threads to explicitly raise, default is false",
+        :refresh_job        => "optional, your own custom refreshing job. if you are using something other than resque",
+      }
+
+      OPTIONS = OPTIONS_DESCRIPTIONS.keys
+
+      def []=(k,v)
+        validate_key_exists!(k)
+        super(k,v)
+      end
+
+      def [](k)
+        validate_key_exists!(k)
+        super(k)
+      end
+
+      class NoConfigError < StandardError; end
+
+      def validate_key_exists!(k)
+        if ! OPTIONS.include?(k)
+          raise NoConfigError, "no such config key exists!"
+        end
+      end
+
+      def description_for(k)
+        OPTIONS_DESCRIPTIONS[k.to_sym]
+      end
+
+      def pretty_descriptions
+        out = "\n"
+        OPTIONS_DESCRIPTIONS.map{|key,msg|
+          out << "#{key}:\n\t#{msg}\n\n"
+        }
+        out
+      end
+
+    end
+  end
+end

data/lib/resque_stuck_queue/version.rb

@@ -1,5 +1,5 @@
 module Resque
   module StuckQueue
-    VERSION = "0.0.11"
+    VERSION = "0.0.13"
   end
 end

data/test/{test_logger.rb → test_config.rb}

@@ -1,6 +1,6 @@
 require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper")
 
-class TestResqueStuckQueue < Minitest::Test
+class TestConfig < Minitest::Test
 
   include TestHelper
 
@@ -14,6 +14,17 @@ class TestResqueStuckQueue < Minitest::Test
     Resque::StuckQueue.reset!
   end
 
+  def test_config_has_descriptions
+    c = Resque::StuckQueue::Config.new
+    assert c.description_for(:logger) =~ /Logger/, "has descriptions"
+  end
+
+  def test_outputs_all_config_options
+    c = Resque::StuckQueue::Config.new
+    puts c.pretty_descriptions
+    assert true
+  end
+
   def test_has_logger
     puts "#{__method__}"
     begin

data/test/test_helper.rb

@@ -11,12 +11,20 @@ require File.join(File.expand_path(File.dirname(__FILE__)), "resque", "refresh_l
 
 module TestHelper
 
+  extend self
+
   def run_resque(queue_name = "*")
-    pid = fork { exec("QUEUE=#{queue_name} bundle exec rake --trace resque:work") }
+    pid = fork { exec("export QUEUE=#{queue_name}; bundle exec rake --trace resque:work") }
     sleep 3 # wait for resque to boot up
     pid
   end
 
+  def hax_kill_resque
+    # ugly, FIXME how to get pid of forked forked process. run_resque pid is incorrect.
+   `ps aux |grep resque |awk '{print $2}' |xargs kill`
+   sleep 2 # wait for shutdown
+  end
+
   def start_and_stop_loops_after(secs)
     ops = []
     ops << Thread.new { Resque::StuckQueue.start }

data/test/test_integration.rb

@@ -12,84 +12,91 @@ require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper")
 class TestIntegration < Minitest::Test
 
   include TestHelper
-  # TODODS there's a better way to do this.
-  #
-  #
-  # run test with  VVERBOSE=1 DEBUG=1 for more output
-  #
-  #
-  # => sleeping suckc
-  # => resque sleeps 5 between checking enqueed jobs, can be configurable?
-  #
-  # cleanup processes correctly?
-  # ps aux |grep resqu |awk '{print $2}' | xargs kill
+
+  # UBER HAXING no after(:all) or before(:all)
+  # if adding a test here, add
+  # self.class.tests_ran += 1
+  class << self
+    def tests_running?
+      test_count = public_instance_methods.select{|m| m.to_s.match(/^test_/)}.size
+      true if tests_ran != test_count
+    end
+
+    def tests_done?
+      !tests_running?
+    end
+
+    attr_accessor :tests_ran, :resque_pid
+    def tests_ran
+      @tests_ran ||= 0
+    end
+
+    def run_resque_before_all
+      return if @running_resque
+      @running_resque = true
+
+      @resque_pid = TestHelper.run_resque
+    end
+  end
 
   def setup
     Resque::StuckQueue.redis = Redis.new
     Resque::StuckQueue.redis.flushall
     Resque::StuckQueue.config[:abort_on_exception] = true
+    self.class.run_resque_before_all
   end
 
   def teardown
-   `kill -9 #{@resque_pid}` # CONT falls throughs sometimes? hax, rm this and SIGSTOP/SIGCONT
-    Resque::StuckQueue.force_stop!
-    Process.waitpid(@resque_pid)
+    if self.class.tests_done?
+      hax_kill_resque
+      Process.waitall
+      return
+    end
   end
 
   def test_resque_enqueues_a_job_does_not_trigger
     puts "#{__method__}"
-    Resque::StuckQueue.config[:trigger_timeout] = 100 # wait a while so we don't trigger
-    Resque::StuckQueue.config[:heartbeat] = 2
+    self.class.tests_ran += 1
+
+    Resque::StuckQueue.config[:trigger_timeout] = 10
+    Resque::StuckQueue.config[:heartbeat] = 1
     @triggered = false
     Resque::StuckQueue.config[:handler] = proc { @triggered = true }
-    Thread.new { Resque::StuckQueue.start }
-
-    # job gets enqueued successfully
-    @resque_pid = run_resque
+    start_and_stop_loops_after(5)
     Resque::StuckQueue.redis.del(SetRedisKey::NAME)
     Resque.enqueue_to(:app, SetRedisKey)
-    sleep 6 # let resque pick up the job
-    assert_equal Resque::StuckQueue.redis.get(SetRedisKey::NAME), "1" # job ran
-
-    # check handler did not get called
+    sleep 3
+    assert_equal Resque::StuckQueue.redis.get(SetRedisKey::NAME), "1"
+    # job ran successfully, so don't trigger
     assert_equal @triggered, false
   end
 
   def test_resque_does_not_enqueues_a_job_does_trigger
     puts "#{__method__}"
-    Resque::StuckQueue.config[:trigger_timeout] = 2 # won't allow waiting too much and will complain (eg trigger) sooner than later
+    self.class.tests_ran += 1
+
+    Resque::StuckQueue.config[:trigger_timeout] = 0
     Resque::StuckQueue.config[:heartbeat] = 1
     @triggered = false
     Resque::StuckQueue.config[:handler] = proc { @triggered = true }
-    Thread.new { Resque::StuckQueue.start }
-
-    # job gets enqueued successfully
-    @resque_pid = run_resque
-    Resque::StuckQueue.redis.del(SetRedisKey::NAME)
-    Process.kill("SIGSTOP", @resque_pid) # jic, do not process jobs so we definitely trigger
-    Resque.enqueue(SetRedisKey)
-    assert_equal Resque::StuckQueue.redis.get(SetRedisKey::NAME), nil
-    sleep 2 # allow timeout to trigger
-
+    start_and_stop_loops_after(2)
     # check handler did get called
     assert_equal @triggered, true
-
-    # unstick the process so we can kill it in teardown
-    Process.kill("SIGCONT", @resque_pid)
   end
 
   def test_has_settable_custom_hearbeat_job
     puts "#{__method__}"
+    self.class.tests_ran += 1
+
     Resque::StuckQueue.config[:trigger_timeout] = 2 # won't allow waiting too much and will complain (eg trigger) sooner than later
     Resque::StuckQueue.config[:heartbeat] = 1
 
     begin
-      Resque::StuckQueue.config[:refresh_job] = proc { Resque.enqueue(RefreshLatestTimestamp, Resque::StuckQueue.global_key_for(:app)) }
+      Resque::StuckQueue.config[:refresh_job] = proc { Resque.enqueue(RefreshLatestTimestamp, Resque::StuckQueue.heartbeat_key_for(:app)) }
       @triggered = false
       Resque::StuckQueue.config[:handler] = proc { @triggered = true }
-      Thread.new { Resque::StuckQueue.start }
+      start_and_stop_loops_after(4)
 
-      @resque_pid = run_resque
       sleep 3 # allow trigger
       assert true, "should not have raised"
       assert @triggered, "should have triggered"
@@ -98,5 +105,4 @@ class TestIntegration < Minitest::Test
     end
   end
 
-
 end

data/test/test_lagtime.rb

@@ -0,0 +1,34 @@
+require 'minitest'
+require "minitest/autorun"
+require 'pry'
+
+$:.unshift(".")
+require 'resque_stuck_queue'
+require File.join(File.expand_path(File.dirname(__FILE__)), "resque", "set_redis_key")
+require File.join(File.expand_path(File.dirname(__FILE__)), "resque", "refresh_latest_timestamp")
+require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper")
+
+class TestLagTime < Minitest::Test
+
+  include TestHelper
+
+  def setup
+    Resque::StuckQueue.redis = Redis.new
+    Resque::StuckQueue.redis.flushall
+    Resque::StuckQueue.config[:abort_on_exception] = true
+  end
+
+  def test_triggers_handler_with_lagtime
+    Resque::StuckQueue.config[:trigger_timeout] = 2 # won't allow waiting too much and will complain (eg trigger) sooner than later
+    Resque::StuckQueue.config[:heartbeat] = 1
+    @lagtime = 0
+    Resque::StuckQueue.config[:handler] = proc { |queue_name, lagtime| @lagtime = lagtime }
+    start_and_stop_loops_after(5)
+
+    # check handler did get called
+    assert @lagtime > 0, "lagtime shoudl be set"
+    assert @lagtime < 5, "lagtime shoudl be set"
+  end
+
+
+end

data/test/test_named_queues.rb

@@ -13,7 +13,7 @@ class TestNamedQueues < Minitest::Test
   end
 
   def teardown
-   `kill -9 #{@resque_pid}` if @resque_pid
+    hax_kill_resque
     Resque::StuckQueue.force_stop!
     Process.waitpid(@resque_pid) if @resque_pid
   end
@@ -22,14 +22,14 @@ class TestNamedQueues < Minitest::Test
     puts "#{__method__}"
     Resque::StuckQueue.config[:queues] = nil
     start_and_stop_loops_after(2)
-    assert Resque::StuckQueue.global_keys.include?("app:resque-stuck-queue"), 'has global keys'
+    assert Resque::StuckQueue.heartbeat_keys.include?("app:resque-stuck-queue"), 'has global keys'
   end
 
   def test_has_custom_queues
     puts "#{__method__}"
     Resque::StuckQueue.config[:queues] = [:foo,:bar]
     start_and_stop_loops_after(2)
-    assert Resque::StuckQueue.global_keys.include?("foo:resque-stuck-queue"), 'has global keys'
+    assert Resque::StuckQueue.heartbeat_keys.include?("foo:resque-stuck-queue"), 'has global keys'
   end
 
   def test_resque_enqueues_a_job_with_resqueue_running_but_on_that_queue_does_trigger
@@ -54,7 +54,7 @@ class TestNamedQueues < Minitest::Test
     Resque::StuckQueue.config[:trigger_timeout] = 2 # won't allow waiting too much and will complain (eg trigger) sooner than later
     Resque::StuckQueue.config[:heartbeat] = 1
     Resque::StuckQueue.config[:queues] = [:custom_queue_name, :diff_one]
-    assert Resque::StuckQueue.global_keys.include?("custom_queue_name:resque-stuck-queue"), 'has global keys'
+    assert Resque::StuckQueue.heartbeat_keys.include?("custom_queue_name:resque-stuck-queue"), 'has global keys'
     @triggered = false
     Resque::StuckQueue.config[:handler] = proc { @triggered = true }
     @resque_pid = run_resque("custom_queue_name")

data/test/test_resque_stuck_queue.rb

@@ -19,11 +19,11 @@ class TestResqueStuckQueue < Minitest::Test
     Resque::StuckQueue.config[:abort_on_exception] = true
   end
 
-  def test_configure_global_key
+  def test_configure_heartbeat_key
     puts "#{__method__}"
     assert_nil Resque::StuckQueue.redis.get("it-is-configurable"), "global key should not be set"
-    Resque::StuckQueue.config[:global_key] = "it-is-configurable"
-    start_and_stop_loops_after(2)
+    Resque::StuckQueue.config[:heartbeat_key] = "it-is-configurable"
+    start_and_stop_loops_after(3)
     refute_nil Resque::StuckQueue.redis.get("app:it-is-configurable"), "global key should be set"
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: resque_stuck_queue
 version: !ruby/object:Gem::Version 
-  version: 0.0.11
+  version: 0.0.13
 platform: ruby
 authors: 
 - Shai Rosenfeld
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2014-01-23 00:00:00 Z
+date: 2014-01-26 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: redis-mutex
@@ -58,14 +58,16 @@ files:
 - THOUGHTS
 - lib/resque/stuck_queue.rb
 - lib/resque_stuck_queue.rb
+- lib/resque_stuck_queue/config.rb
 - lib/resque_stuck_queue/version.rb
 - resque_stuck_queue.gemspec
 - test/resque/refresh_latest_timestamp.rb
 - test/resque/set_redis_key.rb
 - test/test_collision.rb
+- test/test_config.rb
 - test/test_helper.rb
 - test/test_integration.rb
-- test/test_logger.rb
+- test/test_lagtime.rb
 - test/test_named_queues.rb
 - test/test_resque_2.rb
 - test/test_resque_stuck_queue.rb
@@ -97,9 +99,10 @@ test_files:
 - test/resque/refresh_latest_timestamp.rb
 - test/resque/set_redis_key.rb
 - test/test_collision.rb
+- test/test_config.rb
 - test/test_helper.rb
 - test/test_integration.rb
-- test/test_logger.rb
+- test/test_lagtime.rb
 - test/test_named_queues.rb
 - test/test_resque_2.rb
 - test/test_resque_stuck_queue.rb