Serialization interface

[fractaledmind]

I maintain a newer Ruby gem for helping to make Jobs more resilient by leaning on ACIDic database transactions: http://github.com/fractaledmind/acidic_job

At the heart of this approach is essentially tracking job runs via a database record. One essential ingredient for this to work is to be able to serialize and deserialize jobs, so that I can store a job run and then later start that job with the job queue. ActiveJob provides the following interface which makes this straightforward:

SomeJob.deserialize(some_job_hash)
SomeJob.new(arguments).serialize

I faced similar limitations with Sidekiq and opened a similar issue and a corresponding PR to bring a serialization interface to Sidekiq workers.

The central need is to have a way from within a notifier to pause execution of the other delivery methods after the database, store the "instructions" in a database record, which can then be read and used to re-initiate those instructions later.

At the moment, I have this hack that extends the gem with a deliver_transactionally method. I am trying to figure out the best way to extend noticed to make an extension like this less hacky:

module AcidicJob
  module NotifyTransactionallyExtension
    extend ActiveSupport::Concern

    def deliver_transactionally(recipients)
      # THIS IS A HACK THAT COPIES AND PASTES KEY PARTS OF THE `Noticed::Base` CODE IN ORDER TO ALLOW US TO TRANSACTIONALLY DELIVER NOTIFICATIONS
      # THIS IS THUS LIABLE TO BREAK WHENEVER THAT GEM IS UPDATED
      
      job_parent_class = Noticed.parent_class.constantize
      job_adapter = if job_parent_class < ActiveJob::Base
        "activejob"
      elsif job_parent_class.include?(Sidekiq::Worker)
        "sidekiq"
      else
        raise UnknownJobAdapter
      end
      delivery_methods = self.class.delivery_methods.dup

      Array.wrap(recipients).uniq.flat_map do |recipient|
        if (index = delivery_methods.find_index { |m| m[:name] == :database })
          delivery_method = delivery_methods.delete_at(index)
          self.record = run_delivery_method(delivery_method, recipient: recipient, enqueue: false, record: nil)
        end

        delivery_methods.map do |delivery_method|
          job_class = delivery_method_for(delivery_method[:name], delivery_method[:options])
          args = {
            notification_class: self.class.name,
            options: delivery_method[:options],
            params: params,
            recipient: recipient,
            record: self.record
          }
          job_args = job_class.send(:job_or_instantiate, args).serialize
          attributes = {
            adapter: job_adapter,
            job_name: job_class.name,
            job_args: job_args
          }
          
          # AcidicJob::Staged.create!(attributes)
          attributes
        end
      end
    end
  end
end
Noticed::Base.include AcidicJob::NotifyTransactionallyExtension

I'm opening this issue to get some feedback from the community and any wisdom from @excid3 himself hopefully.