acidic_job 1.0.0.rc3 → 1.0.0.rc5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8af9b244cf2343978f26322753e80c779c224ab6942c85de5a8fe05cf0ba55f2
-  data.tar.gz: 5f609ee36139400937e2a8b3cae42f721eb72f1abf6633ddbd275aa18c1b2242
+  metadata.gz: af6f1d0a08680695a243f3b045eb9eedd0bd7d6568e14acf8caefeeca4dc45f6
+  data.tar.gz: 533f91d24f7a4cfc5cbd9b74ef55f7207abd1ae00984fec545ad5590ca0b73b6
 SHA512:
-  metadata.gz: 6becc8ed3a1c1c58e24d52753e53edb206854cec472ffb4438e4711ea2a8abcd5adae080c621ab7b8bd30eb386118a51012a4f446e997277da3e9b12e460c696
-  data.tar.gz: fe04f817a6c2cab6b2284f7ce0a79b44f452e1c490abac18e6385b801a7ca00860e0910286886da6d70270b508ca54fa3ae4c13369d539e47c3ea4d12e9316d8
+  metadata.gz: 12a444e4a971df69a1f6f15c64ce0d3609104fe0e8a42ffc4ece9a6d948a5f799981e8ee087fcac45befea46b4f2d4f1279ef39b625cdc1a4db6618e04a98098
+  data.tar.gz: 05b26e35b45823c32063d41e6ee82b9ad49239de0a412c4c38328ad95391cad60e1e404c04638d0811d27c8073666a5f42cebc36912ac5c44a64d84ab46ad859

data/README.md

@@ -24,7 +24,7 @@ With AcidicJob, you can write reliable and repeatable multi-step distributed ope
 Install the gem and add to the application's Gemfile by executing:
 
 ```sh
-bundle add acidic_job --version "1.0.0.rc1"
+bundle add acidic_job --version "1.0.0.rc3"
 ```
 
 If `bundler` is not being used to manage dependencies, install the gem by executing:
@@ -109,7 +109,7 @@ The block passed to `execute_workflow` is where you define the steps of the work
 The `step` method is the only method available on the yielded workflow builder object, and it simply takes the name of a method available in the job.
 
 > [!IMPORTANT]
-> In order to craft resilient workflows, you need to ensure that each step method wraps a single unit of IO-bound work. You **must not** have a step method that performs multiple IO-bound operations, like writing to your database and calling an external API. Steps should be as granular and self-contained as possible. This allows your own logic to be more durable in case of failures in third-party APIs, network errors, and so on. So, the rule of thumb is to have only one _state mutation_ per step. And this rule of thumb graduates to a hard and fast rule for _foreign state mutations_. You **must** only have **one** foreign state mutation per step, where a foreign state mutation is any operation that writes to a system beyond your own boundaries. This might be creating a charge on Stripe, adding a DNS record, or sending an email.[^1]
+> In order to craft resilient workflows, you need to ensure that each step method wraps a single unit of IO-bound work. You **should not** have a step method that performs multiple IO-bound operations, like writing to your database and calling an external API. Steps should be as granular and self-contained as possible. This allows your own logic to be more durable in case of failures in third-party APIs, network errors, and so on. So, the rule of thumb is to have only one _state mutation_ per step. And this rule of thumb graduates to a hard and fast rule for _foreign state mutations_. You **must** only have **one** foreign state mutation per step, where a foreign state mutation is any operation that writes to a system beyond your own boundaries. This might be creating a charge on Stripe, adding a DNS record, or sending an email.[^1]
 
 [^1]: I first learned this rule from [Brandur Leach](https://twitter.com/brandur) reminds in his post on [Implementing Stripe-like Idempotency Keys in Postgres](https://brandur.org/idempotency-keys).
 
@@ -188,7 +188,7 @@ class Job < ActiveJob::Base
 
 ### Orchestrating steps
 
-In addition to the workflow definition setup, `AcidicJob` also provides a couple of methods to precisely control the workflow step execution. From within any step method, you can call either `repeat_step!` or `halt_step!`.
+In addition to the workflow definition setup, `AcidicJob` also provides a couple of methods to precisely control the workflow step execution. From within any step method, you can call either `repeat_step!` or `halt_workflow!`.
 
 `repeat_step!` will cause the current step to be re-executed on the next iteration of the workflow. This is useful when you need to traverse a collection of items and perform the same operation on each item. For example, if you need to send an email to each user in a collection, you could do something like this:
 
@@ -218,7 +218,7 @@ end
 
 This example demonstrates how you can leverage the basic building blocks provided by `AcidicJob` to orchestrate complex workflows. In this case, the `notify_users` step sends an email to each user in the collection, one at a time, and resiliently handles errors by storing a cursor in the `ctx` object to keep track of the current user being processed. If any error occurs while traversing the `@users` collection, the job will be retried, and the `notify_users` step will be re-executed from the last successful cursor position.
 
-The `halt_step!` method, on the other hand, stops not just the execution of the current step but the job as a whole. This is useful when you either need to conditionally stop the workflow based on some criteria or need to delay the job for some amount of time before being restarted. For example, if you need to send a follow-up email to a user 14 days after they sign up, you could do something like this:
+The `halt_workflow!` method, on the other hand, stops not just the execution of the current step but the job as a whole. This is useful when you either need to conditionally stop the workflow based on some criteria or need to delay the job for some amount of time before being restarted. For example, if you need to send a follow-up email to a user 14 days after they sign up, you could do something like this:
 
 ```ruby
 class Job < ActiveJob::Base
@@ -240,7 +240,7 @@ class Job < ActiveJob::Base
   def send_welcome_email
     if ctx[:halt]
       ctx[:halt] = false
-      halt_step!
+      halt_workflow!
     end
     UserMailer.with(user: @user).welcome_email.deliver_later
   end
@@ -252,7 +252,7 @@ In this example, the `delay` step creates a new instance of the job and enqueues
 
 ### Overview
 
-`AcidicJob` is a library that provides a small yet powerful set of tools to build cohesive and resilient workflows in your Active Jobs. All of the tools are made available by `include`ing the `AcidicJob::Workflow` module. The primary and most important tool is the `execute_workflow` method, which you call within your `perform` method. Then, if you need to store any contextual data, you use the `ctx` objects setters and getters. Finally, within any step methods, you can call `repeat_step!` or `halt_step!` to control the execution of the workflow. If you need, you can also access the `execution` Active Record object to get information about the current execution of the workflow. With these lightweight tools, you can build complex workflows that are resilient to failures and can handle a wide range of use cases.
+`AcidicJob` is a library that provides a small yet powerful set of tools to build cohesive and resilient workflows in your Active Jobs. All of the tools are made available by `include`ing the `AcidicJob::Workflow` module. The primary and most important tool is the `execute_workflow` method, which you call within your `perform` method. Then, if you need to store any contextual data, you use the `ctx` objects setters and getters. Finally, within any step methods, you can call `repeat_step!` or `halt_workflow!` to control the execution of the workflow. If you need, you can also access the `execution` Active Record object to get information about the current execution of the workflow. With these lightweight tools, you can build complex workflows that are resilient to failures and can handle a wide range of use cases.
 
 
 ## Testing

data/app/models/acidic_job/entry.rb

@@ -4,8 +4,10 @@ module AcidicJob
   class Entry < Record
     belongs_to :execution, class_name: "AcidicJob::Execution"
 
-    scope :for_step, ->(step) { where(step: step) }
-    scope :for_action, ->(action) { where(action: action) }
+    serialize :data, coder: AcidicJob::Serializer
+
+    scope :for_step, -> (step) { where(step: step) }
+    scope :for_action, -> (action) { where(action: action) }
     scope :ordered, -> { order(timestamp: :asc) }
 
     def self.most_recent

data/app/models/acidic_job/execution.rb

@@ -2,25 +2,40 @@
 
 module AcidicJob
   class Execution < Record
-    has_many :entries, class_name: "AcidicJob::Entry"
-    has_many :values, class_name: "AcidicJob::Value"
+    has_many :entries, class_name: "AcidicJob::Entry", dependent: :destroy
+    has_many :values, class_name: "AcidicJob::Value", dependent: :destroy
+
+    serialize :definition, coder: AcidicJob::Serializer
 
     validates :idempotency_key, presence: true # uniqueness constraint is enforced at the database level
     validates :serialized_job, presence: true
 
-    scope :finished, -> { where(recover_to: FINISHED_RECOVERY_POINT) }
-    scope :outstanding, lambda {
-                          where.not(recover_to: FINISHED_RECOVERY_POINT).or(where(recover_to: [nil, ""]))
-                        }
+    scope :finished, -> {
+      where(recover_to: FINISHED_RECOVERY_POINT)
+    }
+    scope :outstanding, -> {
+      where.not(recover_to: FINISHED_RECOVERY_POINT).or(where(recover_to: [nil, ""]))
+    }
+    scope :clearable, -> (finished_before: AcidicJob.clear_finished_executions_after.ago) {
+      finished.where(last_run_at: ...finished_before)
+    }
+
+    def self.clear_finished_in_batches(batch_size: 500, finished_before: AcidicJob.clear_finished_executions_after.ago, sleep_between_batches: 0)
+      loop do
+        records_deleted = clearable(finished_before: finished_before).limit(batch_size).delete_all
+        sleep(sleep_between_batches) if sleep_between_batches > 0
+        break if records_deleted == 0
+      end
+    end
 
-    def record!(step:, action:, timestamp:, **kwargs)
+    def record!(step:, action:, timestamp: Time.current, **kwargs)
       AcidicJob.instrument(:record_entry, step: step, action: action, timestamp: timestamp, data: kwargs) do
-        entries.create!(
+        entries.insert!({
           step: step,
           action: action,
           timestamp: timestamp,
-          data: kwargs.stringify_keys!
-        )
+          data: kwargs.except(:ignored),
+        })
       end
     end
 
@@ -29,10 +44,8 @@ module AcidicJob
     end
 
     def finished?
-      # rubocop:disable Style/MultipleComparison
       recover_to.to_s == FINISHED_RECOVERY_POINT ||
         recover_to.to_s == "FINISHED" # old value pre-1.0, remove at v1.0
-      # rubocop:enable Style/MultipleComparison
     end
 
     def defined?(step)

data/app/models/acidic_job/value.rb

@@ -3,5 +3,7 @@
 module AcidicJob
   class Value < Record
     belongs_to :execution, class_name: "AcidicJob::Execution"
+
+    serialize :value, coder: AcidicJob::Serializer
   end
 end

data/lib/acidic_job/builder.rb

@@ -28,9 +28,9 @@ module AcidicJob
 
       definition = {
         "meta" => {
-          "version" => VERSION
+          "version" => VERSION,
         },
-        "steps" => {}
+        "steps" => {},
       }
 
       definition.tap do |workflow|

data/lib/acidic_job/context.rb

@@ -8,14 +8,31 @@ module AcidicJob
 
     def set(hash)
       AcidicJob.instrument(:set_context, **hash) do
-        AcidicJob::Value.upsert_all(
-          hash.map do |key, value|
-            { execution_id: @execution.id,
-              key: key,
-              value: value }
-          end,
-          unique_by: %i[execution_id key]
-        )
+        records = hash.map do |key, value|
+          {
+            execution_id: @execution.id,
+            key: key,
+            value: value,
+          }
+        end
+
+        case AcidicJob::Value.connection.adapter_name.downcase.to_sym
+        when :postgresql, :sqlite
+          AcidicJob::Value.upsert_all(records, unique_by: [:execution_id, :key])
+        when :mysql2, :mysql, :trilogy
+          AcidicJob::Value.upsert_all(records)
+        else
+          # Fallback for other adapters - try with unique_by first, fall back without
+          begin
+            AcidicJob::Value.upsert_all(records, unique_by: [:execution_id, :key])
+          rescue ArgumentError => e
+            if e.message.include?("does not support :unique_by")
+              AcidicJob::Value.upsert_all(records)
+            else
+              raise
+            end
+          end
+        end
       end
     end
 
@@ -25,22 +42,21 @@ module AcidicJob
       end
     end
 
-    # TODO: deprecate these methods
+    def fetch(key, default = nil)
+      result = get(key).first
+      return result if result
+
+      fallback = default || yield(key)
+      set(key => fallback)
+      fallback
+    end
+
     def []=(key, value)
-      AcidicJob.instrument(:set_context, key: key, value: value) do
-        AcidicJob::Value.upsert(
-          { execution_id: @execution.id,
-            key: key,
-            value: value },
-          unique_by: %i[execution_id key]
-        )
-      end
+      set(key => value)
     end
 
     def [](key)
-      AcidicJob.instrument(:get_context, key: key) do
-        @execution.values.select(:value).find_by(key: key)&.value
-      end
+      get(key).first
     end
   end
 end

data/lib/acidic_job/errors.rb

@@ -28,7 +28,6 @@ module AcidicJob
     end
   end
 
-  # rubocop:disable Lint/MissingSuper
   class ArgumentMismatchError < Error
     def initialize(expected, existing)
       @expected = expected
@@ -101,7 +100,7 @@ module AcidicJob
 
   class DoublePluginCallError < Error
     def initialize(plugin, step)
-      @plugin_name = Module === plugin ? plugin.name : plugin.class.name # rubocop:disable Style/CaseEquality
+      @plugin_name = (Module === plugin) ? plugin.name : plugin.class.name
       @step = step
     end
 
@@ -112,7 +111,7 @@ module AcidicJob
 
   class MissingPluginCallError < Error
     def initialize(plugin, step)
-      @plugin_name = Module === plugin ? plugin.name : plugin.class.name # rubocop:disable Style/CaseEquality
+      @plugin_name = (Module === plugin) ? plugin.name : plugin.class.name
       @step = step
     end
 

data/lib/acidic_job/log_subscriber.rb

@@ -28,22 +28,20 @@ module AcidicJob
       debug formatted_event(event, title: "Record entry", **event.payload.slice(:step, :action, :timestamp))
     end
 
-    private
-
-    def formatted_event(event, title:, **attributes)
+    private def formatted_event(event, title:, **attributes)
       "AcidicJob-#{AcidicJob::VERSION} #{title} (#{event.duration.round(1)}ms)  #{formatted_attributes(**attributes)}"
     end
 
-    def formatted_attributes(**attributes)
+    private def formatted_attributes(**attributes)
       attributes.map { |attr, value| "#{attr}: #{value.inspect}" }.join(", ")
     end
 
-    def formatted_error(error)
+    private def formatted_error(error)
       [error.class, error.message].compact.join(" ")
     end
 
     # Use the logger configured for AcidicJob
-    def logger
+    private def logger
       AcidicJob.logger
     end
   end

data/lib/acidic_job/plugin_context.rb

@@ -4,13 +4,22 @@ module AcidicJob
   class PluginContext
     PLUGIN_INACTIVE = :__ACIDIC_JOB_PLUGIN_INACTIVE__
 
-    def initialize(plugin, job, execution, step_definition)
+    def initialize(plugin, job, execution, context, step_definition)
       @plugin = plugin
       @job = job
       @execution = execution
+      @context = context
       @step_definition = step_definition
     end
 
+    def set(hash)
+      @context.set(hash)
+    end
+
+    def get(*keys)
+      @context.get(*keys)
+    end
+
     def definition
       @step_definition.fetch(@plugin.keyword.to_s, PLUGIN_INACTIVE)
     end
@@ -40,8 +49,22 @@ module AcidicJob
       @job.enqueue(...)
     end
 
-    def halt_step!
-      @job.halt_step!
+    def halt_workflow!
+      @job.halt_workflow!
+    end
+
+    def repeat_step!
+      @job.repeat_step!
+    end
+
+    def resolve_method(method_name)
+      begin
+        method_obj = @job.method(method_name)
+      rescue NameError
+        raise UndefinedMethodError.new(method_name)
+      end
+
+      method_obj
     end
 
     def plugin_action(action)

data/lib/acidic_job/plugins/transactional_step.rb

@@ -26,10 +26,10 @@ module AcidicJob
         return yield if context.definition == false
 
         model = if context.definition == true
-                  AcidicJob::Execution
-                else
-                  context.definition["on"].constantize
-                end
+          AcidicJob::Execution
+        else
+          context.definition["on"].constantize
+        end
 
         model.transaction(&block)
       end

data/lib/acidic_job/serializer.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "arguments"
+
+module AcidicJob
+  # Used for `serialize` method in ActiveRecord
+  module Serializer
+    extend self
+
+    def load(json)
+      return if json.nil? || json.empty?
+
+      data = JSON.parse json
+
+      Arguments.__send__ :deserialize_argument, data
+    end
+
+    def dump(obj)
+      data = Arguments.__send__ :serialize_argument, obj
+
+      JSON.generate data, strict: true
+    rescue ActiveJob::SerializationError => e
+      e.message << " (`#{obj.inspect}`)"
+      raise e
+    end
+  end
+end

data/lib/acidic_job/serializers/job_serializer.rb

@@ -15,7 +15,7 @@ module AcidicJob
 
       def deserialize(hash)
         job = ::ActiveJob::Base.deserialize(hash)
-        job.send(:deserialize_arguments_if_needed)
+        job.__send__(:deserialize_arguments_if_needed)
         job
       end
 

data/lib/acidic_job/serializers/range_serializer.rb

@@ -17,9 +17,7 @@ module AcidicJob
         klass.new(*Arguments.deserialize(hash.values_at(*KEYS)))
       end
 
-      private
-
-      def klass
+      private def klass
         ::Range
       end
     end

data/lib/acidic_job/testing.rb

@@ -22,25 +22,23 @@ module AcidicJob
       ::DatabaseCleaner.cleaners = @original_cleaners
     end
 
-    private
-
     # Ensure that the system's original DatabaseCleaner configuration is maintained, options included,
     # except that any `transaction` strategies for any ORMs are replaced with a `deletion` strategy.
-    def transaction_free_cleaners_for(original_cleaners)
+    private def transaction_free_cleaners_for(original_cleaners)
       non_transaction_cleaners = original_cleaners.dup.to_h do |(orm, opts), cleaner|
         [[orm, opts], ensure_no_transaction_strategies_for(cleaner)]
       end
       ::DatabaseCleaner::Cleaners.new(non_transaction_cleaners)
     end
 
-    def ensure_no_transaction_strategies_for(cleaner)
+    private def ensure_no_transaction_strategies_for(cleaner)
       return cleaner unless strategy_name_for(cleaner) == "transaction"
 
       cleaner.strategy = deletion_strategy_for(cleaner)
       cleaner
     end
 
-    def strategy_name_for(cleaner)
+    private def strategy_name_for(cleaner)
       cleaner               # <DatabaseCleaner::Cleaner>
         .strategy           # <DatabaseCleaner::ActiveRecord::Truncation>
         .class              # DatabaseCleaner::ActiveRecord::Truncation
@@ -50,19 +48,19 @@ module AcidicJob
         .downcase           # "truncation"
     end
 
-    def deletion_strategy_for(cleaner)
+    private def deletion_strategy_for(cleaner)
       strategy = cleaner.strategy
-      strategy_namespace = strategy                    # <DatabaseCleaner::ActiveRecord::Truncation>
-                           .class                      # DatabaseCleaner::ActiveRecord::Truncation
-                           .name                       # "DatabaseCleaner::ActiveRecord::Truncation"
-                           .rpartition("::")           # ["DatabaseCleaner::ActiveRecord", "::", "Truncation"]
-                           .first                      # "DatabaseCleaner::ActiveRecord"
+      strategy_namespace = strategy # <DatabaseCleaner::ActiveRecord::Truncation>
+        .class                      # DatabaseCleaner::ActiveRecord::Truncation
+        .name                       # "DatabaseCleaner::ActiveRecord::Truncation"
+        .rpartition("::")           # ["DatabaseCleaner::ActiveRecord", "::", "Truncation"]
+        .first                      # "DatabaseCleaner::ActiveRecord"
       deletion_strategy_class_name = [strategy_namespace, "::", "Deletion"].join
       deletion_strategy_class = deletion_strategy_class_name.constantize
       instance_variable_hash = strategy.instance_variables.to_h do |var|
         [
           var.to_s.remove("@"),
-          strategy.instance_variable_get(var)
+          strategy.instance_variable_get(var),
         ]
       end
       options = instance_variable_hash.except("db", "connection_class")

data/lib/acidic_job/version.rb

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

data/lib/acidic_job/workflow.rb

@@ -8,7 +8,7 @@ module AcidicJob
     HALT_STEP = :__ACIDIC_JOB_HALT_STEP_SIGNAL__
     private_constant :REPEAT_STEP, :HALT_STEP
 
-    def execute_workflow(unique_by:, with: [Plugins::TransactionalStep], &block)
+    def execute_workflow(unique_by:, with: AcidicJob.plugins, &block)
       @__acidic_job_plugins__ = with
       serialized_job = serialize
 
@@ -30,13 +30,13 @@ module AcidicJob
 
       AcidicJob.instrument(:initialize_workflow, definition: workflow_definition) do
         transaction_args = case ::ActiveRecord::Base.connection.adapter_name.downcase.to_sym
-                           # SQLite doesn't support `serializable` transactions
-                           when :sqlite
-                             {}
-                           else
-                             { isolation: :serializable }
-                           end
-        idempotency_key = Digest::SHA256.hexdigest(JSON.fast_generate([self.class.name, unique_by], strict: true))
+          # SQLite doesn't support `serializable` transactions
+          when :sqlite
+            {}
+          else
+            { isolation: :serializable }
+        end
+        idempotency_key = Digest::SHA256.hexdigest(JSON.generate([self.class.name, unique_by], strict: true))
 
         @__acidic_job_execution__ = ::ActiveRecord::Base.transaction(**transaction_args) do
           record = Execution.find_by(idempotency_key: idempotency_key)
@@ -61,11 +61,11 @@ module AcidicJob
             )
           else
             starting_point = if workflow_definition.key?("steps")
-                               workflow_definition["steps"].keys.first
-                             else
-                               # TODO: add deprecation warning
-                               workflow_definition.keys.first
-                             end
+              workflow_definition["steps"].keys.first
+            else
+              # TODO: add deprecation warning
+              workflow_definition.keys.first
+            end
 
             record = Execution.create!(
               idempotency_key: idempotency_key,
@@ -89,7 +89,7 @@ module AcidicJob
 
           current_step = @__acidic_job_execution__.recover_to
 
-          if not @__acidic_job_execution__.defined?(current_step) # rubocop:disable Style/Not
+          if not @__acidic_job_execution__.defined?(current_step)
             raise UndefinedStepError.new(current_step)
           end
 
@@ -101,11 +101,10 @@ module AcidicJob
               @__acidic_job_execution__.record!(
                 step: step_definition.fetch("does"),
                 action: :halted,
-                timestamp: Time.now
               )
               return true
             else
-              @__acidic_job_execution__.update!(recover_to: recover_to)
+              @__acidic_job_execution__.update_column(:recover_to, recover_to)
             end
           end
         end
@@ -116,14 +115,19 @@ module AcidicJob
       throw :repeat, REPEAT_STEP
     end
 
-    def halt_step!
+    def halt_workflow!
       throw :halt, HALT_STEP
     end
 
+    def halt_step!
+      # TODO add deprecation warning
+      halt_workflow!
+    end
+
     def step_retrying?
       step_name = caller_locations.first.label
 
-      if not @__acidic_job_execution__.defined?(step_name) # rubocop:disable Style/IfUnlessModifier, Style/Not
+      if not @__acidic_job_execution__.defined?(step_name)
         raise UndefinedStepError.new(step_name)
       end
 
@@ -138,9 +142,7 @@ module AcidicJob
       @__acidic_job_context__
     end
 
-    private
-
-    def take_step(step_definition)
+    private def take_step(step_definition)
       curr_step = step_definition.fetch("does")
       next_step = step_definition.fetch("then")
 
@@ -148,7 +150,7 @@ module AcidicJob
 
       rescued_error = nil
       begin
-        @__acidic_job_execution__.record!(step: curr_step, action: :started, timestamp: Time.now)
+        @__acidic_job_execution__.record!(step: curr_step, action: :started)
         result = AcidicJob.instrument(:perform_step, **step_definition) do
           perform_step_for(step_definition)
         end
@@ -156,10 +158,16 @@ module AcidicJob
         when REPEAT_STEP
           curr_step
         else
-          @__acidic_job_execution__.record!(step: curr_step, action: :succeeded, timestamp: Time.now, result: result)
+          @__acidic_job_execution__.record!(
+            step: curr_step,
+            action: :succeeded,
+            ignored: {
+              result: result,
+            }
+          )
           next_step
         end
-      rescue StandardError => e
+      rescue => e
         rescued_error = e
         raise e
       ensure
@@ -168,11 +176,10 @@ module AcidicJob
             @__acidic_job_execution__.record!(
               step: curr_step,
               action: :errored,
-              timestamp: Time.now,
               exception_class: rescued_error.class.name,
               message: rescued_error.message
             )
-          rescue StandardError => e
+          rescue => e
             # We're already inside an error condition, so swallow any additional
             # errors from here and just send them to logs.
             logger.error(
@@ -183,7 +190,7 @@ module AcidicJob
       end
     end
 
-    def perform_step_for(step_definition)
+    private def perform_step_for(step_definition)
       step_name = step_definition.fetch("does")
       begin
         step_method = method(step_name)
@@ -191,10 +198,10 @@ module AcidicJob
         raise UndefinedMethodError.new(step_name)
       end
 
-      raise InvalidMethodError.new(step_name) unless step_method.arity.zero?
+      # raise InvalidMethodError.new(step_name) unless step_method.arity.zero?
 
       plugin_pipeline_callable = @__acidic_job_plugins__.reverse.reduce(step_method) do |callable, plugin|
-        context = PluginContext.new(plugin, self, @__acidic_job_execution__, step_definition)
+        context = PluginContext.new(plugin, self, @__acidic_job_execution__, @__acidic_job_context__, step_definition)
 
         if context.inactive?
           callable
@@ -202,14 +209,19 @@ module AcidicJob
           proc do
             called = false
 
-            result = plugin.around_step(context) do
+            result = plugin.around_step(context) do |*args, **kwargs|
               raise DoublePluginCallError.new(plugin, step_name) if called
 
               called = true
-              callable.call
+
+              if callable.arity.zero?
+                callable.call
+              else
+                callable.call(*args, **kwargs)
+              end
             end
 
-            raise MissingPluginCallError.new(plugin, step_name) unless called
+            # raise MissingPluginCallError.new(plugin, step_name) unless called
 
             result
           end