resque-durable 1.0.1 → 2.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b1a9e256ca3afbc5a1605c176de59a028c2546c626f2845c2180bac51dc6b821
+  data.tar.gz: f55e471e1139d717ed4002aff1fc01bef8dfe52649c13a3ee0e5e9fd539237d2
+SHA512:
+  metadata.gz: de3d4efce9c67ea0dcfb7df3d2f19070c01463de09694135cf56b11fc7dcba5ab335412e3b5c8795e58b9a72e807c1277cde95a8250eb7ac8514d30c3bb641bc
+  data.tar.gz: bd6fdfc08faceed5a402a7e7c33f2e2997a82a66d6d4e228dcc3ba34d1ede7f74c890e710572a56ad2b6186436b00a1d8f423cf36771255c568ea9a443fdab5a

data/lib/resque/durable/background_heartbeat.rb

@@ -0,0 +1,82 @@
+require 'thread'
+
+module Resque
+  module Durable
+
+    # Creates a background thread to regularly heartbeat the queue audit.
+    class BackgroundHeartbeat
+
+      def initialize(queue_audit, interval)
+        @queue_audit  = queue_audit
+        @last_timeout = nil
+        @interval     = interval
+        @mutex        = Mutex.new
+        @stop         = false
+        @thread       = nil
+      end
+
+      class << self
+        # only a separate method for easy stubbing
+        def exit_now!
+          abort
+        end
+      end
+
+      def with_heartbeat
+        start!
+        yield
+      ensure
+        stop_and_wait!
+      end
+
+      def heartbeat!
+        @last_timeout ||= @queue_audit.timeout_at
+        @last_timeout = @queue_audit.optimistic_heartbeat!(@last_timeout)
+      rescue StandardError => e
+        @queue_audit.logger.error("Exception in BackgroundHeartbeat thread: #{e.class.name}: #{e.message}")
+        self.class.exit_now!
+      ensure
+        ActiveRecord::Base.clear_active_connections!
+      end
+
+      def start!
+        raise "Thread is already running!" if @thread
+        @stop = false
+
+        # Perform immediately to reduce heartbeat race condition opportunities
+        heartbeat!
+
+        @thread = Thread.new do
+          while !@stop
+            heartbeat!
+
+            @mutex.synchronize do
+              @mutex.sleep(@interval)
+            end
+          end
+        end
+      end
+
+      def stop_and_wait!
+        return unless @thread
+        # Prevent deadlock if called by the `heartbeat` thread, which can't wait for itself to die.
+        return signal_stop! if @thread == Thread.current
+        while @thread.alive?
+          signal_stop!
+          sleep 0.01
+        end
+        @thread.join
+        @thread = nil
+      end
+
+      # Signal the `heartbeat` thread to stop looping immediately. Safe to be call from any thread.
+      def signal_stop!
+        return unless @thread
+        @mutex.synchronize do
+          @stop = true
+          @thread.wakeup
+        end
+      end
+    end
+  end
+end

data/lib/resque/durable/queue_audit.rb

@@ -1,10 +1,12 @@
 require 'active_record'
-require 'active_support/core_ext/class'
+require 'active_support/core_ext'
 
 module Resque
   module Durable
     class QueueAudit < ActiveRecord::Base
-      set_table_name :durable_queue_audits
+      JobCollision = Class.new(StandardError)
+
+      self.table_name = :durable_queue_audits
       # id
       # enqueued_id
       # queue_name
@@ -19,19 +21,18 @@ module Resque
 
       validates_length_of    :payload_before_type_cast, :in => 1..5000
 
-      validates_inclusion_of :duration, :in => 1.minute..3.hours
+      validates_inclusion_of :duration, :in => 1.minute.to_i..3.hours.to_i
 
-      named_scope :older_than, lambda { |date|
-        { :conditions => [ 'created_at < ?', date ] }
-      }
+      scope :older_than, ->(date) { where('created_at < ?', date) }
 
