inst-jobs 1.0.4 → 2.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b7018574b89f64cc8e0a8e601ba594b2ae346cd1fed66237a62b02a71cdaa14c
-  data.tar.gz: bb5865eb7e5933717394ef47e85904827d4e065a2994de2eb9d7c4a43790da80
+  metadata.gz: 4c31ed6d846425c9bf022bb8c744681019cbf0f0192d4e0ee7f0a5d7dc44a65c
+  data.tar.gz: 4a5b940ba8bd6770209d93e20ccc217d4ab5915bcd1a5791de70b076e7cecf97
 SHA512:
-  metadata.gz: 9eeed8f4e9f853ed216c1c1817ab499f27ca6fe4c66837ce07b6e54e4d81f5ada261f19180403f9c6cf211f32daec480559ae9566f5d76b5c975196fe7998688
-  data.tar.gz: fea866765cec29e00c5b94da17d5ce3f0b432ca6d79111325d5fee2829a33b3bc445896079fe93d0a70537a59abc0dddd45d8869a32ab1c1e0e6ab3c24848482
+  metadata.gz: 07377763c26979774add4b3445aa72ebc2cbff6aabe595e1157c883a90dea48407bc8ecb87f5532265178a96b27548caaf5ce13a0789c469272980bc864a2882
+  data.tar.gz: 7ddd291e18be337ae1d858d016af92cc255c111e5141eafca8cee598fcdae9563a74983ba6b98daeb50c1fe599490dd9c962e1c722d5dcea5083bf16a619641d

data/lib/delayed/backend/base.rb

@@ -87,6 +87,10 @@ module Delayed
             batches[batch_enqueue_args] << kwargs
             return true
           else
+            if kwargs[:on_conflict].present?
+              Delayed::Logging.logger.warn("[DELAYED_JOB] WARNING: providing 'on_conflict' as an option to a non-singleton job will have no effect.  Discarding.")
+              kwargs.delete(:on_conflict)
+            end
             job = self.create(**kwargs)
           end
 
@@ -178,6 +182,10 @@ module Delayed
         expires_at && (self.class.db_time_now >= expires_at)
       end
 
+      def inferred_max_attempts
+        self.max_attempts || Delayed::Settings.max_attempts
+      end
+
       # Reschedule the job in the future (when a job fails).
       # Uses an exponential scale depending on the number of failed attempts.
       def reschedule(error = nil, time = nil)
@@ -190,7 +198,7 @@ module Delayed
 
         self.attempts += 1 unless return_code == :unlock
 
-        if self.attempts >= (self.max_attempts || Delayed::Settings.max_attempts)
+        if self.attempts >= self.inferred_max_attempts
           permanent_failure error || "max attempts reached"
         elsif expired?
           permanent_failure error || "job has expired"

data/lib/delayed/lifecycle.rb

@@ -12,6 +12,7 @@ module Delayed
       :loop             => [:worker],
       :perform          => [:worker, :job],
       :pop              => [:worker],
+      :retry            => [:worker, :job, :exception],
       :work_queue_pop   => [:work_queue, :worker_config],
       :check_for_work   => [:work_queue],
     }

data/lib/delayed/periodic.rb

@@ -49,10 +49,23 @@ class Periodic
   end
 
   def enqueue
-    Delayed::Job.enqueue(self, **@job_args.merge(:max_attempts => 1,
-                                                 :run_at => @cron.next_time(Delayed::Periodic.now).utc.to_time,
-                                                 :singleton => tag,
-                                                 on_conflict: :patient))
+    Delayed::Job.enqueue(self, **enqueue_args)
+  end
+
+  def enqueue_args
+    # yes, checking for whether it is actually the boolean literal false,
+    # which means the consuming code really does not want this job to be
+    # a singleton at all.
+    non_singleton_periodic_job = @job_args[:singleton] == false
+    inferred_args = {
+      max_attempts: 1,
+      run_at: @cron.next_time(Delayed::Periodic.now).utc.to_time,
+      singleton: (non_singleton_periodic_job ? nil : tag)
+    }
+    unless non_singleton_periodic_job
+      inferred_args[:on_conflict] = :patient
+    end
+    @job_args.merge(inferred_args)
   end
 
   def perform

data/lib/delayed/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Delayed
-  VERSION = "1.0.4"
+  VERSION = "2.1.3"
 end

data/lib/delayed/worker.rb

@@ -3,6 +3,17 @@
 module Delayed
 
 class TimeoutError < RuntimeError; end
+class RetriableError < RuntimeError
+  # this error is a special case.  You _should_ raise
+  # it from inside the rescue block for another error, 
+  # because it indicates: "something made this job fail
+  # but we're pretty sure it's transient and it's safe to try again".
+  # the workflow is still the same (retry will happen unless
+  # retries are exhausted), but it won't call the :error
+  # callback unless it can't retry anymore.  It WILL call the
+  # separate ":retry" callback, which is ONLY activated
+  # for this kind of error.
+end
 
 require 'tmpdir'
 require 'set'
@@ -94,7 +105,11 @@ class Worker
   end
 
   def exit?
-    @exit
+    !!@exit || parent_exited?
+  end
+
+  def parent_exited?
+    @parent_pid && @parent_pid != Process.ppid
   end
 
   def wake_up
@@ -198,32 +213,38 @@ class Worker
   end
 
   def perform(job)
-    count = 1
-    raise Delayed::Backend::JobExpired, "job expired at #{job.expires_at}" if job.expired?
-    self.class.lifecycle.run_callbacks(:perform, self, job) do
-      set_process_name("run:#{Settings.worker_procname_prefix}#{job.id}:#{job.name}")
-      logger.info("Processing #{log_job(job, :long)}")
-      runtime = Benchmark.realtime do
-        if job.batch?
-          # each job in the batch will have perform called on it, so we don't
-          # need a timeout around this
-          count = perform_batch(job)
-        else
-          job.invoke_job
+    begin
+      count = 1
+      raise Delayed::Backend::JobExpired, "job expired at #{job.expires_at}" if job.expired?
+      self.class.lifecycle.run_callbacks(:perform, self, job) do
+        set_process_name("run:#{Settings.worker_procname_prefix}#{job.id}:#{job.name}")
+        logger.info("Processing #{log_job(job, :long)}")
+        runtime = Benchmark.realtime do
+          if job.batch?
+            # each job in the batch will have perform called on it, so we don't
+            # need a timeout around this
+            count = perform_batch(job)
+          else
+            job.invoke_job
+          end
+          job.destroy
         end
-        job.destroy
+        logger.info("Completed #{log_job(job)} #{"%.0fms" % (runtime * 1000)}")
+      end
+    rescue ::Delayed::RetriableError => re
+      can_retry = job.attempts + 1 < job.inferred_max_attempts
+      callback_type = can_retry ? :retry : :error
+      self.class.lifecycle.run_callbacks(callback_type, self, job, re) do
+        handle_failed_job(job, re)
+      end
+    rescue SystemExit => se
+      # There wasn't really a failure here so no callbacks and whatnot needed,
+      # still reschedule the job though.
+      job.reschedule(se)
+    rescue Exception => e
+      self.class.lifecycle.run_callbacks(:error, self, job, e) do
+        handle_failed_job(job, e)
       end
-      logger.info("Completed #{log_job(job)} #{"%.0fms" % (runtime * 1000)}")
-    end
-    count
-  rescue SystemExit => se
-    # There wasn't really a failure here so no callbacks and whatnot needed,
-    # still reschedule the job though.
-    job.reschedule(se)
-    count
-  rescue Exception => e
-    self.class.lifecycle.run_callbacks(:error, self, job, e) do
-      handle_failed_job(job, e)
     end
     count
   end

data/lib/delayed/worker/health_check.rb

@@ -22,31 +22,46 @@ module Delayed
 
         def reschedule_abandoned_jobs
           return if Settings.worker_health_check_type == :none
