chrono_forge 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be157f4c6a7dbf68348d63c5a67b3c07de4cb981dac1ef8e28e1eebe1d382088
-  data.tar.gz: 4b60dcf5976495716fd1ff661a87dcc0b866daa8c48672723d2d438b5ced4f1d
+  metadata.gz: 1f2655b7f5ea191bd4c80e36b5e6e55439ad04f8570fb29d36ce0f6dc66ce687
+  data.tar.gz: ce5509c4fc6ee82179c6f14be7bf887f41f09ec0f344ef976ba3ac4691305725
 SHA512:
-  metadata.gz: 473a8bb888d88fb8df928c935a8fdeb9941fdfa8cd006e7e90491ce02c64fd73bc5e185c45db94dd8d4152385f8ffcae594ec5a82b7bbc6b7aecfddbf9d147bc
-  data.tar.gz: 0ba90ad3610d55c0dd7c092b6d7140de86a7a380411685d777d9a4aa6c172836930cef5aa0ffbeeda6dbbab34a0a0faff4a4928dc50e5e037e20038fff12863a
+  metadata.gz: baca6968fedbded14682da7a4fb68b3d2f5f3da4228671358461c77245920787d0672fd4886ad000693a06bb8e22438d4f311b66dabfdbbd917dfad5d003cea2
+  data.tar.gz: 677a8ef2549511e7e03f18c45d34897ac0ceaaa25ea9a11300ecac711f552c92c074e56ea6453d21a1b58d0ba20aabdd859941bbb1e93eec8cf3b7e9a6c69b34

data/Appraisals

@@ -1,4 +1,3 @@
 appraise "rails-7.1" do
   gem "rails", "~> 7.1", ">= 7.1.3.4"
-  gem "sqlite3", "~> 1.4"
 end

data/gemfiles/rails_7.1.gemfile

@@ -2,7 +2,7 @@
 
 source "https://rubygems.org"
 
-gem "rails", "~> 7.1", ">= 7.1.3.4"
 gem "sqlite3", "~> 1.4"
+gem "rails", "~> 7.1", ">= 7.1.3.4"
 
 gemspec path: "../"

data/gemfiles/rails_7.1.gemfile.lock

@@ -2,7 +2,8 @@ PATH
   remote: ..
   specs:
     chrono_forge (0.0.1)
-      rails
+      activejob
+      activerecord
       zeitwerk
 
 GEM

data/lib/chrono_forge/error_log.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: chrono_forge_error_logs
+#
+#  id            :integer          not null, primary key
+#  backtrace     :text
+#  context       :json
+#  error_class   :string
+#  error_message :text
+#  created_at    :datetime         not null
+#  updated_at    :datetime         not null
+#  workflow_id   :integer          not null
+#
+# Indexes
+#
+#  index_chrono_forge_error_logs_on_workflow_id  (workflow_id)
+#
+# Foreign Keys
+#
+#  workflow_id  (workflow_id => chrono_forge_workflows.id)
+#
+
+module ChronoForge
+  class ErrorLog < ActiveRecord::Base
+    self.table_name = "chrono_forge_error_logs"
+
+    belongs_to :workflow
+
+    # Cleanup method
+    def self.cleanup_old_logs(retention_period: 30.days)
+      where("created_at < ?", retention_period.ago).delete_all
+    end
+  end
+end

data/lib/chrono_forge/execution_log.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: chrono_forge_execution_logs
+#
+#  id               :integer          not null, primary key
+#  attempts         :integer          default(0), not null
+#  completed_at     :datetime
+#  error_class      :string
+#  error_message    :text
+#  last_executed_at :datetime
+#  metadata         :json
+#  started_at       :datetime
+#  state            :integer          default("pending"), not null
+#  step_name        :string           not null
+#  created_at       :datetime         not null
+#  updated_at       :datetime         not null
+#  workflow_id      :integer          not null
+#
+# Indexes
+#
+#  idx_on_workflow_id_step_name_11bea8586e               (workflow_id,step_name) UNIQUE
+#  index_chrono_forge_execution_logs_on_workflow_id  (workflow_id)
+#
+# Foreign Keys
+#
+#  workflow_id  (workflow_id => chrono_forge_workflows.id)
+#
+module ChronoForge
+  class ExecutionLog < ActiveRecord::Base
+    self.table_name = "chrono_forge_execution_logs"
+
+    belongs_to :workflow
+
+    enum :state, %i[
+      pending
+      completed
+      failed
+    ]
+
+    # Cleanup method
+    def self.cleanup_old_logs(retention_period: 30.days)
+      where("created_at < ?", retention_period.ago).delete_all
+    end
+  end
+end

data/lib/chrono_forge/executor/context.rb

@@ -0,0 +1,68 @@
+module ChronoForge
+  module Executor
+    class Context
+      class ValidationError < Error; end
+
+      ALLOWED_TYPES = [
+        String,
+        Integer,
+        Float,
+        TrueClass,
+        FalseClass,
+        NilClass,
+        Hash,
+        Array
+      ]
+
+      def initialize(workflow)
+        @workflow = workflow
+        @context = workflow.context || {}
+        @dirty = false
+      end
+
+      def []=(key, value)
+        # Type and size validation
+        validate_value!(value)
+
+        @context[key.to_s] =
+          if value.is_a?(Hash) || value.is_a?(Array)
+            deep_dup(value)
+          else
+            value
+          end
+
+        @dirty = true
+      end
+
+      def [](key)
+        @context[key.to_s]
+      end
+
+      def save!
+        return unless @dirty
+
+        @workflow.update_column(:context, @context)
+        @dirty = false
+      end
+
+      private
+
+      def validate_value!(value)
+        unless ALLOWED_TYPES.any? { |type| value.is_a?(type) }
+          raise ValidationError, "Unsupported context value type: #{value.inspect}"
+        end
+
+        # Optional: Add size constraints
+        if value.is_a?(String) && value.size > 64.kilobytes
+          raise ValidationError, "Context value too large"
+        end
+      end
+
+      def deep_dup(obj)
+        JSON.parse(JSON.generate(obj))
+      rescue
+        obj.dup
+      end
+    end
+  end
+end

data/lib/chrono_forge/executor/execution_tracker.rb

@@ -0,0 +1,16 @@
+module ChronoForge
+  module Executor
+    class ExecutionTracker
+      def self.track_error(workflow, error)
+        # Create a detailed error log
+        ErrorLog.create!(
+          workflow: workflow,
+          error_class: error.class.name,
+          error_message: error.message,
+          backtrace: error.backtrace.join("\n"),
+          context: workflow.context
+        )
+      end
+    end
+  end
+end

data/lib/chrono_forge/executor/lock_strategy.rb

@@ -0,0 +1,44 @@
+module ChronoForge
+  module Executor
+    class LongRunningConcurrentExecutionError < Error; end
+
+    class ConcurrentExecutionError < Error; end
+
+    class LockStrategy
+      def self.acquire_lock(job_id, workflow, max_duration:)
+        ActiveRecord::Base.transaction do
+          # Find the workflow with a lock, considering stale locks
+          workflow = workflow.lock!
+
+          # Check for active execution
+          if workflow.locked_at && workflow.locked_at > max_duration.ago
+            raise ConcurrentExecutionError, "Job currently in progress"
+          end
+
+          # Atomic update of lock status
+          workflow.update_columns(
+            locked_by: job_id,
+            locked_at: Time.current,
+            state: :running
+          )
+
+          workflow
+        end
+      end
+
+      def self.release_lock(job_id, workflow)
+        workflow = workflow.reload
+        if workflow.locked_by != job_id
+          raise LongRunningConcurrentExecutionError,
+            "#{self.class}(#{job_id}) executed longer than specified max_duration, " \
+            "allowing another instance(#{workflow.locked_by}) to acquire the lock."
+        end
+
+        columns = {locked_at: nil, locked_by: nil}
+        columns[:state] = :idle if workflow.running?
+
+        workflow.update_columns(columns)
+      end
+    end
+  end
+end

data/lib/chrono_forge/executor/methods/durably_execute.rb

@@ -0,0 +1,75 @@
+module ChronoForge
+  module Executor
+    module Methods
+      module DurablyExecute
+        def durably_execute(method, **options)
+          # Create execution log
+          step_name = "durably_execute$#{method}"
+          execution_log = ExecutionLog.create_or_find_by!(
+            workflow: @workflow,
+            step_name: step_name
+          ) do |log|
+            log.started_at = Time.current
+          end
+
+          # Return if already completed
+          return execution_log.metadata["result"] if execution_log.completed?
+
+          # Execute with error handling
+          begin
+            # Update execution log with attempt
+            execution_log.update!(
+              attempts: execution_log.attempts + 1,
+              last_executed_at: Time.current
+            )
+
+            # Execute the method
+            result = if method.is_a?(Symbol)
+              send(method)
+            else
+              method.call(@context)
+            end
+
+            # Complete the execution
+            execution_log.update!(
+              state: :completed,
+              completed_at: Time.current,
+              metadata: {result: result}
+            )
+            result
+          rescue HaltExecutionFlow
+            raise
+          rescue => e
+            # Log the error
+            Rails.logger.error { "Error while durably executing #{method}: #{e.message}" }
+            self.class::ExecutionTracker.track_error(workflow, e)
+
+            # Optional retry logic
+            if execution_log.attempts < (options[:max_attempts] || 3)
+              # Reschedule with exponential backoff
+              backoff = (2**[execution_log.attempts || 1, 5].min).seconds
+
+              self.class
+                .set(wait: backoff)
+                .perform_later(
+                  @workflow.key,
+                  retry_method: method
+                )
+
+              # Halt current execution
+              halt_execution!
+            else
+              # Max attempts reached
+              execution_log.update!(
+                state: :failed,
+                error_message: e.message,
+                error_class: e.class.name
+              )
+              raise ExecutionFailedError, "#{step_name} failed after maximum attempts"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chrono_forge/executor/methods/wait.rb

@@ -0,0 +1,47 @@
+module ChronoForge
+  module Executor
+    module Methods
+      module Wait
+        def wait(duration, name, **options)
+          # Create execution log
+          execution_log = ExecutionLog.create_or_find_by!(
+            workflow: @workflow,
+            step_name: "wait$#{name}"
+          ) do |log|
+            log.started_at = Time.current
+            log.metadata = {
+              wait_until: duration.from_now
+            }
+          end
+
+          # Return if already completed
+          return if execution_log.completed?
+
+          # Check if wait period has passed
+          if Time.current >= Time.parse(execution_log.metadata["wait_until"])
+            execution_log.update!(
+              attempts: execution_log.attempts + 1,
+              state: :completed,
+              completed_at: Time.current,
+              last_executed_at: Time.current
+            )
+            return
+          end
+
+          execution_log.update!(
+            attempts: execution_log.attempts + 1,
+            last_executed_at: Time.current
+          )
+
+          # Reschedule the job
+          self.class
+            .set(wait: duration)
+            .perform_later(@workflow.key)
+
+          # Halt current execution
+          halt_execution!
+        end
+      end
+    end
+  end
+end

data/lib/chrono_forge/executor/methods/wait_until.rb

@@ -0,0 +1,110 @@
+module ChronoForge
+  module Executor
+    class WaitConditionNotMet < ExecutionFailedError; end
+
+    module Methods
+      module WaitUntil
+        def wait_until(condition, **options)
+          # Default timeout and check interval
+          timeout = options[:timeout] || 10.seconds
+          check_interval = options[:check_interval] || 1.second
+
+          # Find or create execution log
+          step_name = "wait_until$#{condition}"
+          execution_log = ExecutionLog.create_or_find_by!(
+            workflow: @workflow,
+            step_name: step_name
+          ) do |log|
+            log.started_at = Time.current
+            log.metadata = {
+              timeout_at: timeout.from_now,
+              check_interval: check_interval,
+              condition: condition.to_s
+            }
+          end
+
+          # Return if already completed
+          if execution_log.completed?
+            return execution_log.metadata["result"]
+          end
+
+          # Evaluate condition
+          begin
+            execution_log.update!(
+              attempts: execution_log.attempts + 1,
+              last_executed_at: Time.current
+            )
+
+            condition_met = if condition.is_a?(Proc)
+              condition.call(@context)
+            elsif condition.is_a?(Symbol)
+              send(condition)
+            else
+              raise ArgumentError, "Unsupported condition type"
+            end
+          rescue HaltExecutionFlow
+            raise
+          rescue => e
+            # Log the error
+            Rails.logger.error { "Error evaluating condition #{condition}: #{e.message}" }
+            self.class::ExecutionTracker.track_error(workflow, e)
+
+            # Optional retry logic
+            if (options[:retry_on] || []).include?(e.class)
+              # Reschedule with exponential backoff
+              backoff = (2**[execution_log.attempts || 1, 5].min).seconds
+
+              self.class
+                .set(wait: backoff)
+                .perform_later(
+                  @workflow.key
+                )
+
+              # Halt current execution
+              halt_execution!
+            else
+              execution_log.update!(
+                state: :failed,
+                error_message: e.message,
+                error_class: e.class.name
+              )
+              raise ExecutionFailedError, "#{step_name} failed with an error: #{e.message}"
+            end
+          end
+
+          # Handle condition met
+          if condition_met
+            execution_log.update!(
+              state: :completed,
+              completed_at: Time.current,
+              metadata: execution_log.metadata.merge("result" => true)
+            )
+            return true
+          end
+
+          # Check for timeout
+          metadata = execution_log.metadata
+          if Time.current > metadata["timeout_at"]
+            execution_log.update!(
+              state: :failed,
+              metadata: metadata.merge("result" => nil)
+            )
+            Rails.logger.warn { "Timeout reached for condition #{condition}. Condition not met within the timeout period." }
+            raise WaitConditionNotMet, "Condition not met within timeout period"
+          end
+
+          # Reschedule with delay
+          self.class
+            .set(wait: check_interval)
+            .perform_later(
+              @workflow.key,
+              wait_condition: condition
+            )
+
+          # Halt current execution
+          halt_execution!
+        end
+      end
+    end
+  end
+end

data/lib/chrono_forge/executor/methods.rb

@@ -0,0 +1,9 @@
+module ChronoForge
+  module Executor
+    module Methods
+      include Methods::Wait
+      include Methods::WaitUntil
+      include Methods::DurablyExecute
+    end
+  end
+end

data/lib/chrono_forge/executor/retry_strategy.rb

@@ -0,0 +1,29 @@
+module ChronoForge
+  module Executor
+    class RetryStrategy
+      BACKOFF_STRATEGY = [
+        1.second,   # Initial retry
+        5.seconds,  # Second retry
+        30.seconds, # Third retry
+        2.minutes,  # Fourth retry
+        10.minutes  # Final retry
+      ]
+
+      def self.schedule_retry(workflow, attempt: 0)
+        wait_duration = BACKOFF_STRATEGY[attempt] || BACKOFF_STRATEGY.last
+
+        # Schedule with exponential backoff
+        workflow.job_klass.constantize
+          .set(wait: wait_duration)
+          .perform_later(
+            workflow.key,
+            attempt: attempt + 1
+          )
+      end
+
+      def self.max_attempts
+        BACKOFF_STRATEGY.length
+      end
+    end
+  end
+end

data/lib/chrono_forge/executor.rb

@@ -0,0 +1,140 @@
+module ChronoForge
+  module Executor
+    class Error < StandardError; end
+
+    class ExecutionFailedError < Error; end
+
+    class ExecutionFlowControl < Error; end
+
+    class HaltExecutionFlow < ExecutionFlowControl; end
+
+    include Methods
+
+    def perform(key, attempt: 0, **kwargs)
+      # Prevent excessive retries
+      if attempt >= self.class::RetryStrategy.max_attempts
+        Rails.logger.error { "Max attempts reached for job #{key}" }
+        return
+      end
+
+      # Find or create job with comprehensive tracking
+      setup_workflow(key, kwargs)
+
+      begin
+        # Skip if workflow cannot be executed
+        return unless workflow.executable?
+
+        # Acquire lock with advanced concurrency protection
+        self.class::LockStrategy.acquire_lock(job_id, workflow, max_duration: max_duration)
+
+        # Execute core job logic
+        super(**workflow.kwargs.symbolize_keys)
+
+        # Mark as complete
+        complete_workflow!
+      rescue ExecutionFailedError => e
+        Rails.logger.error { "Execution step failed for #{key}" }
+        self.class::ExecutionTracker.track_error(workflow, e)
+        workflow.stalled!
+        nil
+      rescue HaltExecutionFlow
+        # Halt execution
+        Rails.logger.debug { "Execution halted for #{key}" }
+        nil
+      rescue ConcurrentExecutionError
+        # Graceful handling of concurrent execution
+        Rails.logger.warn { "Concurrent execution detected for job #{key}" }
+        nil
+      rescue => e
+        Rails.logger.error { "An error occurred during execution of #{key}" }
+        self.class::ExecutionTracker.track_error(workflow, e)
+
+        # Retry if applicable
+        if should_retry?(e, attempt)
+          self.class::RetryStrategy.schedule_retry(workflow, attempt: attempt)
+        else
+          workflow.failed!
+        end
+      ensure
+        context.save!
+        # Always release the lock
+        self.class::LockStrategy.release_lock(job_id, workflow)
+      end
+    end
+
+    private
+
+    def complete_workflow!
+      # Create an execution log for workflow completion
+      execution_log = ExecutionLog.create_or_find_by!(
+        workflow: workflow,
+        step_name: "$workflow_completion$"
+      ) do |log|
+        log.started_at = Time.current
+        log.metadata = {
+          workflow_id: workflow.id
+        }
+      end
+
+      begin
+        execution_log.update!(
+          attempts: execution_log.attempts + 1,
+          last_executed_at: Time.current
+        )
+
+        workflow.completed_at = Time.current
+        workflow.completed!
+
+        # Mark execution log as completed
+        execution_log.update!(
+          state: :completed,
+          completed_at: Time.current
+        )
+
+        # Return the execution log for tracking
+        execution_log
+      rescue => e
+        # Log any completion errors
+        execution_log.update!(
+          state: :failed,
+          error_message: e.message,
+          error_class: e.class.name
+        )
+        raise
+      end
+    end
+
+    def setup_workflow(key, kwargs)
+      @workflow = find_workflow(key, kwargs)
+      @context = Context.new(@workflow)
+    end
+
+    def find_workflow(key, kwargs)
+      Workflow.create_or_find_by!(key: key) do |workflow|
+        workflow.job_klass = self.class.to_s
+        workflow.kwargs = kwargs
+        workflow.started_at = Time.current
+      end
+    end
+
+    def should_retry?(error, attempt_count)
+      attempt_count < 3
+    end
+
+    def halt_execution!
+      raise HaltExecutionFlow
+    end
+
+    def workflow
+      @workflow
+    end
+
+    def context
+      @context
+    end
+
+    def max_duration
+      10.minutes
+    end
+  end
+end

data/lib/chrono_forge/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ChronoForge
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/chrono_forge/workflow.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: chrono_forge_workflows
+#
+#  id           :integer          not null, primary key
+#  completed_at :datetime
+#  context      :json             not null
+#  job_klass    :string           not null
+#  key          :string           not null
+#  kwargs       :json             not null
+#  locked_at    :datetime
+#  started_at   :datetime
+#  state        :integer          default("idle"), not null
+#  created_at   :datetime         not null
+#  updated_at   :datetime         not null
+#
+# Indexes
+#
+#  index_chrono_forge_workflows_on_key  (key) UNIQUE
+#
+module ChronoForge
+  class Workflow < ActiveRecord::Base
+    self.table_name = "chrono_forge_workflows"
+
+    has_many :execution_logs
+    has_many :error_logs
+
+    enum :state, %i[
+      idle
+      running
+      completed
+      failed
+      stalled
+    ]
+
+    # Cleanup method
+    def self.cleanup_old_logs(retention_period: 30.days)
+      where("created_at < ?", retention_period.ago).delete_all
+    end
+
+    # Serialization for metadata
+    serialize :metadata, coder: JSON
+
+    def executable?
+      idle? || running?
+    end
+  end
+end

data/lib/chrono_forge.rb

@@ -1,13 +1,11 @@
 # frozen_string_literal: true
 
-require_relative "chrono_forge/version"
-
 require "zeitwerk"
-require "active_support/core_ext/object/blank"
+require "active_record"
+require "active_job"
 
 module Chronoforge
-  Loader = Zeitwerk::Loader.new.tap do |loader|
-    loader.tag = File.basename(__FILE__, ".rb")
+  Loader = Zeitwerk::Loader.for_gem.tap do |loader|
     loader.ignore("#{__dir__}/generators")
     loader.setup
   end

data/lib/generators/chrono_forge/install/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Installs ChronoForge
+
+Example:
+    bin/rails g chrono_form:install
+
+    This will create a new migration e.g:
+        20241221181505_install_chrono_forge.rb

data/lib/generators/chrono_forge/install/install_generator.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "rails/generators/active_record/migration"
+
+module ChronoForge
+  class InstallGenerator < Rails::Generators::Base
+    include ::ActiveRecord::Generators::Migration
+
+    source_root File.expand_path("templates", __dir__)
+
+    def start
+      install_migrations
+    rescue => err
+      say "#{err.class}: #{err}\n#{err.backtrace.join("\n")}", :red
+      exit 1
+    end
+
+    private
+
+    def install_migrations
+      migration_template "install_chrono_forge.rb", "install_chrono_forge.rb"
+    end
+  end
+end

data/lib/generators/chrono_forge/install/templates/install_chrono_forge.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+class InstallChronoForge < ActiveRecord::Migration[7.1]
+  def change
+    create_table :chrono_forge_workflows do |t|
+      t.string :key, null: false, index: {unique: true}
+      t.string :job_klass, null: false
+
+      if t.respond_to?(:jsonb)
+        t.jsonb :kwargs, null: false, default: {}
+        t.jsonb :options, null: false, default: {}
+        t.jsonb :context, null: false, default: {}
+      else
+        t.json :kwargs, null: false, default: {}
+        t.json :options, null: false, default: {}
+        t.json :context, null: false, default: {}
+      end
+
+      t.integer :state, null: false, default: 0
+      t.string :locked_by
+      t.datetime :locked_at
+
+      t.datetime :started_at
+      t.datetime :completed_at
+
+      t.timestamps
+    end
+
+    create_table :chrono_forge_execution_logs do |t|
+      t.references :workflow, null: false, foreign_key: {to_table: :chrono_forge_workflows}
+      t.string :step_name, null: false
+      t.integer :attempts, null: false, default: 0
+      t.datetime :started_at
+      t.datetime :last_executed_at
+      t.datetime :completed_at
+      if t.respond_to?(:jsonb)
+        t.jsonb :metadata
+      else
+        t.json :metadata
+      end
+      t.integer :state, null: false, default: 0
+      t.string :error_class
+      t.text :error_message
+
+      t.timestamps
+      t.index %i[workflow_id step_name], unique: true
+    end
+
+    create_table :chrono_forge_error_logs do |t|
+      t.references :workflow, null: false, foreign_key: {to_table: :chrono_forge_workflows}
+      t.string :error_class
+      t.text :error_message
+      t.text :backtrace
+      if t.respond_to?(:jsonb)
+        t.jsonb :context
+      else
+        t.json :context
+      end
+
+      t.timestamps
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chrono_forge
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Stefan Froelich
@@ -11,7 +11,21 @@ cert_chain: []
 date: 2024-12-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rails
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activejob
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -169,7 +183,22 @@ files:
 - gemfiles/rails_7.1.gemfile
 - gemfiles/rails_7.1.gemfile.lock
 - lib/chrono_forge.rb
+- lib/chrono_forge/error_log.rb
+- lib/chrono_forge/execution_log.rb
+- lib/chrono_forge/executor.rb
+- lib/chrono_forge/executor/context.rb
+- lib/chrono_forge/executor/execution_tracker.rb
+- lib/chrono_forge/executor/lock_strategy.rb
+- lib/chrono_forge/executor/methods.rb
+- lib/chrono_forge/executor/methods/durably_execute.rb
+- lib/chrono_forge/executor/methods/wait.rb
+- lib/chrono_forge/executor/methods/wait_until.rb
+- lib/chrono_forge/executor/retry_strategy.rb
 - lib/chrono_forge/version.rb
+- lib/chrono_forge/workflow.rb
+- lib/generators/chrono_forge/install/USAGE
+- lib/generators/chrono_forge/install/install_generator.rb
+- lib/generators/chrono_forge/install/templates/install_chrono_forge.rb
 - sig/chrono_forge.rbs
 homepage: https://github.com/radioactive-labs/chrono_forge
 licenses: