queue_classic_plus 4.0.0.alpha18 → 4.0.0.alpha20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f4194444b2e3b6bc8d08ebfe7393e9efa53bc31fdb8c7e79c5b1a6aff31e8776
-  data.tar.gz: a12f2b01acea5e2fb4fc6e6b257c6aafc228ff38f73280a3deb974452f2e7220
+  metadata.gz: 4e0d46c9b50526efda508c6b06114bff55fe3fe3d34f519b2fb65d55f4b16848
+  data.tar.gz: fd2fa603af9a4e4f65f3021b8e84b1c25f6effa68aed4d5b81b980b04def5b09
 SHA512:
-  metadata.gz: 42399e627f40795df59f4235e6d616527506758af7a988c2e7e923ce3fbad2bac49b188563ad508d66e95f9935149eaafd1928d6eac6c97bfeb9f1a437fffabe
-  data.tar.gz: b08d05305a8772d2aacf0e5984b5d2254f3b1f83cb8e6d4d02b7f1bb3d929d70e3ddd02b1130f9845ebec3d9ef409d7a86d63f44ff04ea3fb998dd0cab2080a0
+  metadata.gz: d19aa544d277fcf0f04954fa9f3dfeb476435e2a4342663c73faa3150d40175b7ab7079550fa469e8b488b41a97e55d46950990714ba4898710bb42e27493672
+  data.tar.gz: c3ed2d8b5cbfcf0e8d1ecfd9bc0432f9c2b371061d5b5473df96d7e299a1ccb4d283a66dc7316de8a6719312254d3eafd9e3ae735b5876b7000334fda040f52e

data/README.md

@@ -124,6 +124,59 @@ class Jobs::NoTransaction < QueueClassicPlus::Base
 end
 ```
 
+
+#### Callbacks
+
+Jobs support the following callbacks:
+```
+before_enqueue
+after_enqueue
+before_perform
+after_perform
+```
+
+- `enqueue` callbacks are called when the job is initially enqueued. Caveats:
+  - not called on retries
+  - not called when scheduled in the future (i.e. `Job.enqueue_perform_in`)
+  - still called if enqueuing fails because a job with `lock!` is already enqueued. 
+- `perform` callbacks are called any time the job is picked up and run by a worker, including retries and jobs scheduled in the future.
+
+Callbacks can either be implemented by providing a method to be called:
+
+```ruby
+class Jobs::WithCallbackMethods < QueueClassicPlus::Base
+  before_enqueue :before_enqueue_method
+
+  @queue = :low
+
+  def self.before_enqueue_method(*args)
+    # ...
+  end
+
+  def self.perform(user_id)
+    # ...
+  end
+end
+```
+
+or by providing a block:
+
+```ruby
+class Jobs::WithCallbackBlocks < QueueClassicPlus::Base
+  before_enqueue do |*args|
+    # ...
+  end
+
+  @queue = :low
+
+  def self.perform(user_id)
+    # ...
+  end
+end
+```
+
+The `args` passed to the callback method/block will be the same as the arguments passed to `QueueClassicPlus::Base.do` and `QueueClassicPlus::Base.perform`. 
+
 ## Advanced configuration
 
 If you want to log exceptions in your favorite exception tracker. You can configured it like so:

data/lib/queue_classic_plus/base.rb

@@ -136,6 +136,22 @@ module QueueClassicPlus
       end
     end
 
+    def self.before_enqueue(callback_method = nil, &block)
+      define_callback(:enqueue, :before, callback_method, &block)
+    end
+
+    def self.after_enqueue(callback_method = nil, &block)
+      define_callback(:enqueue, :after, callback_method, &block)
+    end
+
+    def self.before_perform(callback_method = nil, &block)
+      define_callback(:perform, :before, callback_method, &block)
+    end
+
+    def self.after_perform(callback_method = nil, &block)
+      define_callback(:perform, :after, callback_method, &block)
+    end
+
     # Debugging
     def self.list
       q = "SELECT * FROM queue_classic_jobs WHERE q_name = '#{@queue}'"
@@ -165,5 +181,26 @@ module QueueClassicPlus
     def self.execute(sql, *args)
       QC.default_conn_adapter.execute(sql, *args)
     end
+
+    def self.define_callback(name, type, callback_method, &_block)
+      singleton_class.prepend(
+        Module.new do |callback_module|
+          callback_module.define_method(name) do |*args|
+            callback_args = args
+              if name == :enqueue
+                callback_args = callback_args.drop(1) # Class/method is the first argument. Callbacks don't need that.
+              end
+
+              if type == :before
+                block_given? ? yield(*callback_args) : send(callback_method, *callback_args)
+              end
+              super(*args)
+              if type == :after
+                block_given? ? yield(*callback_args) : send(callback_method, *callback_args)
+              end
+          end
+        end
+      )
+    end
   end
 end

data/lib/queue_classic_plus/version.rb

@@ -1,3 +1,3 @@
 module QueueClassicPlus
-  VERSION = '4.0.0.alpha18'.freeze
+  VERSION = '4.0.0.alpha20'.freeze
 end

data/lib/queue_classic_plus/worker.rb

@@ -26,15 +26,19 @@ module QueueClassicPlus
 
       @failed_job = job
       @raw_args = job[:args]
-      @failed_job_args = failed_job_class ? failed_job_class.deserialized(@raw_args) : @raw_args
-
-      if force_retry && !(failed_job_class.respond_to?(:disable_retries) && failed_job_class.disable_retries)
-        Metrics.increment("qc.force_retry", source: @q_name)
-        retry_with_remaining(e)
-      # The mailers doesn't have a retries_on?
-      elsif failed_job_class.respond_to?(:retries_on?) && failed_job_class.retries_on?(e)
-        Metrics.increment("qc.retry", source: @q_name)
-        retry_with_remaining(e)
+
+      if queue_classic_plus_job?
+        @failed_job_args = failed_job_class.deserialized(@raw_args)
+
+        if force_retry && !failed_job_class.disable_retries
+          Metrics.increment("qc.force_retry", source: @q_name)
+          retry_with_remaining(e)
+        elsif failed_job_class.retries_on?(e)
+          Metrics.increment("qc.retry", source: @q_name)
+          retry_with_remaining(e)
+        else
+          enqueue_failed(e)
+        end
       else
         enqueue_failed(e)
       end
@@ -60,10 +64,20 @@ module QueueClassicPlus
       (@failed_job[:remaining_retries] || max_retries).to_i
     end
 
+    def queue_classic_plus_job?
+      failed_job_class && failed_job_class < Base
+    end
+
     def failed_job_class
-      Object.const_get(@failed_job[:method].split('.')[0])
-    rescue NameError
-      nil
+      return @failed_job_class if @failed_job_class_memoized
+
+      @failed_job_class_memoized = true
+      @failed_job_class =
+      begin
+        Object.const_get(@failed_job[:method].split('.')[0])
+      rescue NameError
+        nil
+      end
     end
 
     def backoff

data/spec/base_spec.rb

@@ -184,6 +184,172 @@ describe QueueClassicPlus::Base do
         subject._perform(42, true)
       end
     end
+
+    context "with callbacks defined" do
+      subject do
+        Class.new(QueueClassicPlus::Base) do
+          @queue = :test
+
+          before_enqueue :before_enqueue_method
+          after_enqueue :after_enqueue_method
+
+          before_perform :before_perform_method
+          after_perform :after_perform_method
+
+          def self.before_enqueue_method(*_args); end;
+          def self.after_enqueue_method(*_args); end;
+          def self.before_perform_method(*_args); end;
+          def self.after_perform_method(*_args); end;
+
+          def self.perform(*_args); end;
+        end
+      end
+
+      it "passes enqueue arguments to callbacks" do
+        expect(subject).to receive(:before_enqueue_method).with("enqueue_argument").once
+        expect(subject).to receive(:after_enqueue_method).with("enqueue_argument").once
+
+        subject.do("enqueue_argument")
+      end
+
+      it "passes perform arguments to callbacks" do
+        expect(subject).to receive(:before_perform_method).with("perform_argument").once
+        expect(subject).to receive(:after_perform_method).with("perform_argument").once
+
+        subject.perform("perform_argument")
+      end
+
+      context "when enqueued" do
+        it "calls the enqueue callback methods" do
+          expect(subject).to receive(:before_enqueue_method).once
+          expect(subject).to receive(:after_enqueue_method).once
+
+          subject.do
+        end
+
+        it "does not call the perform callbacks" do
+          expect(subject).to_not receive(:before_perform_method)
+          expect(subject).to_not receive(:after_perform_method)
+
+          subject.do
+        end
+      end
+
+      context "when perform" do
+        it "calls the perform callback methods" do
+          expect(subject).to receive(:before_perform_method).once
+          expect(subject).to receive(:after_perform_method).once
+
+          subject.perform
+        end
+
+        it "does not call the enqueue callbacks" do
+          expect(subject).to_not receive(:before_enqueue_method)
+          expect(subject).to_not receive(:after_enqueue_method)
+
+          subject.perform
+        end
+
+        context "when perform fails" do
+          subject do
+            Class.new(QueueClassicPlus::Base) do
+              @queue = :test
+
+              before_perform :before_perform_method
+              after_perform :after_perform_method
+
+              def self.before_perform_method(*_args); end;
+              def self.after_perform_method(*_args); end;
+
+              def self.perform(*_args)
+                raise StandardError
+              end
+            end
+          end
+
+          it "does not call after callbacks" do
+            expect(subject).to receive(:before_perform_method).once
+            expect(subject).to_not receive(:after_perform_method)
+
+            begin
+              subject.perform
+            rescue StandardError
+            end
+          end
+        end
+      end
+
+      context "when callback defined multiple times" do
+        subject do
+          Class.new(QueueClassicPlus::Base) do
+            @queue = :test
+
+            before_enqueue :before_enqueue_method_1
+            before_enqueue :before_enqueue_method_2
+            before_enqueue :before_enqueue_method_3
+
+            def self.before_enqueue_method_1(*_args); end;
+            def self.before_enqueue_method_2(*_args); end;
+            def self.before_enqueue_method_3(*_args); end;
+
+            def self.perform(*_args); end;
+          end
+        end
+
+        it "calls each callback" do
+          expect(subject).to receive(:before_enqueue_method_1).once
+          expect(subject).to receive(:before_enqueue_method_2).once
+          expect(subject).to receive(:before_enqueue_method_3).once
+
+          subject.do
+        end
+      end
+    end
+
+    context "with callback blocks defined" do
+      subject do
+        Class.new(QueueClassicPlus::Base) do
+          @queue = :test
+          class_variable_set(:@@block_result, [])
+
+          before_enqueue do |*_args|
+            class_variable_get(:@@block_result).append("before_enqueue_block")
+          end
+          after_enqueue do |*_args|
+            class_variable_get(:@@block_result).append("after_enqueue_block")
+          end
+
+          before_perform do |*_args|
+            class_variable_get(:@@block_result).append("before_perform_block")
+          end
+          after_perform do |*_args|
+            class_variable_get(:@@block_result).append("after_perform_block")
+          end
+
+          def self.perform; end;
+        end
+      end
+
+      context "when enqueued" do
+        it "calls the enqueue callback blocks" do
+          subject.do
+
+          expect(subject.class_variable_get(:@@block_result)).to eq(
+            %w(before_enqueue_block after_enqueue_block)
+          )
+        end
+      end
+
+      context "when perform" do
+        it "calls the perform callback blocks" do
+          subject.perform
+
+          expect(subject.class_variable_get(:@@block_result)).to eq(
+            %w(before_perform_block after_perform_block)
+          )
+        end
+      end
+    end
   end
 
   describe ".librato_key" do

data/spec/worker_spec.rb

@@ -45,6 +45,48 @@ describe QueueClassicPlus::CustomWorker do
         expect(job).to_not be_nil
         expect(job['last_error']).to_not be_nil
       end
+
+      context 'for a non-QueueClassicPlus job' do
+        let(:job_type) do
+          Class.new(ActiveJob::Base) do
+            def self.name
+              "NonQcJob"
+            end
+
+            self.queue_adapter = :queue_classic
+
+            queue_as :test
+
+            def perform(boom)
+              raise boom.to_s
+            end
+          end.tap { Object.const_set(:NonQcJob, _1) }
+        end
+        let(:queue) { QC::Queue.new("test") }
+
+        it 'properly enqueues for jobs in the failed queue' do
+          non_qc_job = job_type.new(:boom).enqueue
+          job_id = non_qc_job.provider_job_id
+
+          expect(failed_queue.count).to eq(0)
+          job = find_job(job_id)
+          expect(job).to_not be_nil
+          expect(find_job(job_id.succ)).to be_nil
+          args = JSON.load(job['args']).first
+          expect(args['arguments']).to eq(QueueClassicPlus::Base.serialized([:boom]))
+
+          worker.work
+
+          expect(failed_queue.count).to eq(1)
+          expect(find_job(job_id)).to be_nil
+          job = find_job(job_id.succ)
+          expect(job).to_not be_nil
+          failed_args = JSON.load(job['args']).first
+          expect(failed_args['arguments']).to eq(QueueClassicPlus::Base.serialized([:boom]))
+          expect(job['last_error']).to_not be_nil
+          expect(job['last_error']).to start_with("boom\n")
+        end
+      end
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: queue_classic_plus
 version: !ruby/object:Gem::Version
-  version: 4.0.0.alpha18
+  version: 4.0.0.alpha20
 platform: ruby
 authors:
 - Simon Mathieu
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-09-06 00:00:00.000000000 Z
+date: 2023-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: queue_classic