postburner 0.4.0 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6faa3078340ee2bc8d90e931ee1db203114e32ff69b288ec69340e8b86a987cd
-  data.tar.gz: 0a2ddf78a320e9b01c26a0e3fbd3158b78d37a89bca04a5fdd8c64b70eada1a7
+  metadata.gz: 6d47898f4be7a93d1643ba6ff32db238b341a2ceed09bbc18de2774d3048d9cd
+  data.tar.gz: 934f5a102f6644e679c2bf30d4708e171f01d88b5652fe6bcef2cac8b6fe4c50
 SHA512:
-  metadata.gz: 5253309eb7aff502623040d49e923faff7c91df6aac407ec7a4e306a8317b1363db43a4b0408eb20fbdad6ee017ad68489480ac50d7e2ac68a612a1337488457
-  data.tar.gz: 49d0253fe3ecde9cfd4de8b48a2ce95997245bea4310f7c751ccca3685fea8a42b29310a8058f222031ee8aa91f6ec61f990ec5c330157e39853c95830236cfa
+  metadata.gz: cb29ebe178b4675552a441c335fd95867a9a26c0a15235c42d5dff0f8ab72c40c417c728bc171ecf461ef3e78c9672364b89fae3b91419dceac59f80ad4c9986
+  data.tar.gz: 807cb26488522a5a3becdc53fbc43b44a9123d1355ee31d2b79dc2d1d479ce714a6b3a5f20c60b74e2f2fc22753736e6fde9822fe59e83feab69024e34e60deb

data/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## v0.6.2 - 2021-11-01
+
+### Fixed
+- add #requeue method.
+- check if AlreadyProcessed.
+
+## v0.6.1 - 2021-11-01
+
+### Updated
+- update run_at logic to support only inserting after save commit.
+
+## v0.6.0 - 2021-11-01
+
+### Added
+- update exception handling to better show where the error was raised.
+- update logging to match errata format.
+- update documentation.
+
+## v0.5.0 - 2021-10-27
+
+### Added
+- add mailer, action, params accessors to Mailer for easy access in subclassed jobs.
+- add logging to Mailer perform.
+- add save to #queue! job if unsaved
+- add block with logging if queued_at isn't set or isn't prior to run time.
+
 ## v0.4.0 - 2021-10-12
 
 ### Added

data/README.md

@@ -47,6 +47,17 @@ RunDonation.create!(args: {donation_id: 123}).queue! delay: 1.hour
 => {:status=>"INSERTED", :id=>"1141"}
 ```
 
+### Mailers
+
+```ruby
+j = Postburner::Mailer.
+  delivery(UserMailer, :welcome)
+  .with(name: 'Freddy')
+
+j.queue!
+=> {:status=>"INSERTED", :id=>"1139"}
+```
+
 ### [Beaneater](https://github.com/beanstalkd/beaneater) and [beanstalkd](https://raw.githubusercontent.com/beanstalkd/beanstalkd/master/doc/protocol.txt) attributes and methods
 ```ruby
 # get the beanstalkd job id

data/app/models/postburner/job.rb

@@ -1,4 +1,17 @@
 module Postburner
+  # Must implement a perform method, if an exception is raised the job
+  # doesn't complete.
+  #
+  # Job won't run unless queued_at is set, and is set to a time prior to
+  # the time the job runs.
+  #
+  # TODO Mailer uses ActiveJob::Arguments... probably should use that here
+  # as well. Decided how to migrate existing jobs or allow both - Opt to 
+  # allow both: rescue from ActiveJob::DeserializationError and use the
+  # plain hash, probably log it too.
+  #
+  # Add `cancelled_at` that blocks jobs performing if present.
+  #
   class Job < ApplicationRecord
     include Backburner::Queue
 
@@ -11,36 +24,56 @@ module Postburner
 
     before_validation :ensure_sid!
     before_destroy :delete!
+    after_save_commit :insert_if_queued!
 
     validates :sid, presence: {strict: true}
 
     def queue!(options={})
       return if self.queued_at.present? && self.bkid.present?
+      raise ActiveRecord::RecordInvalid, "Can't queue unless valid." unless self.valid?
+      raise AlreadyProcessed, "Processed at #{self.processed_at}" if self.processed_at
 
-      case
-      when options[:at].present?
-        # this is rudimentary, add error handling
-        options[:delay] ||= options[:at].to_i - Time.zone.now.to_i
-        update_column :run_at, options[:at]
-        options.delete(:at)
-      when options[:delay].present?
-        update_column :run_at, Time.zone.now + options[:delay].seconds
-      end
+      at = options.delete(:at)
+      now = Time.zone.now
+
+      self.queued_at = now
+      self.run_at = case
+                    when at.present?
+                      # this is rudimentary, add error handling
+                      options[:delay] ||= at.to_i - now.to_i
+                      at
+                    when options[:delay].present?
+                      now + options[:delay].seconds
+                    end
+
+      @_insert_options = options
+
+      self.save!
+    end
+
+    def requeue!(options={})
+      self.delete!
+      self.bkid, self.queued_at = nil, nil
 
-      insert!(options)
+      self.queue! options
+    end
+
+    def will_insert?
+      @_insert_options.is_a? Hash
     end
 
     # tube: backburner.worker.queue.backburner-jobs
     #
     def self.perform(id, _={})
+      job = nil
       begin
         job = self.find(id)
-        job.perform!(job.args)
       rescue ActiveRecord::RecordNotFound => e
         Rails.logger.warn <<-MSG
 [Postburner::Job] [#{id}] Not Found.
         MSG
       end
+      job&.perform!(job.args)
     end
 
     def perform!(args={})
@@ -55,6 +88,16 @@ module Postburner
       )
 
       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!
@@ -72,22 +115,24 @@ module Postburner
           return
         end
 
-        self.log!('START')
+        self.log!("START (bkid #{self.bkid})")
 
-        self.perform(args)
+        begin
+          self.perform(args)
+        rescue Exception => exception
+          self.persist_metadata!
+          self.log! '[Postburner] Exception raised during perform prevented completion.'
+          raise exception
+        end
 
-        self.log!('DONE')
+        self.log!("DONE (bkid #{self.bkid})")
 
         begin
           now = Time.zone.now
           _duration =  (now - self.processing_at) * 1000 rescue nil
-          self.update_columns(
+          persist_metadata!(
             processed_at: now,
             duration:     _duration,
-            errata:       self.errata,
-            error_count:  self.errata.length,
-            logs:         self.logs,
-            log_count:    self.logs.length,
           )
         rescue Exception => e
           self.log_exception!(e)
@@ -97,7 +142,6 @@ module Postburner
 
       rescue Exception => exception
         self.log_exception!(exception)
-        self.log! '[Postburner] Exception raised during perform prevented completion.'
         raise exception
       end
 
@@ -148,6 +192,7 @@ module Postburner
       self.errata << [
         Time.zone.now,
         {
+          bkid:       self.bkid,
           class:      exception.class,
           message:    exception.message,
           backtrace:  exception.backtrace,
@@ -165,30 +210,67 @@ module Postburner
       options[:level] = :error unless LOG_LEVELS.member?(options[:level])
 
       self.logs << [
-        Time.zone.now,
-        options[:level],
-        message,
+        Time.zone.now, # time
+        {
+          bkid:     self.bkid,
+          level:    options[:level], # level
+          message:  message, # message
+          elapsed:  self.elapsed_ms, # ms from start
+        }
       ]
     end
 
+    # ms from attempting_at
+    #
+    def elapsed_ms
+      return unless self.attempting_at
+      (Time.zone.now - self.attempting_at) * 1000
+    end
+
     def log!(message, options={})
       self.log(message, options)
       self.update_column :logs, self.logs
     end
 
+    def intended_at
+      self.run_at ? self.run_at : self.queued_at
+    end
+
+    class AlreadyProcessed < StandardError; end
+
     private
 
+    def persist_metadata!(data={})
+      self.update_columns({
+        errata:       self.errata,
+        error_count:  self.errata.length,
+        logs:         self.logs,
+        log_count:    self.logs.length,
+      }.merge(data))
+    end
+
+    def insert_if_queued!
+      return unless self.will_insert?
+      insert!(@_insert_options)
+    end
+
     def insert!(options={})
-      response = Backburner::Worker.enqueue(Postburner::Job, self.id, options)
+      response = nil
+
+      Job.transaction do
+        response = Backburner::Worker.enqueue(
+          Postburner::Job,
+          self.id,
+          options
+        )
+
+        persist_metadata!(
+          bkid: response[:id],
+        )
+      end
 
       self.log("QUEUED: #{response}")
 
-      update_columns(
-        queued_at:  Time.zone.now,
-        bkid:       response[:id],
-        logs:       self.logs,
-      )
-
       response
     end
 
@@ -196,14 +278,10 @@ module Postburner
       now = Time.zone.now
       self.attempts << now
       self.attempting_at ||= now
-      self.lag ||= (self.attempting_at - self.intended_at) * 1000
+      self.lag ||= (self.attempting_at - self.intended_at) * 1000 rescue nil
       now
     end
 
-    def intended_at
-      self.run_at ? self.run_at : self.queued_at
-    end
-
     def ensure_sid!
       self.sid ||= SecureRandom.uuid
     end

data/app/models/postburner/mailer.rb

@@ -7,8 +7,8 @@ module Postburner
   class Mailer < Job
     #queue 'mailers'
 
-    def self.deliver(mailer, action)
-      job = self.create!(
+    def self.delivery(mailer, action)
+      job = self.new(
         args: {
           mailer: mailer.to_s,
           action: action.to_s,
@@ -17,32 +17,62 @@ module Postburner
       job
     end
 
+    def self.delivery!(mailer, action)
+      job = self.delivery(mailer, action)
+      job.save!
+      job
+    end
+
     # Similar to ActionMailer #with - set the parameters
     #
     def with(params={})
       self.args.merge!(
-        params: ActiveJob::Arguments.serialize(params)
+        'params' => ActiveJob::Arguments.serialize(params)
       )
+      self
+    end
+
+    def with!(params={})
+      self.with(params)
       self.save!
       self
     end
 
     # Build the mail but don't send.
     #
-    def assemble(args=nil)
-      _args = args || self.args
+    # Optional `args` argument for testing convenience.
+    #
+    def assemble
+      mail = self.mailer.with(self.params).send(self.action)
+      mail
+    end
 
-      cls = _args['mailer'].constantize
+    # Get the mailer class.
+    #
+    def mailer
+      self.args['mailer'].constantize
+    end
 
-      mail = cls.
-        with(ActiveJob::Arguments.deserialize(_args['params']).to_h).
-        send(_args['action'])
+    # Get the mailer action as a symbol.
+    #
+    def action
+      self.args['action']&.to_sym
+    end
 
-      mail
+    # Get the deserialized params.
+    #
+    def params
+      ActiveJob::Arguments.deserialize(self.args['params']).to_h
     end
 
     def perform(args)
-      self.assemble(args).deliver_now
+      self.log! "Building"
+      mail = self.assemble
+
+      self.log! "Delivering"
+      mail.deliver_now
+
+      self.log! "Delivered"
     end
   end
 end

data/lib/postburner/version.rb

@@ -1,3 +1,3 @@
 module Postburner
-  VERSION = '0.4.0'
+  VERSION = '0.6.2'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: postburner
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.2
 platform: ruby
 authors:
 - Matt Smith
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-10-12 00:00:00.000000000 Z
+date: 2021-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails