acidic_job 1.0.0.pre11 → 1.0.0.pre14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53b5f12879bffb6a461e3574b96f8a41464ec83ce0a21eaa8e244261ce53a9be
-  data.tar.gz: 7b90c9864347564706466e62c61f08eb377d8e3a33475ad40ba559de59e7b70e
+  metadata.gz: fcc6621d513d4284bb09bdb4da7433b81b2c240ce9873dbf1348569e76942960
+  data.tar.gz: 411b5819c7faab9f8bcb19f39bd4dc5c8a03d42f28239f5f19489b2f7d01eb68
 SHA512:
-  metadata.gz: '08b4a0bdd41ac80f8ac879003f455f577f93fc431acdb780dfd3e54260b07a61bf0557c3e7d99192e1ad809134b709211fd2c5efe581b797563187dcfbb34467'
-  data.tar.gz: 66e8b3bfe0226c3e1f5168d45431a01a36ee3dfb796c855c49fc009296cb223d33922bc2db5febbe6d6453b4a01c46661b805aa1e2c80a4e37f3dce183b5e748
+  metadata.gz: 644bc4268dfa5c66804e169314f67452b4046bdbbd4b013589b6463e0c79363407d8fbdecfc2db3197cccdb75c558059492b2a9f22a0eca0198f7033836abd05
+  data.tar.gz: 2807478181d478a7ee10e082e7f76f42409e3c587e436712396371d92d8b53481b0606a19bbcb108fa2cb95c4529f4b9ca86b146cf1aec64c53954c57eda5971

data/.tool-versions

@@ -0,0 +1 @@
+ruby 3.0.2

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    acidic_job (1.0.0.pre11)
+    acidic_job (1.0.0.pre14)
       activerecord (>= 6.1.0)
       activesupport
 

data/README.md

@@ -1,5 +1,8 @@
 # AcidicJob
 
+[![Gem Version](https://badge.fury.io/rb/acidic_job.svg)](https://badge.fury.io/rb/acidic_job)
+![main workflow](https://github.com/fractaledmind/acidic_job/actions/workflows/main.yml/badge.svg)
+
 ### Idempotent operations for Rails apps (for ActiveJob or Sidekiq)
 
 At the conceptual heart of basically any software are "operations"—the discrete actions the software performs. Rails provides a powerful abstraction layer for building operations in the form of `ActiveJob`, or we Rubyists can use the tried and true power of pure `Sidekiq`. With either we can easily trigger from other Ruby code throughout our Rails application (controller actions, model methods, model callbacks, etc.); we can run operations both synchronously (blocking execution and then returning its response to the caller) and asychronously (non-blocking and the caller doesn't know its response); and we can also retry a specific operation if needed seamlessly.
@@ -193,16 +196,20 @@ class ExampleJob < ActiveJob::Base
 end
 ```
 
-These options cover the two common situations, but sometimes our systems need finer-grained control. For example, our job might take some record as the job argument, but we need to use a combination of the record identifier and record status as the foundation for the idempotency key. In these cases we can't configure the idempotency key logic at the class level, so instead we can provide the logic when enqueuing the job itself.
-
-When you call any `deliver_acidicly` or `perform_acidicly` method you can pass an optional `unique_by` argument which will be used to generate the idempotency key:
+These options cover the two common situations, but sometimes our systems need finer-grained control. For example, our job might take some record as the job argument, but we need to use a combination of the record identifier and record status as the foundation for the idempotency key. In these cases you can pass a `Proc` to an `acidic_by` class method:
 
 ```ruby
-ExampleJob.perform_acidicly(unique_by: { id: record.id, status: record.status })
-UserMailer.with(user, record).deliver_acidicly(unique_by: [user.id, record.id, record.status])
+class ExampleJob < ActiveJob::Base
+  include AcidicJob
+  acidic_by ->(record:) { [record.id, record.status] }
+
+  def perform(record:)
+    # the idempotency key will be based on whatever the values of `record.id` and `record.status` are
+  end
+end
 ```
 
-As you see, the value to the `unique_by` option can be a Hash or an Array or even a simple scalar value.
+> **Note:** The signature of the `acidic_by` proc _needs to match the signature_ of the job's `perform` method.
 
 
 ### Sidekiq Callbacks

data/lib/acidic_job/awaiting.rb

@@ -6,47 +6,32 @@ module AcidicJob
   module Awaiting
     extend ActiveSupport::Concern
 
-    class_methods do
-      # TODO: Allow the `perform` method to be used to kick off Sidekiq Batch powered workflows
-      def initiate(*args)
-        raise SidekiqBatchRequired unless defined?(Sidekiq::Batch)
-
-        top_level_workflow = Sidekiq::Batch.new
-        top_level_workflow.on(:success, self, *args)
-        top_level_workflow.jobs do
-          perform_async
-        end
-      end
-    end
-
     def enqueue_step_parallel_jobs(jobs, run, step_result)
       # `batch` is available from Sidekiq::Pro
       raise SidekiqBatchRequired unless defined?(Sidekiq::Batch)
 
-      batch.jobs do
-        step_batch = Sidekiq::Batch.new
-        # step_batch.description = "AcidicJob::Workflow Step: #{step}"
-        step_batch.on(
-          :success,
-          "#{self.class.name}#step_done",
-          # NOTE: options are marshalled through JSON so use only basic types.
-          { "run_id" => run.id,
-            "step_result_yaml" => step_result.to_yaml.strip }
-        )
-        # NOTE: The jobs method is atomic.
-        # All jobs created in the block are actually pushed atomically at the end of the block.
-        # If an error is raised, none of the jobs will go to Redis.
-        step_batch.jobs do
-          jobs.each do |worker_name|
-            # TODO: handle Symbols as well
-            worker = worker_name.is_a?(String) ? worker_name.constantize : worker_name
-            if worker.instance_method(:perform).arity.zero?
-              worker.perform_async
-            elsif worker.instance_method(:perform).arity == 1
-              worker.perform_async(run.id)
-            else
-              raise TooManyParametersForParallelJob
-            end
+      step_batch = Sidekiq::Batch.new
+      # step_batch.description = "AcidicJob::Workflow Step: #{step}"
+      step_batch.on(
+        :success,
+        "#{self.class.name}#step_done",
+        # NOTE: options are marshalled through JSON so use only basic types.
+        { "run_id" => run.id,
+          "step_result_yaml" => step_result.to_yaml.strip }
+      )
+      # NOTE: The jobs method is atomic.
+      # All jobs created in the block are actually pushed atomically at the end of the block.
+      # If an error is raised, none of the jobs will go to Redis.
+      step_batch.jobs do
+        jobs.each do |worker_name|
+          # TODO: handle Symbols as well
+          worker = worker_name.is_a?(String) ? worker_name.constantize : worker_name
+          if worker.instance_method(:perform).arity.zero?
+            worker.perform_async
+          elsif worker.instance_method(:perform).arity == 1
+            worker.perform_async(run.id)
+          else
+            raise TooManyParametersForParallelJob
           end
         end
       end

data/lib/acidic_job/extensions/action_mailer.rb

@@ -7,19 +7,14 @@ module AcidicJob
     module ActionMailer
       extend ActiveSupport::Concern
 
-      def deliver_acidicly(_options = {}, unique_by: nil)
+      def deliver_acidicly(_options = {})
         job_class = ::ActionMailer::MailDeliveryJob
 
         job_args = [@mailer_class.name, @action.to_s, "deliver_now", @params, *@args]
         # for Sidekiq, this depends on the Sidekiq::Serialization extension
         serialized_job = job_class.new(job_args).serialize
         acidic_identifier = job_class.respond_to?(:acidic_identifier) ? job_class.acidic_identifier : :job_id
-        # use either [1] provided uniqueness constraint or [2] computed key
-        key = if unique_by
-                IdempotencyKey.generate(unique_by: unique_by, job_class: job_class.name)
-              else
-                IdempotencyKey.new(acidic_identifier).value_for(serialized_job)
-              end
+        key = IdempotencyKey.new(acidic_identifier).value_for(serialized_job)
 
         AcidicJob::Run.create!(
           staged: true,

data/lib/acidic_job/extensions/active_job.rb

@@ -24,13 +24,7 @@ module AcidicJob
           raise UnsupportedExtension unless defined?(::ActiveJob) && self < ::ActiveJob::Base
 
           serialized_job = serialize_with_arguments(*args, **kwargs)
-          # use either [1] provided uniqueness constraint or [2] computed key
-          key = if kwargs.key?(:unique_by) || kwargs.key?("unique_by")
-                  unique_by = [kwargs[:unique_by], kwargs["unique_by"]].compact.first
-                  IdempotencyKey.generate(unique_by: unique_by, job_class: name)
-                else
-                  IdempotencyKey.new(acidic_identifier).value_for(serialized_job)
-                end
+          key = IdempotencyKey.new(acidic_identifier).value_for(serialized_job)
 
           AcidicJob::Run.create!(
             staged: true,

data/lib/acidic_job/extensions/noticed.rb

@@ -6,12 +6,12 @@ module AcidicJob
       extend ActiveSupport::Concern
 
       class_methods do
-        def deliver_acidicly(recipients, unique_by: nil)
-          new.deliver_acidicly(recipients, unique_by: unique_by)
+        def deliver_acidicly(recipients)
+          new.deliver_acidicly(recipients)
         end
       end
 
-      def deliver_acidicly(recipients, unique_by: nil)
+      def deliver_acidicly(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
@@ -37,12 +37,7 @@ module AcidicJob
             }
             serialized_job = job_class.send(:job_or_instantiate, args).serialize
             acidic_identifier = job_class.respond_to?(:acidic_identifier) ? job_class.acidic_identifier : :job_id
-            # use either [1] provided uniqueness constraint or [2] computed key
-            key = if unique_by
-                    IdempotencyKey.generate(unique_by: unique_by, job_class: job_class.name)
-                  else
-                    IdempotencyKey.new(acidic_identifier).value_for(serialized_job)
-                  end
+            key = IdempotencyKey.new(acidic_identifier).value_for(serialized_job)
 
             AcidicJob::Run.create!(
               staged: true,

data/lib/acidic_job/extensions/sidekiq.rb

@@ -34,9 +34,10 @@ module AcidicJob
           end
         end
 
-        def serialize_job(args = [], _kwargs = nil)
+        def serialize_job(*args, **kwargs)
           # `@args` is only set via `deserialize`; it is not a standard Sidekiq thing
           arguments = args || @args
+          arguments += [kwargs] unless kwargs.empty?
           normalized_args = ::Sidekiq.load_json(::Sidekiq.dump_json(arguments))
           item = { "class" => self.class, "args" => normalized_args, "jid" => jid }
           sidekiq_options = sidekiq_options_hash || {}
@@ -58,13 +59,7 @@ module AcidicJob
         class_methods do
           def perform_acidicly(*args, **kwargs)
             serialized_job = serialize_with_arguments(*args, **kwargs)
-            # use either [1] provided uniqueness constraint or [2] computed key
-            key = if kwargs.key?(:unique_by) || kwargs.key?("unique_by")
-                    unique_by = [kwargs[:unique_by], kwargs["unique_by"]].compact.first
-                    IdempotencyKey.generate(unique_by: unique_by, job_class: name)
-                  else
-                    IdempotencyKey.new(acidic_identifier).value_for(serialized_job)
-                  end
+            key = IdempotencyKey.new(acidic_identifier).value_for(serialized_job)
 
             AcidicJob::Run.create!(
               staged: true,

data/lib/acidic_job/idempotency_key.rb

@@ -2,21 +2,22 @@
 
 module AcidicJob
   class IdempotencyKey
-    def self.generate(unique_by:, job_class:)
-      new(:job_args).value_for({ "job_class" => job_class }, Marshal.dump(unique_by))
-    end
-
     def initialize(identifier = :job_id)
       @identifier = identifier
     end
 
     def value_for(hash_or_job, *args, **kwargs)
-      return value_from_job_args(hash_or_job, *args, **kwargs) if @identifier == :job_args
-
-      value = if hash_or_job.is_a?(Hash)
-                value_from_job_id_for_hash(hash_or_job)
+      value = case @identifier
+              when Proc
+                value_from_proc(hash_or_job, *args, **kwargs)
+              when :job_args
+                value_from_job_args(hash_or_job, *args, **kwargs)
               else
-                value_from_job_id_for_obj(hash_or_job)
+                if hash_or_job.is_a?(Hash)
+                  value_from_job_id_for_hash(hash_or_job)
+                else
+                  value_from_job_id_for_obj(hash_or_job)
+                end
               end
 
       value || value_from_job_args(hash_or_job, *args, **kwargs)
@@ -62,5 +63,12 @@ module AcidicJob
 
       Digest::SHA1.hexdigest [worker_class, args, kwargs].flatten.join
     end
+
+    def value_from_proc(_hash_or_job, *args, **kwargs)
+      return if args.empty? && kwargs.empty?
+
+      idempotency_args = Array(@identifier.call(*args, **kwargs))
+      Digest::SHA1.hexdigest idempotency_args.flatten.join
+    end
   end
 end

data/lib/acidic_job/perform_wrapper.rb

@@ -4,46 +4,19 @@ module AcidicJob
   # NOTE: it is essential that this be a bare module and not an ActiveSupport::Concern
   module PerformWrapper
     def perform(*args, **kwargs)
-      super_method = method(:perform).super_method
+      @__acidic_job_args = args
+      @__acidic_job_kwargs = kwargs
 
       # we don't want to run the `perform` callbacks twice, since ActiveJob already handles that for us
-      if aj_job?
-        __acidic_job_perform_for_aj(super_method, *args, **kwargs)
-      elsif sk_job?
-        __acidic_job_perform_for_sk(super_method, *args, **kwargs)
+      if defined?(ActiveJob) && self.class < ActiveJob::Base
+        super(*args, **kwargs)
+      elsif defined?(Sidekiq) && self.class.include?(Sidekiq::Worker)
+        run_callbacks :perform do
+          super(*args, **kwargs)
+        end
       else
         raise UnknownJobAdapter
       end
     end
-
-    def sk_job?
-      defined?(Sidekiq) && self.class.include?(Sidekiq::Worker)
-    end
-
-    def aj_job?
-      defined?(ActiveJob) && self.class < ActiveJob::Base
-    end
-
-    private
-
-    # don't run `perform` callbacks, as ActiveJob already does this
-    def __acidic_job_perform_for_aj(super_method, *args, **kwargs)
-      __acidic_job_perform_base(super_method, *args, **kwargs)
-    end
-
-    # ensure to run `perform` callbacks
-    def __acidic_job_perform_for_sk(super_method, *args, **kwargs)
-      run_callbacks :perform do
-        __acidic_job_perform_base(super_method, *args, **kwargs)
-      end
-    end
-
-    # capture arguments passed to `perform` to be used by AcidicJob later
-    def __acidic_job_perform_base(super_method, *args, **kwargs)
-      @__acidic_job_args = args
-      @__acidic_job_kwargs = kwargs
-
-      super_method.call(*args, **kwargs)
-    end
   end
 end

data/lib/acidic_job/staging.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_support/concern"
+require "global_id/locator"
 
 module AcidicJob
   module Staging

data/lib/acidic_job/version.rb

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

data/lib/acidic_job.rb

@@ -50,6 +50,7 @@ module AcidicJob
     klass.instance_variable_set(:@acidic_identifier, :job_id)
     klass.define_singleton_method(:acidic_by_job_id) { @acidic_identifier = :job_id }
     klass.define_singleton_method(:acidic_by_job_args) { @acidic_identifier = :job_args }
+    klass.define_singleton_method(:acidic_by) { |proc| @acidic_identifier = proc }
   end
 
   included do
@@ -67,9 +68,20 @@ module AcidicJob
     end
   end
 
-  def with_acidity(providing: {})
+  def initialize(*args, **kwargs)
     # ensure this instance variable is always defined
     @__acidic_job_steps = []
+    @__acidic_job_args = args
+    @__acidic_job_kwargs = kwargs
+
+    if method(__method__).super_method.arity.zero?
+      super()
+    else
+      super(*args, **kwargs)
+    end
+  end
+
+  def with_acidity(providing: {})
     # execute the block to gather the info on what steps are defined for this job workflow
     yield
 
@@ -98,7 +110,6 @@ module AcidicJob
     FinishedPoint.new
   end
 
-  # TODO: allow idempotency to be defined by args OR job id
   # rubocop:disable Naming/MemoizedInstanceVariableName
   def idempotency_key
     if defined?(@__acidic_job_idempotency_key) && !@__acidic_job_idempotency_key.nil?
@@ -107,7 +118,7 @@ module AcidicJob
 
     acidic_identifier = self.class.acidic_identifier
     @__acidic_job_idempotency_key ||= IdempotencyKey.new(acidic_identifier)
-                                                    .value_for(self, @__acidic_job_args, @__acidic_job_kwargs)
+                                                    .value_for(self, *@__acidic_job_args, **@__acidic_job_kwargs)
   end
   # rubocop:enable Naming/MemoizedInstanceVariableName
 
@@ -124,7 +135,7 @@ module AcidicJob
 
       # if any step calls `safely_finish_acidic_job` or the workflow has simply completed,
       # be sure to break out of the loop
-      if recovery_point == Run::FINISHED_RECOVERY_POINT.to_s # rubocop:disable Style/GuardClause
+      if recovery_point.to_s == Run::FINISHED_RECOVERY_POINT.to_s # rubocop:disable Style/GuardClause
         break
       elsif current_step.nil?
         raise UnknownRecoveryPoint, "Defined workflow does not reference this step: #{recovery_point}"
@@ -191,7 +202,7 @@ module AcidicJob
 
     ActiveRecord::Base.transaction(isolation: isolation_level) do
       run = Run.find_by(idempotency_key: idempotency_key)
-      serialized_job = serialize_job(@__acidic_job_args, @__acidic_job_kwargs)
+      serialized_job = serialize_job(*@__acidic_job_args, **@__acidic_job_kwargs)
 
       if run.present?
         # Programs enqueuing multiple jobs with different parameters but the

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: acidic_job
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre11
+  version: 1.0.0.pre14
 platform: ruby
 authors:
 - fractaledmind
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-03-13 00:00:00.000000000 Z
+date: 2022-03-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -63,6 +63,7 @@ files:
 - ".gitignore"
 - ".rubocop.yml"
 - ".ruby_version"
+- ".tool-versions"
 - Gemfile
 - Gemfile.lock
 - LICENSE