+          Delayed::Job.transaction do
+            # this job is a special case, and is not a singleton
+            # because if it gets wiped out suddenly during execution
+            # it can't go clean up it's abandoned self.  Therefore,
+            # we try to get an advisory lock when it runs.  If we succeed,
+            # no other job is trying to do this right now (and if we abandon the
+            # job, the transaction will end, releasing the advisory lock).
+            result = attempt_advisory_lock
+            return unless result
+            checker = Worker::HealthCheck.build(
+              type: Settings.worker_health_check_type,
+              config: Settings.worker_health_check_config,
+              worker_name: 'cleanup-crew'
+            )
+            live_workers = checker.live_workers
 
-          checker = Worker::HealthCheck.build(
-            type: Settings.worker_health_check_type,
-            config: Settings.worker_health_check_config,
-            worker_name: 'cleanup-crew'
-          )
-          live_workers = checker.live_workers
-
-          Delayed::Job.running_jobs.each do |job|
-            # prefetched jobs have their own way of automatically unlocking themselves
-            next if job.locked_by.start_with?("prefetch:")
-            unless live_workers.include?(job.locked_by)
-              begin
-                Delayed::Job.transaction do
-                  # double check that the job is still there. locked_by will immediately be reset
-                  # to nil in this transaction by Job#reschedule
-                  next unless Delayed::Job.where(id: job, locked_by: job.locked_by).update_all(locked_by: "abandoned job cleanup") == 1
-                  job.reschedule
+            Delayed::Job.running_jobs.each do |job|
+              # prefetched jobs have their own way of automatically unlocking themselves
+              next if job.locked_by.start_with?("prefetch:")
+              unless live_workers.include?(job.locked_by)
+                begin
+                  Delayed::Job.transaction do
+                    # double check that the job is still there. locked_by will immediately be reset
+                    # to nil in this transaction by Job#reschedule
+                    next unless Delayed::Job.where(id: job, locked_by: job.locked_by).update_all(locked_by: "abandoned job cleanup") == 1
+                    job.reschedule
+                  end
+                rescue
+                  ::Rails.logger.error "Failure rescheduling abandoned job #{job.id} #{$!.inspect}"
                 end
-              rescue
-                ::Rails.logger.error "Failure rescheduling abandoned job #{job.id} #{$!.inspect}"
               end
             end
           end
         end
+
+        def attempt_advisory_lock
+          lock_name = "Delayed::Worker::HealthCheck#reschedule_abandoned_jobs"
+          conn = ActiveRecord::Base.connection
+          conn.select_value("SELECT pg_try_advisory_xact_lock(#{conn.quote_table_name('half_md5_as_bigint')}('#{lock_name}'));")
+        end
       end
 
       attr_accessor :config, :worker_name

data/spec/delayed/periodic_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Delayed::Periodic do
+  around(:each) do |block|
+    # make sure we can use ".cron" and
+    # such safely without leaking global state
+    prev_sched = Delayed::Periodic.scheduled
+    prev_ovr = Delayed::Periodic.overrides
+    Delayed::Periodic.scheduled = {}
+    Delayed::Periodic.overrides = {}
+    block.call
+  ensure
+    Delayed::Periodic.scheduled = prev_sched
+    Delayed::Periodic.overrides = prev_ovr
+    Delayed::Job.delete_all
+  end
+
+  describe ".cron" do
+    let(:job_name){ 'just a test'}
+    it "provides a tag by default for periodic jobs" do
+      Delayed::Periodic.cron job_name, '*/10 * * * *' do
+        # no-op
+      end
+      instance = Delayed::Periodic.scheduled[job_name]
+      expect(instance).to_not be_nil
+      expect(instance.enqueue_args[:singleton]).to eq("periodic: just a test")
+    end
+
+    it "uses no singleton if told to skip" do
+      Delayed::Periodic.cron job_name, '*/10 * * * *', {singleton: false} do
+        # no-op
+      end
+      instance = Delayed::Periodic.scheduled[job_name]
+      expect(instance).to_not be_nil
+      expect(instance.enqueue_args[:singleton]).to be_nil
+      Delayed::Periodic.perform_audit!
+    end
+  end
+end

data/spec/delayed/worker/health_check_spec.rb

@@ -107,6 +107,15 @@ RSpec.describe Delayed::Worker::HealthCheck do
       @dead_job.reload
       expect(@dead_job.locked_by).to eq 'prefetch:some_node'
     end
+
+    it "bails immediately if advisory lock already taken" do
+      allow(Delayed::Worker::HealthCheck).to receive(:attempt_advisory_lock).and_return(false)
+      Delayed::Worker::HealthCheck.reschedule_abandoned_jobs
+      @dead_job.reload
+      expect(@dead_job.run_at.to_i).to eq(initial_run_at.to_i)
+      expect(@dead_job.locked_at).to_not be_nil
+      expect(@dead_job.locked_by).to_not be_nil
+    end
   end
 
   describe '#initialize' do

data/spec/delayed/worker_spec.rb

@@ -6,6 +6,11 @@ describe Delayed::Worker do
   let(:worker_config) { {
       queue: "test", min_priority: 1, max_priority: 2, stuff: "stuff",
   }.freeze }
+  let(:job_attrs) { {
+    id: 42, name: "testjob", full_name: "testfullname", :last_error= => nil,
+    attempts: 1, reschedule: nil, :expired? => false,
+    payload_object: {}, priority: 25
+  }.freeze }
   subject { described_class.new(worker_config.dup) }
 
   after { Delayed::Worker.lifecycle.reset! }
@@ -14,9 +19,24 @@ describe Delayed::Worker do
     it "fires off an error callback when a job raises an exception" do
       fired = false
       Delayed::Worker.lifecycle.before(:error) {|worker, exception| fired = true}
-      job = double(:last_error= => nil, attempts: 1, reschedule: nil)
-      subject.perform(job)
+      job = double(job_attrs)
+      output_count = subject.perform(job)
       expect(fired).to be_truthy
+      expect(output_count).to eq(1)
+    end
+
+    it "uses the retry callback for a retriable exception" do
+      error_fired = retry_fired = false
+      Delayed::Worker.lifecycle.before(:error) {|worker, exception| error_fired = true }
+      Delayed::Worker.lifecycle.before(:retry) {|worker, exception| retry_fired = true}
+      job = Delayed::Job.new(payload_object: {}, priority: 25, strand: "test_jobs", max_attempts: 3)
+      expect(job).to receive(:invoke_job) do
+        raise Delayed::RetriableError, "that's all this job does"
+      end
+      output_count = subject.perform(job)
+      expect(error_fired).to be_falsey
+      expect(retry_fired).to be_truthy
+      expect(output_count).to eq(1)
     end
 
     it "reloads" do
@@ -35,7 +55,7 @@ describe Delayed::Worker do
         expect(ActionDispatch::Reloader).to receive(:prepare!).once
         expect(ActionDispatch::Reloader).to receive(:cleanup!).once
       end
-      job = double(:last_error= => nil, attempts: 0, reschedule: nil, expired?: false)
+      job = double(job_attrs)
       subject.perform(job)
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: inst-jobs
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 2.1.3
 platform: ruby
 authors:
 - Tobias Luetke
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-11-25 00:00:00.000000000 Z
+date: 2020-12-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -412,6 +412,7 @@ files:
 - spec/delayed/cli_spec.rb
 - spec/delayed/daemon_spec.rb
 - spec/delayed/message_sending_spec.rb
+- spec/delayed/periodic_spec.rb
 - spec/delayed/server_spec.rb
 - spec/delayed/settings_spec.rb
 - spec/delayed/work_queue/in_process_spec.rb
@@ -448,7 +449,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.3'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -480,6 +481,7 @@ test_files:
 - spec/delayed/cli_spec.rb
 - spec/delayed/daemon_spec.rb
 - spec/delayed/worker_spec.rb
+- spec/delayed/periodic_spec.rb
 - spec/delayed/message_sending_spec.rb
 - spec/delayed/settings_spec.rb
 - spec/delayed/work_queue/in_process_spec.rb