que 0.11.6 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1d29adfcb566361924bbd594ba6e5c7b93006060
-  data.tar.gz: 65905d420760dcafc00411f895d6140262d9beb1
+  metadata.gz: dd0f74eb9d94a2f949174b802fdd70f898cfe2e3
+  data.tar.gz: 60c5ea6a16dd1080bc16fcea19250c01e94937f6
 SHA512:
-  metadata.gz: 729dcc64222ed6c9c1d528e72ad4195a9b66aa2275372143f0add9ad051977e967dad6b5dbced2dec86a714553a2994fe2e12e4a2f03224751e2d9670f97d05b
-  data.tar.gz: 1ffb694bd34229a657e203256e85556b9e84bc293681e71cbb80d98cbf21003651d0d9b80d67f34f0849f2f863743a8d08a5bb24a24e7ae6ed7ec7eaa3f149fb
+  metadata.gz: fdc55d830dccfb0eaed7b7220b2bb65a239b0abda3b7cbd749cd87f7835fc6e521db375ef749e0a3f216f82620b6e76fc6dd6edf3b44c5d80f35feb8a43324ea
+  data.tar.gz: cecc9a9a728cf2445ffc4fed02c050972e8903cd4639594b069252e10f130c8dc96ea7bf2305c81f7a2b3e045e416d13198c3009cc08074d4545ebd232ef1f18

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+### 0.12.0 (2016-09-09)
+
+*   The error_handler configuration option has been renamed to error_notifier, which is more descriptive of what it's actually supposed to do. You can still use error_handler for configuration, but you'll get a warning.
+
+*   Introduced a new framework for handling errors on a per-job basis. See the docs for more information. (#106, #147)
+
 ### 0.11.6 (2016-07-01)
 
 *   Fix for operating in nested transactions in Rails 5.0. (#160) (greysteil)
@@ -62,7 +68,7 @@
 
 ### 0.9.0 (2014-12-16)
 
-*   The error_handler callable is now be passed two objects, the error and the job that raised it. If your current error_handler is a proc, as recommended in the docs, you shouldn't need to make any code changes, unless you want to use the job in your error handling. If your error_handler is a lambda, or another callable with a strict arity requirement, you'll want to change it before upgrading. (#69) (statianzo)
+*   The error_handler callable is now passed two objects, the error and the job that raised it. If your current error_handler is a proc, as recommended in the docs, you shouldn't need to make any code changes, unless you want to use the job in your error handling. If your error_handler is a lambda, or another callable with a strict arity requirement, you'll want to change it before upgrading. (#69) (statianzo)
 
 ### 0.8.2 (2014-10-12)
 

data/docs/error_handling.md

@@ -20,10 +20,10 @@ end
 
 Unlike DelayedJob, however, there is currently no maximum number of failures after which jobs will be deleted. Que's assumption is that if a job is erroring perpetually (and not just transiently), you will want to take action to get the job working properly rather than simply losing it silently.
 
-If you're using an error notification system (highly recommended, of course), you can hook Que into it by setting a callable as the error handler:
+If you're using an error notification system (highly recommended, of course), you can hook Que into it by setting a callable as the error notifier:
 
 ```ruby
-Que.error_handler = proc do |error, job|
+Que.error_notifier = proc do |error, job|
   # Do whatever you want with the error object or job row here.
 
   # Note that the job passed is not the actual job object, but the hash

data/lib/que.rb

@@ -48,7 +48,7 @@ module Que
   end
 
   class << self
-    attr_accessor :error_handler
+    attr_accessor :error_notifier
     attr_writer :logger, :adapter, :log_formatter, :disable_prepared_statements, :json_converter
 
     def connection=(connection)
@@ -131,6 +131,16 @@ module Que
       @disable_prepared_statements || false
     end
 
+    def error_handler
+      warn "Que.error_handler has been renamed to Que.error_notifier, please update your code. This shim will be removed in Que version 1.0.0."
+      error_notifier
+    end
+
+    def error_handler=(p)
+      warn "Que.error_handler= has been renamed to Que.error_notifier=, please update your code. This shim will be removed in Que version 1.0.0."
+      self.error_notifier = p
+    end
+
     def constantize(camel_cased_word)
       if camel_cased_word.respond_to?(:constantize)
         # Use ActiveSupport's version if it exists.

data/lib/que/job.rb

@@ -2,7 +2,7 @@
 
 module Que
   class Job
-    attr_reader :attrs
+    attr_reader :attrs, :_error
 
     def initialize(attrs)
       @attrs = attrs
@@ -16,10 +16,35 @@ module Que
     def _run
       run(*attrs[:args])
       destroy unless @destroyed
+    rescue => error
+      @_error = error
+      run_error_notifier = handle_error(error)
+      destroy unless @retried || @destroyed
+
+      if run_error_notifier && Que.error_notifier
+        # Protect the work loop from a failure of the error notifier.
+        Que.error_notifier.call(error, @attrs) rescue nil
+      end
     end
 
     private
 
+    def error_count
+      @attrs[:error_count]
+    end
+
+    def handle_error(error)
+      error_count = @attrs[:error_count] += 1
+      retry_interval = self.class.retry_interval || Job.retry_interval
+      wait = retry_interval.respond_to?(:call) ? retry_interval.call(error_count) : retry_interval
+      retry_in(wait)
+    end
+
+    def retry_in(period)
+      Que.execute :set_error, [period, @_error.message] + @attrs.values_at(:queue, :priority, :run_at, :job_id)
+      @retried = true
+    end
+
     def destroy
       Que.execute :destroy_job, attrs.values_at(:queue, :priority, :run_at, :job_id)
       @destroyed = true
@@ -99,8 +124,13 @@ module Que
                   {:event => :job_race_condition}
                 else
                   klass = class_for(job[:job_class])
-                  klass.new(job)._run
-                  {:event => :job_worked, :job => job}
+                  instance = klass.new(job)
+                  instance._run
+                  if e = instance._error
+                    {:event => :job_errored, :job => job, :error => e}
+                  else
+                    {:event => :job_worked, :job => job}
+                  end
                 end
               else
                 {:event => :job_unavailable}
@@ -112,16 +142,16 @@ module Que
                   interval = klass && klass.respond_to?(:retry_interval) && klass.retry_interval || retry_interval
                   delay    = interval.respond_to?(:call) ? interval.call(count) : interval
                   message  = "#{error.message}\n#{error.backtrace.join("\n")}"
-                  Que.execute :set_error, [count, delay, message] + job.values_at(:queue, :priority, :run_at, :job_id)
+                  Que.execute :set_error, [delay, message] + job.values_at(:queue, :priority, :run_at, :job_id)
                 end
               rescue
                 # If we can't reach the database for some reason, too bad, but
                 # don't let it crash the work loop.
               end
 
-              if Que.error_handler
-                # Similarly, protect the work loop from a failure of the error handler.
-                Que.error_handler.call(error, job) rescue nil
+              if Que.error_notifier
+                # Similarly, protect the work loop from a failure of the error notifier.
+                Que.error_notifier.call(error, job) rescue nil
               end
 
               return {:event => :job_errored, :error => error, :job => job}

data/lib/que/sql.rb

@@ -88,13 +88,13 @@ module Que
 
     :set_error => %{
       UPDATE que_jobs
-      SET error_count = $1::integer,
-          run_at      = now() + $2::bigint * '1 second'::interval,
-          last_error  = $3::text
-      WHERE queue     = $4::text
-      AND   priority  = $5::smallint
-      AND   run_at    = $6::timestamptz
-      AND   job_id    = $7::bigint
+      SET error_count = error_count + 1,
+          run_at      = now() + $1::bigint * '1 second'::interval,
+          last_error  = $2::text
+      WHERE queue     = $3::text
+      AND   priority  = $4::smallint
+      AND   run_at    = $5::timestamptz
+      AND   job_id    = $6::bigint
     }.freeze,
 
     :insert_job => %{

data/lib/que/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Que
-  Version = '0.11.6'
+  Version = '0.12.0'
 end

data/spec/unit/work_spec.rb

@@ -237,7 +237,7 @@ describe Que::Job, '.work' do
       DB[:que_jobs].count.should be 1
       job = DB[:que_jobs].first
       job[:error_count].should be 1
-      job[:last_error].should =~ /\AErrorJob!\n/
+      job[:last_error].should =~ /\AErrorJob!/
       job[:run_at].should be_within(3).of Time.now + 4
 
       DB[:que_jobs].update :error_count => 5,
@@ -251,7 +251,7 @@ describe Que::Job, '.work' do
       DB[:que_jobs].count.should be 1
       job = DB[:que_jobs].first
       job[:error_count].should be 6
-      job[:last_error].should =~ /\AErrorJob!\n/
+      job[:last_error].should =~ /\AErrorJob!/
       job[:run_at].should be_within(3).of Time.now + 1299
     end
 
@@ -270,7 +270,7 @@ describe Que::Job, '.work' do
       DB[:que_jobs].count.should be 1
       job = DB[:que_jobs].first
       job[:error_count].should be 1
-      job[:last_error].should =~ /\AErrorJob!\n/
+      job[:last_error].should =~ /\AErrorJob!/
       job[:run_at].to_f.should be_within(3).of Time.now.to_f + RetryIntervalJob.retry_interval
 
       DB[:que_jobs].update :error_count => 5,
@@ -284,7 +284,7 @@ describe Que::Job, '.work' do
       DB[:que_jobs].count.should be 1
       job = DB[:que_jobs].first
       job[:error_count].should be 6
-      job[:last_error].should =~ /\AErrorJob!\n/
+      job[:last_error].should =~ /\AErrorJob!/
       job[:run_at].to_f.should be_within(3).of Time.now.to_f + RetryIntervalJob.retry_interval
     end
 
@@ -303,7 +303,7 @@ describe Que::Job, '.work' do
       DB[:que_jobs].count.should be 1
       job = DB[:que_jobs].first
       job[:error_count].should be 1
-      job[:last_error].should =~ /\AErrorJob!\n/
+      job[:last_error].should =~ /\AErrorJob!/
       job[:run_at].should be_within(3).of Time.now + 10
 
       DB[:que_jobs].update :error_count => 5,
@@ -317,14 +317,14 @@ describe Que::Job, '.work' do
       DB[:que_jobs].count.should be 1
       job = DB[:que_jobs].first
       job[:error_count].should be 6
-      job[:last_error].should =~ /\AErrorJob!\n/
+      job[:last_error].should =~ /\AErrorJob!/
       job[:run_at].should be_within(3).of Time.now + 60
     end
 
-    it "should pass it to an error handler, if one is defined" do
+    it "should pass it to an error notifier, if one is defined" do
       begin
         errors = []
-        Que.error_handler = proc { |error| errors << error }
+        Que.error_notifier = proc { |error| errors << error }
 
         ErrorJob.enqueue
 
@@ -338,14 +338,14 @@ describe Que::Job, '.work' do
         error.should be_an_instance_of RuntimeError
         error.message.should == "ErrorJob!"
       ensure
-        Que.error_handler = nil
+        Que.error_notifier = nil
       end
     end
 
-    it "should pass job to an error handler, if one is defined" do
+    it "should pass job to an error notifier, if one is defined" do
       begin
         jobs = []
-        Que.error_handler = proc { |error, job| jobs << job }
+        Que.error_notifier = proc { |error, job| jobs << job }
 
         ErrorJob.enqueue
         result = Que::Job.work
@@ -354,20 +354,20 @@ describe Que::Job, '.work' do
         job = jobs[0]
         job.should be result[:job]
       ensure
-        Que.error_handler = nil
+        Que.error_notifier = nil
       end
     end
 
-    it "should not do anything if the error handler itelf throws an error" do
+    it "should not do anything if the error notifier itelf throws an error" do
       begin
-        Que.error_handler = proc { |error| raise "Another error!" }
+        Que.error_notifier = proc { |error| raise "Another error!" }
         ErrorJob.enqueue
 
         result = Que::Job.work
         result[:event].should == :job_errored
         result[:error].should be_an_instance_of RuntimeError
       ensure
-        Que.error_handler = nil
+        Que.error_notifier = nil
       end
     end
 
@@ -403,5 +403,151 @@ describe Que::Job, '.work' do
       job[:error_count].should be 1
       job[:run_at].should be_within(3).of Time.now + 4
     end
+
+    context "in a job class that has a custom error handler" do
+      it "should allow it to schedule a retry after a specific interval" do
+        begin
+          error = nil
+          Que.error_notifier = proc { |e| error = e }
+
+          class CustomRetryIntervalJob < Que::Job
+            def run(*args)
+              raise "Blah!"
+            end
+
+            private
+
+            def handle_error(error)
+              retry_in(42)
+            end
+          end
+
+          CustomRetryIntervalJob.enqueue
+
+          result = Que::Job.work
+          result[:event].should == :job_errored
+          result[:error].should be_an_instance_of RuntimeError
+          result[:job][:job_class].should == 'CustomRetryIntervalJob'
+
+          DB[:que_jobs].count.should be 1
+          job = DB[:que_jobs].first
+          job[:error_count].should be 1
+          job[:last_error].should =~ /\ABlah!/
+          job[:run_at].should be_within(3).of Time.now + 42
+
+          error.should == result[:error]
+        ensure
+          Que.error_notifier = nil
+        end
+      end
+
+      it "should allow it to destroy the job" do
+        begin
+          error = nil
+          Que.error_notifier = proc { |e| error = e }
+
+          class CustomRetryIntervalJob < Que::Job
+            def run(*args)
+              raise "Blah!"
+            end
+
+            private
+
+            def handle_error(error)
+              destroy
+            end
+          end
+
+          CustomRetryIntervalJob.enqueue
+
+          result = Que::Job.work
+          result[:event].should == :job_errored
+          result[:error].should be_an_instance_of RuntimeError
+          result[:job][:job_class].should == 'CustomRetryIntervalJob'
+
+          DB[:que_jobs].count.should be 0
+
+          error.should == result[:error]
+        ensure
+          Que.error_notifier = nil
+        end
+      end
+
+      it "should allow it to return false to skip the error notification" do
+        begin
+          error = nil
+          Que.error_notifier = proc { |e| error = e }
+
+          class CustomRetryIntervalJob < Que::Job
+            def run(*args)
+              raise "Blah!"
+            end
+
+            private
+
+            def handle_error(error)
+              false
+            end
+          end
+
+          CustomRetryIntervalJob.enqueue
+
+          result = Que::Job.work
+          result[:event].should == :job_errored
+          result[:error].should be_an_instance_of RuntimeError
+          result[:job][:job_class].should == 'CustomRetryIntervalJob'
+
+          DB[:que_jobs].count.should be 0
+
+          error.should == nil
+        ensure
+          Que.error_notifier = nil
+        end
+      end
+
+      it "should allow it to call super to get the default behavior" do
+        begin
+          error = nil
+          Que.error_notifier = proc { |e| error = e }
+
+          class CustomRetryIntervalJob < Que::Job
+            def run(*args)
+              raise "Blah!"
+            end
+
+            private
+
+            def handle_error(error)
+              case error
+              when RuntimeError
+                super
+              else
+                $error_handler_failed = true
+                raise "Bad!"
+              end
+            end
+          end
+
+          CustomRetryIntervalJob.enqueue
+
+          result = Que::Job.work
+          result[:event].should == :job_errored
+          result[:error].should be_an_instance_of RuntimeError
+          result[:job][:job_class].should == 'CustomRetryIntervalJob'
+
+          $error_handler_failed.should == nil
+
+          DB[:que_jobs].count.should be 1
+          job = DB[:que_jobs].first
+          job[:error_count].should be 1
+          job[:last_error].should =~ /\ABlah!/
+          job[:run_at].should be_within(3).of Time.now + 4
+
+          error.should == result[:error]
+        ensure
+          Que.error_notifier = nil
+        end
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: que
 version: !ruby/object:Gem::Version
-  version: 0.11.6
+  version: 0.12.0
 platform: ruby
 authors:
 - Chris Hanks
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-01 00:00:00.000000000 Z
+date: 2016-09-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler