postburner 0.6.5 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7712222bcad943495a38f620aefaffbcc26d3483e68c07c1aae5102d20144baf
-  data.tar.gz: 1dc644fcdb72b196e2694c2dd935b4f08cf3229873c08625a4db898e0195e7a3
+  metadata.gz: 9d8b5fb47d69c141d348c00520ff51579fc67f8300ac804f75b96cb023a8c584
+  data.tar.gz: 49d79bc8e8e04edc9cca6d74e5f66326573a8defc859fc54d875c02dee626e4b
 SHA512:
-  metadata.gz: ea6308f6a9a13134ca84a693a933818d82d3ccf05a02f7f1bfc51a8d37178419143e9903e2f0b9a529dc3cab283196122dc6be833d0eeee10ec0a1ea3b5a9889
-  data.tar.gz: 1b8ac590e3289de30eccfe3ef6a4d65fa0e034d6f43069b03e1190b324dab38dc65d5eb358e3ea306daa15db044a86151e3118a27b803cee2d78bfbfbd99facc
+  metadata.gz: 9f835395176f8ce70a2790e2e6f34e08ae051fde7711bd2ed17f83f2f211133dc15ba914967e5cf0737ab57b4e1737ea055cbb283ff4223f76921ad1dd2aea29
+  data.tar.gz: a793a67476072574c1f5e1a2439d21377ea2074053a3ef6834daac4c28fe9e72048e0d6333c1536dce4dcf8801ea449d8f506dd3e76c0d2af8631c21b94b304b

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## v0.7.0 - 2022-10-24
+
+### Added
+- - add ActiveJob style callbacks for enqueue, attempt, processing, and processed.
+
+### Fixed
+- remove assets config as for rails >=7
+
 ## v0.6.5 - 2022-05-21
 
 ### Fixed

data/app/concerns/postburner/callbacks.rb

@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+
+require "active_support/callbacks"
+require "active_support/core_ext/object/with_options"
+require "active_support/core_ext/module/attribute_accessors"
+
+module Postburner
+  # = Postburner Job Callbacks
+  #
+  # Postburner Job provides hooks during the life cycle of a job. Callbacks allow you
+  # to trigger logic during this cycle. In called order, available callbacks are:
+  #
+  # * <tt>before_enqueue</tt>
+  # * <tt>after_enqueue</tt>
+  # * <tt>before_attempt</tt>
+  # * <tt>before_processing</tt>
+  # * <tt>after_processing</tt>
+  # * <tt>after_processed</tt>
+  # * <tt>after_attempt</tt>
+  #
+  # Around callbacks are also defined:
+  # * <tt>around_enqueue</tt>
+  # * <tt>around_attempt</tt>
+  # * <tt>around_processing</tt>
+  #
+  # NOTE: Calling the same callback multiple times will overwrite previous callback definitions.
+  #
+  module Callbacks
+    extend  ActiveSupport::Concern
+    include ActiveSupport::Callbacks
+
+    included do
+      cattr_accessor :skip_after_callbacks_if_terminated,
+        instance_accessor: false,
+        default: false
+
+      with_options(skip_after_callbacks_if_terminated: skip_after_callbacks_if_terminated) do
+        define_callbacks :enqueue
+        define_callbacks :attempt
+        define_callbacks :processing
+        define_callbacks :processed
+      end
+    end
+    module ClassMethods
+      def inherited(klass)
+        klass.get_callbacks(:enqueue).
+          config[:skip_after_callbacks_if_terminated] =
+            skip_after_callbacks_if_terminated
+        klass.get_callbacks(:processing).
+          config[:skip_after_callbacks_if_terminated] =
+            skip_after_callbacks_if_terminated
+        klass.get_callbacks(:attempt).
+          config[:skip_after_callbacks_if_terminated] =
+            skip_after_callbacks_if_terminated
+        klass.get_callbacks(:processed).
+          config[:skip_after_callbacks_if_terminated] =
+            skip_after_callbacks_if_terminated
+        super
+      end
+
+      # Defines a callback that will get called right before the
+      # job starts and any metadata is persisted.
+      #
+      #   class VideoProcessJob < Postburner::Base
+      #
+      #     before_attempt do |job|
+      #       $statsd.increment "attempting-video-job.try"
+      #     end
+      #
+      #     def perform(video_id)
+      #       Video.find(video_id).process
+      #     end
+      #   end
+      #
+      def before_attempt(*filters, &blk)
+        set_callback(:attempt, :before, *filters, &blk)
+      end
+
+      # Defines a callback that will get called right after the
+      # job finishes and all metadata is persisted.
+      #
+      # This isn't called unless the attempt finishes without error,
+      # though this is subject to change in the future
+      #
+      #   class VideoProcessJob < Postburner::Base
+      #
+      #     before_attempt do |job|
+      #       $statsd.increment "attempt-complete-video-job.try"
+      #     end
+      #
+      #     def perform(video_id)
+      #       Video.find(video_id).process
+      #     end
+      #   end
+      #
+      def after_attempt(*filters, &blk)
+        set_callback(:attempt, :after, *filters, &blk)
+      end
+
+      # Defines a callback that will get called around the attempt
+      # of the job.
+      #
+      #   class VideoProcessJob < Postburner::Base
+      #
+      #     around_enqueue do |job, block|
+      #       $statsd.time "video-job.process" do
+      #         block.call
+      #       end
+      #     end
+      #
+      #     def perform(video_id)
+      #       Video.find(video_id).process
+      #     end
+      #   end
+      #
+      def around_attempt(*filters, &blk)
+        set_callback(:attempt, :around, *filters, &blk)
+      end
+
+      # Defines a callback that will get called right before the
+      # job's perform method is executed.
+      #
+      #   class VideoProcessJob < Postburner::Base
+      #
+      #     before_processing do |job|
+      #       UserMailer.notify_video_started_processing(job.arguments.first)
+      #     end
+      #
+      #     def perform(video_id)
+      #       Video.find(video_id).process
+      #     end
+      #   end
+      #
+      def before_processing(*filters, &blk)
+        set_callback(:processing, :before, *filters, &blk)
+      end
+
+      # Defines a callback that will get called right after the
+      # job's perform method has finished.
+      #
+      #   class VideoProcessJob < Postburner::Base
+      #
+      #     after_processing do |job|
+      #       UserMailer.notify_video_processed(job.arguments.first)
+      #     end
+      #
+      #     def perform(video_id)
+      #       Video.find(video_id).process
+      #     end
+      #   end
+      #
+      def after_processing(*filters, &blk)
+        set_callback(:processing, :after, *filters, &blk)
+      end
+
+      # Defines a callback that will get called around the job's perform method.
+      #
+      #   class VideoProcessJob < Postburner::Base
+      #
+      #     around_processing do |job, block|
+      #       UserMailer.notify_video_started_processing(job.arguments.first)
+      #       block.call
+      #       UserMailer.notify_video_processed(job.arguments.first)
+      #     end
+      #
+      #     def perform(video_id)
+      #       Video.find(video_id).process
+      #     end
+      #   end
+      #
+      # You can access the return value of the job only if the execution wasn't halted.
+      #
+      #   class VideoProcessJob < Postburner::Base
+      #     around_processing do |job, block|
+      #       value = block.call
+      #       puts value # => "Hello World!"
+      #     end
+      #
+      #     def perform
+      #       "Hello World!"
+      #     end
+      #   end
+      #
+      def around_processing(*filters, &blk)
+        set_callback(:processing, :around, *filters, &blk)
+      end
+
+      # Defines a callback that will get called right after the
+      # job's processed_at timestamp has been persisted, marking the
+      # job as successfully completed, i.e. no errors raised.
+      #
+      # This is rather similar to after_processing but all of the
+      # job's metadata has been set.
+      #
+      #   class VideoProcessJob < Postburner::Base
+      #
+      #     after_processed do |job|
+      #       UserMailer.notify_video_processed(job.arguments.first)
+      #     end
+      #
+      #     def perform(video_id)
+      #       Video.find(video_id).process
+      #     end
+      #   end
+      #
+      def after_processed(*filters, &blk)
+        set_callback(:processed, :after, *filters, &blk)
+      end
+
+      # Defines a callback that will get called right before the
+      # job is enqueued.
+      #
+      #   class VideoProcessJob < Postburner::Base
+      #
+      #     before_enqueue do |job|
+      #       $statsd.increment "enqueue-video-job.try"
+      #     end
+      #
+      #     def perform(video_id)
+      #       Video.find(video_id).process
+      #     end
+      #   end
+      #
+      def before_enqueue(*filters, &blk)
+        set_callback(:enqueue, :before, *filters, &blk)
+      end
+
+      # Defines a callback that will get called right after the
+      # job is enqueued.
+      #
+      #   class VideoProcessJob < Postburner::Base
+      #
+      #     after_enqueue do |job|
+      #       $statsd.increment "enqueue-video-job.success"
+      #     end
+      #
+      #     def perform(video_id)
+      #       Video.find(video_id).process
+      #     end
+      #   end
+      #
+      def after_enqueue(*filters, &blk)
+        set_callback(:enqueue, :after, *filters, &blk)
+      end
+
+      # Defines a callback that will get called around the enqueuing
+      # of the job.
+      #
+      #   class VideoProcessJob < Postburner::Base
+      #
+      #     around_enqueue do |job, block|
+      #       $statsd.time "video-job.process" do
+      #         block.call
+      #       end
+      #     end
+      #
+      #     def perform(video_id)
+      #       Video.find(video_id).process
+      #     end
+      #   end
+      #
+      def around_enqueue(*filters, &blk)
+        set_callback(:enqueue, :around, *filters, &blk)
+      end
+    end
+
+    private
+
+    # NOTE processed / attempt exclueded here -- intentionally
+    #
+    def halted_callback_hook(_filter, name) # :nodoc:
+      return super unless %i(enqueue processing).include?(name.to_sym)
+      callbacks = public_send("_#{name}_callbacks")
+
+      if !self.class.skip_after_callbacks_if_terminated && callbacks.any? { |c| c.kind == :after }
+        ActiveSupport::Deprecation.warn(<<~EOM)
+            In Rails 7.0, `after_enqueue`/`after_work` callbacks no longer run if `before_enqueue`/`before_work` respectively halts with `throw :abort`.
+            To enable this behavior, uncomment the `config.active_job.skip_after_callbacks_if_terminated` config
+            in the new 6.1 framework defaults initializer.
+        EOM
+      end
+
+      super
+    end
+  end
+end

data/app/models/postburner/job.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Postburner
   # Must implement a perform method, if an exception is raised the job
   # doesn't complete.
@@ -14,6 +16,7 @@ module Postburner
   #
   class Job < ApplicationRecord
     include Backburner::Queue
+    include Callbacks
 
     LOG_LEVELS = [
       :debug,
@@ -48,7 +51,9 @@ module Postburner
 
       @_insert_options = options
 
-      self.save!
+      run_callbacks :enqueue do
+        self.save!
+      end
     end
 
     def requeue!(options={})
@@ -73,77 +78,85 @@ module Postburner
 [Postburner::Job] [#{id}] Not Found.
         MSG
       end
-      job&.perform!(job.args)
+      #job&.perform!(job.args)
+      job.perform!(job.args)
     end
 
     def perform!(args={})
-      self.attempting
-
-      self.update_columns(
-        attempting_at:  self.attempting_at,
-        attempts:       self.attempts,
-        attempt_count:  self.attempts.length,
-        lag:            self.lag,
-        processing_at:  Time.zone.now,
-      )
-
-      begin
-        if self.queued_at.nil?
-          self.log! "Not Queued", level: :error
-          return
-        end
-
-        if self.queued_at > Time.zone.now
-          self.log! "Future Queued", level: :error
-          return
-        end
-
-        if self.processed_at.present?
-          self.log! "Already Processed", level: :error
-          self.delete!
-          return
-        end
-
-        if self.removed_at.present?
-          self.log! "Removed", level: :error
-          return
-        end
-
-        if self.run_at && self.run_at > Time.zone.now
-          response = self.insert! delay: self.run_at - Time.zone.now
-          self.log! "PREMATURE; RE-INSERTED: #{response}"
-          return
-        end
-
-        self.log!("START (bkid #{self.bkid})")
+      run_callbacks :attempt do
+        self.attempting
+
+        self.update_columns(
+          attempting_at:  self.attempting_at,
+          attempts:       self.attempts,
+          attempt_count:  self.attempts.length,
+          lag:            self.lag,
+          processing_at:  Time.zone.now,
+        )
 
         begin
-          self.perform(args)
+          if self.queued_at.nil?
+            self.log! "Not Queued", level: :error
+            return
+          end
+
+          if self.queued_at > Time.zone.now
+            self.log! "Future Queued", level: :error
+            return
+          end
+
+          if self.processed_at.present?
+            self.log! "Already Processed", level: :error
+            self.delete!
+            return
+          end
+
+          if self.removed_at.present?
+            self.log! "Removed", level: :error
+            return
+          end
+
+          if self.run_at && self.run_at > Time.zone.now
+            response = self.insert! delay: self.run_at - Time.zone.now
+            self.log! "PREMATURE; RE-INSERTED: #{response}"
+            return
+          end
+
+          self.log!("START (bkid #{self.bkid})")
+
+          run_callbacks :processing do
+            begin
+              self.perform(args)
+            rescue Exception => exception
+              self.persist_metadata!
+              self.log! '[Postburner] Exception raised during perform prevented completion.'
+              raise exception
+            end
+          end
+
+          self.log!("DONE (bkid #{self.bkid})")
+
+          begin
+            now = Time.zone.now
+            _duration =  (now - self.processing_at) * 1000 rescue nil
+
+            run_callbacks :processed do
+              persist_metadata!(
+                processed_at: now,
+                duration:     _duration,
+              )
+            end
+          rescue Exception => e
+            self.log_exception!(e)
+            self.log! '[Postburner] Could not set data after processing.'
+            # TODO README doesn't retry if Postburner is to blame
+          end
+
         rescue Exception => exception
-          self.persist_metadata!
-          self.log! '[Postburner] Exception raised during perform prevented completion.'
+          self.log_exception!(exception)
           raise exception
         end
-
-        self.log!("DONE (bkid #{self.bkid})")
-
-        begin
-          now = Time.zone.now
-          _duration =  (now - self.processing_at) * 1000 rescue nil
-          persist_metadata!(
-            processed_at: now,
-            duration:     _duration,
-          )
-        rescue Exception => e
-          self.log_exception!(e)
-          self.log! '[Postburner] Could not set data after processing.'
-          # TODO README doesn't retry if Postburner is to blame
-        end
-
-      rescue Exception => exception
-        self.log_exception!(exception)
-        raise exception
-      end
+      end # run_callbacks :attempt
 
     end
 

data/lib/postburner/version.rb

@@ -1,3 +1,3 @@
 module Postburner
-  VERSION = '0.6.5'
+  VERSION = '0.7.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: postburner
 version: !ruby/object:Gem::Version
-  version: 0.6.5
+  version: 0.7.0
 platform: ruby
 authors:
 - Matt Smith
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-05-21 00:00:00.000000000 Z
+date: 2022-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -79,6 +79,7 @@ files:
 - Rakefile
 - app/assets/config/postburner_manifest.js
 - app/assets/stylesheets/postburner/application.css
+- app/concerns/postburner/callbacks.rb
 - app/controllers/postburner/application_controller.rb
 - app/controllers/postburner/jobs_controller.rb
 - app/controllers/postburner/static_controller.rb
@@ -122,7 +123,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.3.7
 signing_key: 
 specification_version: 4
 summary: Postgres backed beanstalkd queue via backburner