resque_stuck_queue 0.0.13 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 --- 
-SHA1: 
-  metadata.gz: 5d18f8d4224a9e8a9d30495ae0c7b6f3f0901f63
-  data.tar.gz: fd796adf7d09bb92e76c4806df3f725106d04d7a
 SHA512: 
-  metadata.gz: 476f6beaff11089bcd25c08428bdf6e7355af941ca5500c7e941c70addc5ed542e61a2f9d7d5df09970270a7401a880a0e3e58939139f00d3c5879222bc3d4f9
-  data.tar.gz: 6325fd7e73422455a97ea5479c82d36ef131ad5ba05a982db92d106bf088cd4804dd1126391c377bba7c8a538b56059164a303596123ab3f742c3c719ea71b87
+  metadata.gz: 18578e956daa34b9788d57db6fc5539e0e425c692d672c89302c82051f81a639eff25fbf76570a1b0ac74099051503835fca1912e051086c1a7f6df2ea485e0f
+  data.tar.gz: 2a721eec9c3ba4555a71425111b9ab322913da8df68612e6a08a6f4577c9f3a77793014617742661a4db1bfdede87e65567a8578c5f3511201d7678005e16bc0
+SHA1: 
+  metadata.gz: d8a0f8ef0e451bba4b99236eb653aae4078c498e
+  data.tar.gz: 4cb3c0daad447f88893d8f2ebbd1bf991bea0d10

data/README.md

@@ -20,13 +20,13 @@ It will trigger a pre-defined proc (see below) if the last time the hearbeat job
 
 ## Usage
 
-Configure it first. Optional settings are below. You'll most likely at the least want to tune `:handler`,`:heartbeat` and `:trigger_timeout` settings.
+Configure it first. Optional settings are below. You'll most likely at the least want to tune `:triggered_handler`,`:heartbeat` and `:trigger_timeout` settings.
 
 <pre>
 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') }
+	Resque::StuckQueue.config[:triggered_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.
@@ -93,7 +93,7 @@ namespace :resque do
 
     Resque::StuckQueue.config[:heartbeat] = 10.minutes
     Resque::StuckQueue.config[:trigger_timeout] = 1.hour
-    Resque::StuckQueue.config[:handler] = proc { |queue_name| $stderr.puts("resque queue #{queue_name} wonky!") }
+    Resque::StuckQueue.config[:triggered_handler] = proc { |queue_name| $stderr.puts("resque queue #{queue_name} wonky!") }
 
     Resque::StuckQueue.start # blocking operation, daemon running
   end

data/THOUGHTS

@@ -5,19 +5,16 @@ other resources:
 
 ## TODOS
 
-verifications of @config options: raise if no handler, etc.
-add daemon example to readme
 add a 'resque_stuck_queue/tasks' bit? See tres eg
-require 'resque/stuck_queue' instead?
-ensure the logging gets flushed into log file correctly? (integration with god?)
 add a trap{} to force_stop. ok for overwriting process's trap handlers? use config for that?
 
 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?
+
+rm redis locking (since it works by keys now, no need for it, recover/trigger ping pong).

data/lib/resque_stuck_queue.rb

@@ -7,7 +7,6 @@ require 'resque'
 # TODO rm redis-mutex dep and just do the setnx locking here
 require 'redis-mutex'
 
-require 'logger'
 
 module Resque
   module StuckQueue
@@ -21,7 +20,7 @@ module Resque
       end
 
       def logger
-        @logger ||= (config[:logger] || Logger.new($stdout))
+        @logger ||= (config[:logger] || StuckQueue::LOGGER)
       end
 
       def redis
@@ -35,11 +34,19 @@ module Resque
       end
 
       def heartbeat_key_for(queue)
-        "#{queue}:#{config[:heartbeat_key] || HEARTBEAT_KEY}"
+        if config[:heartbeat_key]
+          "#{queue}:#{config[:heartbeat_key]}"
+        else
+          "#{queue}:#{HEARTBEAT_KEY}"
+        end
       end
 
       def triggered_key_for(queue)
-        "#{queue}:#{config[:triggered_key] || TRIGGERED_KEY}"
+        if config[:triggered_key]
+          "#{queue}:#{config[:triggered_key]}"
+        else
+          "#{queue}:#{TRIGGERED_KEY}"
+        end
       end
 
       def heartbeat_keys
@@ -64,6 +71,8 @@ module Resque
         @threads = []
         config.freeze
 
+        reset_keys
+
         Redis::Classy.db = redis if Redis::Classy.db.nil?
 
         enqueue_repeating_refresh_job
@@ -93,12 +102,19 @@ module Resque
 
       def reset!
         # clean state so we can stop and start in the same process.
-        @config = config.dup #unfreeze
+        @config = Config.new # clear, unfreeze
         @queues = nil
         @running = false
         @logger = nil
       end
 
+      def reset_keys
+        queues.each do |qn|
+          redis.del(heartbeat_key_for(qn))
+          redis.del(triggered_key_for(qn))
+        end
+      end
+
       def stopped?
         @stopped
       end
@@ -139,12 +155,18 @@ module Resque
             if mutex.lock
               begin
                 queues.each do |queue_name|
-                  logger.info("Checking if queue #{queue_name} is lagging")
-                  # else TODO recovered?
+                  logger.info("Lag time for #{queue_name} is #{lag_time(queue_name).inspect} seconds.")
+                  if triggered_ago = last_triggered(queue_name)
+                    logger.info("Last triggered for #{queue_name} is #{triggered_ago.inspect} seconds.")
+                  else
+                    logger.info("No last trigger found for #{queue_name}.")
+                  end
                   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)
+                    logger.info("Triggering :triggered handler for #{queue_name} at #{Time.now}.")
+                    trigger_handler(queue_name, :triggered)
+                  elsif should_recover?(queue_name)
+                    logger.info("Triggering :recovered handler for #{queue_name} at #{Time.now}.")
+                    trigger_handler(queue_name, :recovered)
                   end
                 end
               ensure
@@ -156,29 +178,23 @@ module Resque
         end
       end
 
-      #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)
+          manual_refresh(queue_name, :first_time)
          end.to_i
       end
 
-      def manual_refresh(queue_name, type = :first_time)
+      def manual_refresh(queue_name, type)
         if type == :triggered
           time = Time.now.to_i
           redis.set(triggered_key_for(queue_name), time)
           time
+        elsif type == :recovered
+          redis.del(triggered_key_for(queue_name))
+          nil
         elsif type == :first_time
           time = Time.now.to_i
           redis.set(heartbeat_key_for(queue_name), time)
@@ -197,26 +213,32 @@ module Resque
         end
       end
 
+      def should_recover?(queue_name)
+        last_triggered(queue_name) &&
+          lag_time(queue_name) < max_wait_time
+      end
+
       def should_trigger?(queue_name)
-        if lag_time(queue_name) > max_wait_time
+        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.
+            # if it already triggered in the past and needs to re-trigger,
+            # :recovered should have cleared last_triggered out by then
             return false
           end
         end
       end
 
-      def trigger_handler(queue_name)
-        (config[:handler] || HANDLER).call(queue_name, lag_time(queue_name))
-        manual_refresh(queue_name, :triggered)
+      def trigger_handler(queue_name, type)
+        raise 'Must trigger either the recovered or triggered handler!' unless (type == :recovered || type == :triggered)
+        handler_name = :"#{type}_handler"
+        (config[handler_name] || const_get(handler_name.upcase)).call(queue_name, lag_time(queue_name))
+        manual_refresh(queue_name, type)
       rescue => e
-        logger.info("handler for #{queue_name} crashed: #{e.inspect}")
+        logger.info("handler #{type} for #{queue_name} crashed: #{e.inspect}")
         logger.info("\n#{e.backtrace.join("\n")}")
         force_stop!
       end

data/lib/resque_stuck_queue/config.rb

@@ -1,17 +1,22 @@
 module Resque
   module StuckQueue
 
+    require 'logger'
     # 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}") }
+    LOGGER               = Logger.new($stdout)
+    # must be called by convention: type_handler
+    TRIGGERED_HANDLER    = proc { |queue_name, lag| Resque::StuckQueue::LOGGER.info("Shit gone bad with them queues...on #{queue_name}. Lag time is #{lag}") }
+    RECOVERED_HANDLER    = proc { |queue_name, lag| Resque::StuckQueue::LOGGER.info("recovered queue phew #{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') }",
+        :triggered_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[:triggered_handler] = proc { |queue_name, lagtime| send_email('queue \#{queue_name} isnt working, aaah the daemons') }",
+        :recovered_handler  => "set to what gets triggered when resque-stuck-queue has triggered a problem, but then detects the queue went back down to functioning well again(before the next trigger).\n\tExample:\n\tResque::StuckQueue.config[:recovered_handler] = proc { |queue_name, lagtime| send_email('phew, queue \#{queue_name} is ok') }",
         :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",
@@ -39,7 +44,7 @@ module Resque
 
       def validate_key_exists!(k)
         if ! OPTIONS.include?(k)
-          raise NoConfigError, "no such config key exists!"
+          raise NoConfigError, "no such config key #{k} exists!"
         end
       end
 

data/lib/resque_stuck_queue/version.rb

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

data/test/test_collision.rb

@@ -39,7 +39,7 @@ class TestCollision < Minitest::Test
     Resque::StuckQueue.config[:heartbeat] = 1
     Resque::StuckQueue.config[:abort_on_exception] = true
     Resque::StuckQueue.config[:trigger_timeout] = 3
-    Resque::StuckQueue.config[:handler] = proc { Resque::StuckQueue.redis.incr("test-incr-key") }
+    Resque::StuckQueue.config[:triggered_handler] = proc { Resque::StuckQueue.redis.incr("test-incr-key") }
     Resque::StuckQueue.start
   end
 

data/test/test_config.rb

@@ -10,10 +10,6 @@ class TestConfig < Minitest::Test
     Resque::StuckQueue.config[:abort_on_exception] = true
   end
 
-  def teardown
-    Resque::StuckQueue.reset!
-  end
-
   def test_config_has_descriptions
     c = Resque::StuckQueue::Config.new
     assert c.description_for(:logger) =~ /Logger/, "has descriptions"

data/test/test_integration.rb

@@ -14,8 +14,6 @@ class TestIntegration < Minitest::Test
   include TestHelper
 
   # 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
@@ -44,6 +42,7 @@ class TestIntegration < Minitest::Test
     Resque::StuckQueue.redis.flushall
     Resque::StuckQueue.config[:abort_on_exception] = true
     self.class.run_resque_before_all
+    self.class.tests_ran += 1
   end
 
   def teardown
@@ -56,29 +55,27 @@ class TestIntegration < Minitest::Test
 
   def test_resque_enqueues_a_job_does_not_trigger
     puts "#{__method__}"
-    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 }
+    Resque::StuckQueue.config[:triggered_handler] = proc { @triggered = true }
     start_and_stop_loops_after(5)
     Resque::StuckQueue.redis.del(SetRedisKey::NAME)
     Resque.enqueue_to(:app, SetRedisKey)
     sleep 3
-    assert_equal Resque::StuckQueue.redis.get(SetRedisKey::NAME), "1"
+    #assert_equal Resque::StuckQueue.redis.get(SetRedisKey::NAME), "1" # transient failure: resque picks up jobs at unpredectiple times?
     # job ran successfully, so don't trigger
     assert_equal @triggered, false
   end
 
   def test_resque_does_not_enqueues_a_job_does_trigger
     puts "#{__method__}"
-    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 }
+    Resque::StuckQueue.config[:triggered_handler] = proc { @triggered = true }
     start_and_stop_loops_after(2)
     # check handler did get called
     assert_equal @triggered, true
@@ -86,7 +83,6 @@ class TestIntegration < Minitest::Test
 
   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
@@ -94,7 +90,7 @@ class TestIntegration < Minitest::Test
     begin
       Resque::StuckQueue.config[:refresh_job] = proc { Resque.enqueue(RefreshLatestTimestamp, Resque::StuckQueue.heartbeat_key_for(:app)) }
       @triggered = false
-      Resque::StuckQueue.config[:handler] = proc { @triggered = true }
+      Resque::StuckQueue.config[:triggered_handler] = proc { @triggered = true }
       start_and_stop_loops_after(4)
 
       sleep 3 # allow trigger

data/test/test_lagtime.rb

@@ -22,7 +22,7 @@ class TestLagTime < 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
     @lagtime = 0
-    Resque::StuckQueue.config[:handler] = proc { |queue_name, lagtime| @lagtime = lagtime }
+    Resque::StuckQueue.config[:triggered_handler] = proc { |queue_name, lagtime| @lagtime = lagtime }
     start_and_stop_loops_after(5)
 
     # check handler did get called

data/test/test_named_queues.rb

@@ -28,7 +28,6 @@ class TestNamedQueues < Minitest::Test
   def test_has_custom_queues
     puts "#{__method__}"
     Resque::StuckQueue.config[:queues] = [:foo,:bar]
-    start_and_stop_loops_after(2)
     assert Resque::StuckQueue.heartbeat_keys.include?("foo:resque-stuck-queue"), 'has global keys'
   end
 
@@ -38,7 +37,7 @@ class TestNamedQueues < Minitest::Test
     Resque::StuckQueue.config[:heartbeat] = 1
     Resque::StuckQueue.config[:queues] = [:custom_queue_name]
     @triggered = false
-    Resque::StuckQueue.config[:handler] = proc { |queue_name| @triggered = queue_name }
+    Resque::StuckQueue.config[:triggered_handler] = proc { |queue_name| @triggered = queue_name }
     Resque::StuckQueue.start_in_background
 
     # job gets enqueued successfully
@@ -56,7 +55,7 @@ class TestNamedQueues < Minitest::Test
     Resque::StuckQueue.config[:queues] = [:custom_queue_name, :diff_one]
     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::StuckQueue.config[:triggered_handler] = proc { @triggered = true }
     @resque_pid = run_resque("custom_queue_name")
     Resque::StuckQueue.start_in_background
     sleep 2 # allow timeout to trigger
@@ -65,6 +64,34 @@ class TestNamedQueues < Minitest::Test
     assert_equal @triggered, false
   end
 
+  def test_triggers_once_and_then_recovers
+    # FIXME test refactoring wrong place for this test.
+    puts "#{__method__}"
+
+    Resque::StuckQueue.config[:trigger_timeout] = 2
+    Resque::StuckQueue.config[:heartbeat] = 1
+    Resque::StuckQueue.config[:queues] = [:app]
+
+    @triggered = 0
+    @recovered = 0
+    Resque::StuckQueue.config[:triggered_handler] = proc { @triggered += 1 }
+    Resque::StuckQueue.config[:recovered_handler] = proc { @recovered += 1 }
+
+    Thread.new {
+      # mock a job going through after we trigger :recovered so we'll w/o doing a run_resque
+      Thread.current.abort_on_exception = true
+      sleep 3
+      Resque::StuckQueue.redis.set(Resque::StuckQueue.heartbeat_key_for(:app), Time.now.to_i)
+    }
+    start_and_stop_loops_after(4)
+
+    # check handler did get called ONCE
+    assert_equal @recovered, 1
+    assert_equal @triggered, 1
+  end
+
+
+
 end
 
 

data/test/test_resque_2.rb

@@ -28,7 +28,7 @@ if !ENV['RESQUE_2'].nil?
      Resque::StuckQueue.config[:abort_on_exception] = true
      Resque::StuckQueue.config[:trigger_timeout] = 5
      Resque::StuckQueue.config[:logger] = Logger.new($stdout)
-     Resque::StuckQueue.config[:handler] = proc { Redis.new.incr("test-incr-key") }
+     Resque::StuckQueue.config[:triggered_handler] = proc { Redis.new.incr("test-incr-key") }
      Resque::StuckQueue.config[:redis] = Redis.new
 
      #binding.pry

data/test/test_resque_stuck_queue.rb

@@ -7,7 +7,6 @@ class TestResqueStuckQueue < Minitest::Test
   def teardown
     puts "#{__method__}"
     Resque::StuckQueue.unstub(:read_from_redis)
-    Resque::StuckQueue.config.clear
   end
 
   def setup
@@ -33,29 +32,16 @@ class TestResqueStuckQueue < Minitest::Test
     Resque::StuckQueue.stubs(:read_from_redis).returns(Time.now.to_i)
 
     @triggered = false
-    Resque::StuckQueue.config[:handler] = proc { @triggered = true }
+    Resque::StuckQueue.config[:triggered_handler] = proc { @triggered = true }
     start_and_stop_loops_after(3)
     assert_equal false, @triggered # "handler should not be called"
   end
 
-  def test_it_triggers_handler_if_over_trigger_timeout
-    puts "#{__method__}"
-    Resque::StuckQueue.config[:trigger_timeout] = 2
-    last_time_too_old = Time.now.to_i - Resque::StuckQueue::TRIGGER_TIMEOUT
-    Resque::StuckQueue.stubs(:read_from_redis).returns(last_time_too_old.to_s)
-
-    @triggered = false
-    Resque::StuckQueue.config[:handler] = proc { @triggered = true }
-    start_and_stop_loops_after(2)
-    assert_equal true, @triggered # "handler should be called"
-  end
-
   def test_stops_if_handler_raises
     puts "#{__method__}"
-    Resque::StuckQueue.config[:trigger_timeout] = 1
+    Resque::StuckQueue.config[:trigger_timeout] = 1 # wait a short time, will trigger
     last_time_too_old = Time.now.to_i - Resque::StuckQueue::TRIGGER_TIMEOUT
-    Resque::StuckQueue.stubs(:read_from_redis).returns(last_time_too_old.to_s) # enforce trigger
-    Resque::StuckQueue.config[:handler] = proc { raise "handler had bad sad!" }
+    Resque::StuckQueue.config[:triggered_handler] = proc { raise "handler had bad sad!" }
     Thread.new {
       sleep 3 # should have triggered
       Thread.current.abort_on_exception = true
@@ -64,6 +50,5 @@ class TestResqueStuckQueue < Minitest::Test
     start_and_stop_loops_after(4)
   end
 
-
 end
 

data/test/test_set_custom_refresh_job.rb

@@ -5,6 +5,7 @@ class TestYourOwnRefreshJob < Minitest::Test
   include TestHelper
 
   def setup
+    Resque::StuckQueue.reset!
     Resque::StuckQueue.config[:trigger_timeout] = 1
     Resque::StuckQueue.config[:heartbeat] = 1
     Resque::StuckQueue.config[:abort_on_exception] = true
@@ -13,17 +14,12 @@ class TestYourOwnRefreshJob < Minitest::Test
     Resque::StuckQueue.redis.flushall
   end
 
-  def teardown
-    Resque::StuckQueue.reset!
-    Resque::StuckQueue.config.clear
-  end
-
   def test_will_trigger_with_unrefreshing_custom_heartbeat_job 
     # it will trigger because the key will be unrefreshed, hence 'old' and will always trigger.
     puts "#{__method__}"
     Resque::StuckQueue.config[:refresh_job] = proc { nil } # does not refresh global key
     @triggered = false
-    Resque::StuckQueue.config[:handler] = proc { @triggered = true }
+    Resque::StuckQueue.config[:triggered_handler] = proc { @triggered = true }
     start_and_stop_loops_after(3)
     assert @triggered, "will trigger because global key will be old"
   end
@@ -33,7 +29,7 @@ class TestYourOwnRefreshJob < Minitest::Test
     begin
       Resque::StuckQueue.config[:refresh_job] = proc { raise 'bad proc doc' } # does not refresh global key
       @triggered = false
-      Resque::StuckQueue.config[:handler] = proc { @triggered = true }
+      Resque::StuckQueue.config[:triggered_handler] = proc { @triggered = true }
       start_and_stop_loops_after(3)
       assert false, "should not succeed with bad refresh_job"
     rescue

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: resque_stuck_queue
 version: !ruby/object:Gem::Version 
-  version: 0.0.13
+  version: 0.1.1
 platform: ruby
 authors: 
 - Shai Rosenfeld
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2014-01-26 00:00:00 Z
+date: 2014-01-27 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: redis-mutex