-      named_scope :failed, lambda {
-        { :conditions => [ 'completed_at is null AND timeout_at < ?', Time.now.utc ], :order => 'timeout_at asc', :limit => 500 }
+      scope :failed, -> {
+        where(completed_at: nil)
+          .where('timeout_at < ?', Time.now.utc)
+          .order('timeout_at asc')
+          .limit(500)
       }
 
-      named_scope :complete, lambda {
-        { :conditions => 'completed_at is not null' }
-      }
+      scope :complete, -> { where('completed_at is not null') }
 
       module Recovery
 
@@ -89,6 +90,18 @@ module Resque
         update_attribute(:timeout_at, Time.now.utc + duration)
       end
 
+      # Bumps the `timeout_at` column, but raises a `JobCollision` exception if
+      # another process has changed the value, indicating we may have multiple
+      # workers processing the same job.
+      def optimistic_heartbeat!(last_timeout_at)
+        next_timeout_at = Time.now.utc + duration
+        nrows = self.class.
+          where(id: id, timeout_at: last_timeout_at).
+          update_all(timeout_at: next_timeout_at)
+        raise JobCollision.new unless nrows == 1
+        next_timeout_at
+      end
+
       def fail!
         update_attribute(:timeout_at, Time.now.utc)
       end
@@ -118,6 +131,13 @@ module Resque
         (enqueue_count ** 3).minutes
       end
 
+      def reset_backoff!(timeout_at = Time.now.utc)
+        # Set timeout_at = Time.now and enqueue_count = 1 so
+        # the job can be picked up by the Durable Monitor asap.
+        self.timeout_at = timeout_at
+        self.enqueue_count = 1
+        save!
+      end
     end
   end
 end

data/lib/resque/durable.rb

@@ -3,11 +3,20 @@ module Resque
     autoload :GUID,       'resque/durable/guid'
     autoload :Monitor,    'resque/durable/monitor'
     autoload :QueueAudit, 'resque/durable/queue_audit'
+    autoload :BackgroundHeartbeat, 'resque/durable/background_heartbeat'
 
     def self.extended(base)
+      # The duration since the last heartbeat that the monitor will wait before
+      # re-enqueing the job.
       base.cattr_accessor :job_timeout
       base.job_timeout = 10.minutes
 
+      # How frequently a background thread will optimistically heartbeat the
+      # QueueAudit. Value must be smaller than job_timeout. Currently opt-in.
+      #
+      # Recommended value: `15.seconds`
+      base.cattr_accessor :background_heartbeat_interval
+
       base.cattr_accessor :auditor
       base.auditor = QueueAudit
     end
@@ -24,12 +33,12 @@ module Resque
       begin
         audit.enqueued!
       rescue Exception => e
-        audit_failed(e)
+        audit_failed(e, args)
       end
 
       Resque.enqueue(self, *args)
     rescue Exception => e
-      enqueue_failed(e)
+      enqueue_failed(e, args)
     end
 
     def audit(args)
@@ -46,24 +55,46 @@ module Resque
 
     def around_perform_manage_audit(*args)
       if a = audit(args)
-        a.heartbeat!
         return if a.complete?
-        yield
-        a.complete!
+        if background_heartbeat_interval
+          raise "background_heartbeat_interval (#{background_heartbeat_interval.inspect}) be smaller than job_timeout (#{job_timeout.inspect})" if background_heartbeat_interval >= job_timeout
+          BackgroundHeartbeat.new(audit(args), background_heartbeat_interval).with_heartbeat do
+            yield
+          end
+        else
+          a.heartbeat!
+          yield
+        end
+
+        if requeue_immediately
+          a.reset_backoff!
+        else
+          a.complete!
+        end
       else
         yield
       end
+    ensure
+      @requeue_immediately = false
+    end
+
+    def requeue_immediately
+      @requeue_immediately
+    end
+
+    def requeue_immediately!
+      @requeue_immediately = true
     end
 
     def build_audit(args)
       auditor.initialize_by_klass_and_args(self, args)
     end
 
-    def audit_failed(e)
+    def audit_failed(e, args)
       raise e
     end
 
-    def enqueue_failed(e)
+    def enqueue_failed(e, args)
       raise e
     end
 

metadata

@@ -1,49 +1,63 @@
 --- !ruby/object:Gem::Specification
 name: resque-durable
 version: !ruby/object:Gem::Version
-  version: 1.0.1
-  prerelease: 
+  version: 2.2.0
 platform: ruby
 authors:
 - Eric Chapweske
 - Ben Osheroff
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2012-07-16 00:00:00.000000000 Z
-dependencies: []
-description: 
-email: 
+date: 2021-09-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+description:
+email:
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - lib/resque/durable.rb
+- lib/resque/durable/background_heartbeat.rb
 - lib/resque/durable/guid.rb
 - lib/resque/durable/monitor.rb
 - lib/resque/durable/queue_audit.rb
-homepage: 
-licenses: []
-post_install_message: 
+homepage: https://github.com/zendesk/resque-durable
+licenses:
+- MIT
+metadata: {}
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 1.8.21
-signing_key: 
-specification_version: 3
+rubyforge_project:
+rubygems_version: 2.7.6.2
+signing_key:
+specification_version: 4
 summary: Resque queue backed by database audits, with automatic retry
 test_files: []