acidic_job 0.9.0 → 1.0.0.beta.1

data/gemfiles/{rails_6.1_sidekiq_6.4.gemfile → rails_6.1.gemfile}

@@ -5,6 +5,4 @@ source "https://rubygems.org"
 gem "activemodel", "~> 6.1.0"
 gem "railties", "~> 6.1.0"
 
-gem "sidekiq", "~> 6.4.0"
-
 gemspec path: "../"

data/gemfiles/{rails_7.0_sidekiq_6.4.gemfile → rails_7.0.gemfile}

@@ -5,6 +5,4 @@ source "https://rubygems.org"
 gem "activemodel", "~> 7.0.0"
 gem "railties", "~> 7.0.0"
 
-gem "sidekiq", "~> 6.4.0"
-
 gemspec path: "../"

data/lib/acidic_job/active_kiq.rb

@@ -13,29 +13,11 @@ module AcidicJob
     define_callbacks :perform
     include Mixin
 
-    concerning :Configuring do
-      # Configures the job with the given options.
-      def set(options = {}) # :nodoc:
-        self.scheduled_at = options[:wait].seconds.from_now.to_f if options[:wait]
-        self.scheduled_at = options[:wait_until].to_f if options[:wait_until]
-        self.queue_name   = self.class.queue_name_from_part(options[:queue]) if options[:queue]
-
-        self
-      end
-    end
-
     concerning :Initializing do
-      class_methods do
-        def job_or_instantiate(*args)
-          args.first.is_a?(self) ? args.first : new(*args)
-        end
-      end
-
       included do
         attr_accessor :arguments
         attr_accessor :job_id
         attr_accessor :queue_name
-        attr_accessor :scheduled_at
         attr_accessor :sidekiq_options
       end
       ##
@@ -43,9 +25,9 @@ module AcidicJob
       # +args+ are the arguments, if any, that will be passed to the perform method
       # +opts+ are any options to configure the job
       def initialize(*arguments)
-        @arguments = arguments
-        @job_id = ::SecureRandom.uuid
-        @sidekiq_options = sidekiq_options_hash || ::Sidekiq.default_job_options
+        @arguments  = arguments
+        @job_id     = SecureRandom.uuid
+        @sidekiq_options = sidekiq_options_hash || Sidekiq.default_job_options
         @queue_name = @sidekiq_options["queue"]
       end
 
@@ -61,33 +43,22 @@ module AcidicJob
 
     concerning :Performing do
       class_methods do
-        def perform_later(*args)
-          perform_async(*args)
-        end
-
-        def perform_now(*args)
-          perform_inline(*args)
+        def perform_now(*args, **kwargs)
+          new.perform(*args, **kwargs)
         end
       end
 
-      def perform_later(*args)
-        Setter.new(self.class, {}).perform_async(*args)
-      end
-
-      def perform_now(*args)
-        Setter.new(self.class, {}).perform_inline(*args)
+      def perform_now(*args, **kwargs)
+        perform(*args, **kwargs)
       end
 
       def enqueue
-        item = {
+        ::Sidekiq::Client.push(
           "class" => self.class,
           "args" => @arguments,
           "jid" => @job_id,
           "queue" => @queue_name
-        }
-        item["at"] = @scheduled_at if defined?(@scheduled_at) && @scheduled_at
-
-        ::Sidekiq::Client.push(item)
+        )
       end
     end
 
@@ -126,16 +97,16 @@ module AcidicJob
     # https://github.com/rails/rails/blob/93c9534c9871d4adad4bc33b5edc355672b59c61/activejob/lib/active_job/callbacks.rb
     concerning :Callbacks do
       class_methods do
-        def around_perform(...)
-          set_callback(:perform, :around, ...)
+        def around_perform(*filters, &blk)
+          set_callback(:perform, :around, *filters, &blk)
         end
 
-        def before_perform(...)
-          set_callback(:perform, :before, ...)
+        def before_perform(*filters, &blk)
+          set_callback(:perform, :before, *filters, &blk)
         end
 
-        def after_perform(...)
-          set_callback(:perform, :after, ...)
+        def after_perform(*filters, &blk)
+          set_callback(:perform, :after, *filters, &blk)
         end
       end
     end

data/lib/acidic_job/arguments.rb

@@ -18,13 +18,5 @@ module AcidicJob
     rescue ActiveRecord::RecordNotFound
       nil
     end
-
-    # In order to allow our `NewRecordSerializer` a chance to work, we need to ensure that
-    # ActiveJob's first attempt to serialize an ActiveRecord model doesn't throw an exception.
-    def convert_to_global_id_hash(argument)
-      { GLOBALID_KEY => argument.to_global_id.to_s }
-    rescue URI::GID::MissingModelIdError
-      Serializers.serialize(argument)
-    end
   end
 end

data/lib/acidic_job/errors.rb

@@ -15,5 +15,4 @@ module AcidicJob
   class UnserializableValue < Error; end
   class LockedIdempotencyKey < Error; end
   class MismatchedIdempotencyKeyAndJobArguments < Error; end
-  class MissingBlockArgument < Error; end
 end

data/lib/acidic_job/mixin.rb

@@ -7,11 +7,12 @@ module AcidicJob
     extend ActiveSupport::Concern
 
     def self.wire_up(other)
+      raise UnknownJobAdapter unless (defined?(::ActiveJob::Base) && other < ::ActiveJob::Base) ||
+                                     (defined?(::Sidekiq::Worker) && other.include?(::Sidekiq::Worker))
+
       # Ensure our `perform` method always runs first to gather parameters
       # and run perform callbacks for Sidekiq workers
       other.prepend PerformWrapper
-      # Ensure both configured and base jobs can be performed acidicly
-      other.include PerformAcidicly
 
       # By default, we unique job runs by the `job_id`
       other.instance_variable_set(:@acidic_identifier, :job_id)
@@ -20,7 +21,7 @@ module AcidicJob
       # You could unique job runs by the arguments passed to the job (e.g. memoization)
       other.define_singleton_method(:acidic_by_job_arguments) { @acidic_identifier = :job_arguments }
       # Or, you could unique jobs run by any logic you'd like using a block
-      other.define_singleton_method(:acidic_by) { |proc = nil, &block| @acidic_identifier = proc || block }
+      other.define_singleton_method(:acidic_by) { |&block| @acidic_identifier = block }
 
       # We add a callback to ensure that staged, non-workflow jobs are "finished" after they are "performed".
       # This allows us to ensure that we can always inspect whether a run is finished and get correct data
@@ -42,6 +43,15 @@ module AcidicJob
         super
       end
 
+      # `perform_now` runs a job synchronously and immediately
+      # `perform_later` runs a job asynchronously and queues it immediately
+      # `perform_acidicly` run a job asynchronously and queues it after a successful database commit
+      def perform_acidicly(*args)
+        job = new(*args)
+
+        Run.stage!(job)
+      end
+
       # Instantiate an instance of a job ready for serialization
       def with(...)
         # New delegation syntax (...) was introduced in Ruby 2.7.
@@ -51,26 +61,12 @@ module AcidicJob
         job.queue_name
         job
       end
-
-      def set(options = {})
-        ::AcidicJob::ConfiguredJob.new(self, options)
-      end
     end
 
     def idempotency_key
       IdempotencyKey.new(self).value(acidic_by: acidic_identifier)
     end
 
-    # Configures the job with the given options.
-    def set(options = {}) # :nodoc:
-      self.scheduled_at = options[:wait].seconds.from_now.to_f if options[:wait]
-      self.scheduled_at = options[:wait_until].to_f if options[:wait_until]
-      self.queue_name   = self.class.queue_name_from_part(options[:queue]) if options[:queue]
-      self.priority     = options[:priority].to_i if options[:priority]
-
-      self
-    end
-
     protected
 
     # Short circuits execution by sending execution right to 'finished'.
@@ -80,16 +76,17 @@ module AcidicJob
     end
 
     def with_acidic_workflow(persisting: {}, &block)
-      raise UnknownJobAdapter unless known_job_adapter?
-
       raise RedefiningWorkflow if defined? @workflow_builder
 
       @workflow_builder = WorkflowBuilder.new
 
       raise MissingWorkflowBlock, "A block must be passed to `with_acidic_workflow`" unless block_given?
-      raise MissingBlockArgument, "An argument must be passed to the `with_acidic_workflow` block" if block.arity.zero?
 
-      block.call @workflow_builder
+      if block.arity.zero?
+        @workflow_builder.instance_exec(&block)
+      else
+        yield @workflow_builder
+      end
 
       raise NoDefinedSteps if @workflow_builder.steps.empty?
 
@@ -233,7 +230,7 @@ module AcidicJob
 
       # "STG__#{idempotency_key}__#{encoded_global_id}"
       _prefix, _idempotency_key, encoded_global_id = job_id.split("__")
-      staged_job_gid = "gid://#{::Base64.urlsafe_decode64(encoded_global_id)}"
+      staged_job_gid = "gid://#{::Base64.decode64(encoded_global_id)}"
 
       @staged_job_run = ::GlobalID::Locator.locate(staged_job_gid)
     end
@@ -252,13 +249,5 @@ module AcidicJob
         :serializable
       end
     end
-
-    def known_job_adapter?
-      return true if defined?(::AcidicJob::Base) && self.class < ::AcidicJob::Base
-      return true if defined?(::AcidicJob::ActiveKiq) && self.class < ::AcidicJob::ActiveKiq
-      return true if defined?(::ActiveJob) && self.class < ::ActiveJob::Base
-
-      false
-    end
   end
 end

data/lib/acidic_job/perform_wrapper.rb

@@ -4,15 +4,15 @@ module AcidicJob
   # NOTE: it is essential that this be a bare module and not an ActiveSupport::Concern
   # WHY?
   module PerformWrapper
-    ruby2_keywords def perform(*args)
+    def perform(*args, **kwargs)
       @arguments = args
 
       # we don't want to run the `perform` callbacks twice, since ActiveJob already handles that for us
-      if defined?(::ActiveJob) && self.class < ::ActiveJob::Base
-        super(*args)
-      elsif defined?(::Sidekiq) && self.class.include?(::Sidekiq::Worker)
+      if defined?(ActiveJob) && self.class < ActiveJob::Base
+        super(*args, **kwargs)
+      elsif defined?(Sidekiq) && self.class.include?(Sidekiq::Worker)
         run_callbacks :perform do
-          super(*args)
+          super(*args, **kwargs)
         end
       else
         raise UnknownJobAdapter

data/lib/acidic_job/processor.rb

@@ -19,7 +19,7 @@ module AcidicJob
         if !@run.known_recovery_point?
           raise UnknownRecoveryPoint,
                 "Defined workflow does not reference this step: #{@run.current_step_name.inspect}"
-        elsif (awaited_jobs = jobs_from(@run.current_step_awaits)).any?
+        elsif !Array(awaited_jobs = @run.current_step_hash.fetch("awaits", [])).compact.empty?
           # We only execute the current step, without progressing to the next step.
           # This ensures that any failures in parallel jobs will have this step retried in the main workflow
           step_result = @workflow.execute_current_step
@@ -47,12 +47,14 @@ module AcidicJob
 
     private
 
-    def enqueue_awaited_jobs(awaited_jobs, step_result)
+    def enqueue_awaited_jobs(jobs_or_jobs_getter, step_result)
+      awaited_jobs = jobs_from(jobs_or_jobs_getter)
+
       AcidicJob.logger.log_run_event("Enqueuing #{awaited_jobs.count} awaited jobs...", @job, @run)
       # All jobs created in the block are pushed atomically at the end of the block.
       AcidicJob::Run.transaction do
         awaited_jobs.each do |awaited_job|
-          worker_class, args = job_and_args(awaited_job)
+          worker_class, args = job_args_and_kwargs(awaited_job)
 
           job = worker_class.new(*args)
 
@@ -65,11 +67,10 @@ module AcidicJob
     def jobs_from(jobs_or_jobs_getter)
       case jobs_or_jobs_getter
       when Array
-        jobs_or_jobs_getter.compact
+        jobs_or_jobs_getter
       when Symbol, String
-        if @job.respond_to?(jobs_or_jobs_getter, _include_private = true)
-          jobs = @job.method(jobs_or_jobs_getter).call
-          Array(jobs).compact
+        if @job.respond_to?(jobs_or_jobs_getter)
+          @job.method(jobs_or_jobs_getter).call
         else
           raise UnknownAwaitedJob,
                 "Invalid `awaits`; unknown method `#{jobs_or_jobs_getter}` for this job"
@@ -80,7 +81,7 @@ module AcidicJob
       end
     end
 
-    def job_and_args(job)
+    def job_args_and_kwargs(job)
       case job
       when Class
         [job, []]

data/lib/acidic_job/run.rb

@@ -15,10 +15,6 @@ module AcidicJob
     STAGED_JOB_ID_PREFIX = "STG"
     STAGED_JOB_ID_DELIMITER = "__"
     IDEMPOTENCY_KEY_LOCK_TIMEOUT_SECONDS = 2
-    RAILS_VERSION = Gem::Version.new(ActiveRecord.version)
-    TARGET_VERSION = Gem::Version.new("7.1")
-    REQUIRES_CODER_FOR_SERIALIZE = RAILS_VERSION >= TARGET_VERSION ||
-                                   RAILS_VERSION.segments[..1] == TARGET_VERSION.segments
 
     self.table_name = "acidic_job_runs"
 
@@ -51,11 +47,7 @@ module AcidicJob
 
         after_update_commit :proceed_with_parent, if: :finished?
 
-        if REQUIRES_CODER_FOR_SERIALIZE
-          serialize :returning_to, coder: AcidicJob::Serializer
-        else
-          serialize :returning_to, AcidicJob::Serializer
-        end
+        serialize :returning_to, AcidicJob::Serializer
       end
 
       class_methods do
@@ -125,7 +117,7 @@ module AcidicJob
             staged: true,
             job_class: job.class.name,
             serialized_job: job.serialize,
-            idempotency_key: job.try(:idempotency_key) || job.job_id
+            idempotency_key: job.idempotency_key
           )
         end
       end
@@ -138,7 +130,7 @@ module AcidicJob
         # encode the identifier for this record in the job ID
         global_id = to_global_id.to_s.remove("gid://")
         # base64 encoding for minimal security
-        encoded_global_id = Base64.urlsafe_encode64(global_id, padding: false)
+        encoded_global_id = Base64.encode64(global_id).strip
 
         [
           STAGED_JOB_ID_PREFIX,
@@ -150,13 +142,8 @@ module AcidicJob
 
     concerning :Workflowable do
       included do
-        if REQUIRES_CODER_FOR_SERIALIZE
-          serialize :workflow, coder: AcidicJob::Serializer
-          serialize :error_object, coder: AcidicJob::Serializer
-        else
-          serialize :workflow, AcidicJob::Serializer
-          serialize :error_object, AcidicJob::Serializer
-        end
+        serialize :workflow, AcidicJob::Serializer
+        serialize :error_object, AcidicJob::Serializer
         store :attr_accessors, coder: AcidicJob::Serializer
 
         with_options unless: :staged? do
@@ -186,10 +173,6 @@ module AcidicJob
         current_step_hash.fetch("then")
       end
 
-      def current_step_awaits
-        current_step_hash["awaits"]
-      end
-
       def next_step_finishes?
         next_step_name.to_s == FINISHED_RECOVERY_POINT
       end
@@ -201,11 +184,7 @@ module AcidicJob
 
     concerning :Jobbable do
       included do
-        if REQUIRES_CODER_FOR_SERIALIZE
-          serialize :serialized_job, coder: JSON
-        else
-          serialize :serialized_job, JSON
-        end
+        serialize :serialized_job, JSON
 
         validates :serialized_job, presence: true
         validates :job_class, presence: true

data/lib/acidic_job/serializer.rb

@@ -10,11 +10,11 @@ module AcidicJob
         return if json.nil? || json.empty?
 
         data = JSON.parse(json)
-        Arguments.send :deserialize_argument, data
+        Arguments.deserialize(data).first
       end
 
       def dump(obj)
-        data = Arguments.send :serialize_argument, obj
+        data = Arguments.serialize [obj]
         data.to_json
       rescue ActiveJob::SerializationError
         raise UnserializableValue

data/lib/acidic_job/serializers/exception_serializer.rb

@@ -6,36 +6,31 @@ module AcidicJob
   module Serializers
     class ExceptionSerializer < ::ActiveJob::Serializers::ObjectSerializer
       def serialize(exception)
-        compressed_backtrace = {}
-        exception.backtrace&.map do |trace|
+        hash = {
+          "class" => exception.class.name,
+          "message" => exception.message,
+          "cause" => exception.cause,
+          "backtrace" => {}
+        }
+
+        exception.backtrace.map do |trace|
           path, _, location = trace.rpartition("/")
-          next if compressed_backtrace.key?(path)
 
-          compressed_backtrace[path] = location
+          next if hash["backtrace"].key?(path)
+
+          hash["backtrace"][path] = location
         end
-        exception.set_backtrace(compressed_backtrace.map do |path, location|
-          [path, location].join("/")
-        end)
-        exception.cause&.set_backtrace([])
 
-        super({ "yaml" => exception.to_yaml })
+        super(hash)
       end
 
       def deserialize(hash)
-        if hash.key?("class")
-          exception_class = hash["class"].constantize
-          exception = exception_class.new(hash["message"])
-          exception.set_backtrace(hash["backtrace"].map do |path, location|
-                                    [path, location].join("/")
-                                  end)
-          exception
-        elsif hash.key?("yaml")
-          if YAML.respond_to?(:unsafe_load)
-            YAML.unsafe_load(hash["yaml"])
-          else
-            YAML.load(hash["yaml"]) # rubocop:disable Security/YAMLLoad
-          end
-        end
+        exception_class = hash["class"].constantize
+        exception = exception_class.new(hash["message"])
+        exception.set_backtrace(hash["backtrace"].map do |path, location|
+          [path, location].join("/")
+        end)
+        exception
       end
 
       def serialize?(argument)

data/lib/acidic_job/serializers/job_serializer.rb

@@ -6,16 +6,24 @@ module AcidicJob
   module Serializers
     class JobSerializer < ::ActiveJob::Serializers::ObjectSerializer
       def serialize(job)
-        # don't serialize the `enqueued_at` value, as ActiveRecord will check if the Run record has changed
-        # by comparing the deserialized database value with a temporary in-memory generated value.
-        # That temporary in-memory generated value can sometimes have an `enqueued_at` value that is 1 second off
-        # from the original. In this case, ActiveRecord will think the record has unsaved changes and block the lock.
-        super(job.serialize.except("enqueued_at"))
+        super(job.serialize)
       end
 
       def deserialize(hash)
-        job = ::ActiveJob::Base.deserialize(hash)
+        job = ActiveJob::Base.deserialize(hash)
         job.send(:deserialize_arguments_if_needed)
+        # this is a shim to ensure we can work with Ruby 2.7 as well as 3.0+
+        # :nocov:
+        if job.arguments.last.is_a?(Hash)
+          *args, kwargs = job.arguments
+        else
+          args = job.arguments
+          kwargs = {}
+        end
+        # :nocov:
+        job.instance_variable_set(:@__acidic_job_args, args)
+        job.instance_variable_set(:@__acidic_job_kwargs, kwargs)
+
         job
       end
 

data/lib/acidic_job/serializers/worker_serializer.rb

@@ -2,24 +2,26 @@
 
 require "active_job/serializers/object_serializer"
 
+# :nocov:
 module AcidicJob
   module Serializers
     class WorkerSerializer < ::ActiveJob::Serializers::ObjectSerializer
       def serialize(worker)
         super(
-          "job_class" => worker.class.name
+          "job_class" => worker.class.name,
+          "arguments" => worker.arguments,
         )
       end
 
       def deserialize(hash)
         worker_class = hash["job_class"].constantize
-        worker_class.new
+        worker_class.new(*hash["arguments"])
       end
 
       def serialize?(argument)
-        defined?(::Sidekiq) && argument.class.include?(::Sidekiq::Worker) &&
-          !(defined?(::AcidicJob::ActiveKiq) && argument.class < ::AcidicJob::ActiveKiq)
+        defined?(::Sidekiq) && argument.class.include?(::Sidekiq::Worker)
       end
     end
   end
 end
+# :nocov:

data/lib/acidic_job/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AcidicJob
-  VERSION = "0.9.0"
+  VERSION = "1.0.0.beta.1"
 end

data/lib/acidic_job/workflow.rb

@@ -50,6 +50,10 @@ module AcidicJob
       wrapped_method = WorkflowStep.new(run: @run, job: @job).wrapped
       current_step = @run.current_step_name
 
+      # can't reproduce yet, but saw a bug in production where
+      # nested awaits workflows had an unsaved `workflow` attribute
+      @run.save! if @run.has_changes_to_save?
+
       AcidicJob.logger.log_run_event("Executing #{current_step}...", @job, @run)
       @run.with_lock do
         @step_result = wrapped_method.call(@run)
@@ -60,6 +64,10 @@ module AcidicJob
     def run_step_result
       next_step = @run.next_step_name
 
+      # can't reproduce yet, but saw a bug in production where
+      # nested awaits workflows had an unsaved `workflow` attribute
+      @run.save! if @run.has_changes_to_save?
+
       AcidicJob.logger.log_run_event("Progressing to #{next_step}...", @job, @run)
       @run.with_lock do
         @step_result.call(run: @run)

data/lib/acidic_job.rb

@@ -5,7 +5,6 @@ require_relative "acidic_job/errors"
 require_relative "acidic_job/logger"
 require_relative "acidic_job/arguments"
 require_relative "acidic_job/serializer"
-require_relative "acidic_job/configured_job"
 require_relative "acidic_job/workflow_builder"
 require_relative "acidic_job/idempotency_key"
 require_relative "acidic_job/recovery_point"
@@ -15,24 +14,25 @@ require_relative "acidic_job/workflow_step"
 require_relative "acidic_job/workflow"
 require_relative "acidic_job/processor"
 require_relative "acidic_job/perform_wrapper"
-require_relative "acidic_job/perform_acidicly"
-require_relative "acidic_job/extensions/action_mailer"
-require_relative "acidic_job/extensions/noticed"
 require_relative "acidic_job/mixin"
 require_relative "acidic_job/base"
-# require_relative "acidic_job/active_kiq"
+require_relative "acidic_job/active_kiq"
 
-require "active_job/serializers"
 require_relative "acidic_job/serializers/exception_serializer"
 require_relative "acidic_job/serializers/finished_point_serializer"
 require_relative "acidic_job/serializers/job_serializer"
 require_relative "acidic_job/serializers/range_serializer"
 require_relative "acidic_job/serializers/recovery_point_serializer"
 require_relative "acidic_job/serializers/worker_serializer"
-require_relative "acidic_job/serializers/active_kiq_serializer"
-require_relative "acidic_job/serializers/new_record_serializer"
-
-require_relative "acidic_job/railtie"
+require "active_job/serializers"
 
 module AcidicJob
+  ::ActiveJob::Serializers.add_serializers(
+    Serializers::ExceptionSerializer,
+    Serializers::FinishedPointSerializer,
+    Serializers::JobSerializer,
+    Serializers::RangeSerializer,
+    Serializers::RecoveryPointSerializer,
+    Serializers::WorkerSerializer
+  )
 end