chrono_forge 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9da8de8f1664f4234f1a87cd69b1f32a2ccf96ce8501be4ef0e5f9585ceb7417
-  data.tar.gz: afe72783ec386e3aa9b5f3b79e468c83eb5bc2dd144634f797a882760a4f6eac
+  metadata.gz: 887025fd6483bb1d532ec4c78344a9cb716b40ed8aa23dc6e18ab4356e852d75
+  data.tar.gz: b6fbedf50eb2372424ca8bd7d4acf5471edb1ea676a1118180422df1e1306a27
 SHA512:
-  metadata.gz: b24ef7eb8e7b2c2a07a368efde14bdfb54c4e846b1da9681013d23f3159693497f42d373aea3e85b6db340e737a03d907e8d745e4a3424843ecad7c8daa6e4b6
-  data.tar.gz: 742063a706c815f8f9a568fe2ee40f774d1510c3d46f2cdc90dd5f83304b8feeeb937c363d9f07ae19f2d8fbb75dcc33db57e9eecedc714f0a9f6dba19113da0
+  metadata.gz: eb618c3c16fbee88a5398a09ccc9a0859c9d7d6252285ed56cb37562977bff1042d68517313c305193c18ff2170055843c6a126c6f481051234cc12aba30b359
+  data.tar.gz: 5eda3316fcc204a40f6d5fa1654623e16c0c1cc9ddbbe3f1fb9dca5dcf06556df5195cefa97f5f13271214c4d9dde42c02c41513348eb06176a3fae7d5bbc61b

data/README.md

@@ -1,8 +1,10 @@
 # ChronoForge
 
-![Version](https://img.shields.io/badge/version-0.3.0-blue.svg)
+![Version](https://img.shields.io/badge/version-0.5.1-blue.svg)
+[![Ruby](https://github.com/radioactive-labs/chrono_forge/actions/workflows/main.yml/badge.svg)](https://github.com/radioactive-labs/chrono_forge/actions/workflows/main.yml)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
+
 > A robust framework for building durable, distributed workflows in Ruby on Rails applications
 
 ChronoForge provides a powerful solution for handling long-running processes, managing state, and recovering from failures in your Rails applications. Built on top of ActiveJob, it ensures your critical business processes remain resilient and traceable.

data/lib/chrono_forge/executor/lock_strategy.rb

@@ -5,42 +5,56 @@ module ChronoForge
     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"
+      class << self
+        def acquire_lock(job_id, workflow, max_duration:)
+          ActiveRecord::Base.transaction do
+            # Find the workflow with a lock, considering stale locks
+            workflow = workflow.lock!
+
+            ensure_executable!(workflow)
+
+            # Check for active execution
+            if workflow.locked_at && workflow.locked_at > max_duration.ago
+              raise ConcurrentExecutionError,
+                "ChronoForge:#{self.class}(#{key}) job(#{job_id}) failed to acquire lock. " \
+                "Currently being executed by job(#{workflow.locked_by})"
+            end
+
+            # Atomic update of lock status
+            workflow.update_columns(
+              locked_by: job_id,
+              locked_at: Time.current,
+              state: :running
+            )
+
+            Rails.logger.debug { "ChronoForge:#{self.class}(#{workflow.key}) job(#{job_id}) acquired lock." }
+
+            workflow
           end
+        end
 
-          # Atomic update of lock status
-          workflow.update_columns(
-            locked_by: job_id,
-            locked_at: Time.current,
-            state: :running
-          )
-
-          Rails.logger.debug { "ChronoForge:#{self.class} job(#{job_id}) acquired lock for workflow(#{workflow.key})" }
+        def release_lock(job_id, workflow, force: false)
+          workflow = workflow.reload
+          if !force && workflow.locked_by != job_id
+            raise LongRunningConcurrentExecutionError,
+              "ChronoForge:#{self.class}(#{workflow.key}) job(#{job_id}) executed longer than specified max_duration, " \
+              "allowed job(#{workflow.locked_by}) to acquire the lock."
+          end
 
-          workflow
-        end
-      end
+          columns = {locked_at: nil, locked_by: nil}
+          columns[:state] = :idle if force || workflow.running?
 
-      def self.release_lock(job_id, workflow, force: false)
-        workflow = workflow.reload
-        if !force && workflow.locked_by != job_id
-          raise LongRunningConcurrentExecutionError,
-            "ChronoForge:#{self.class} job(#{job_id}) executed longer than specified max_duration, " \
-            "allowed another instance job(#{workflow.locked_by}) to acquire the lock."
+          workflow.update_columns(columns)
         end
 
-        columns = {locked_at: nil, locked_by: nil}
-        columns[:state] = :idle if force || workflow.running?
-
+        private
 
-        workflow.update_columns(columns)
+        def ensure_executable!(workflow)
+          # Raise error if workflow cannot be executed
+          unless workflow.executable?
+            raise NotExecutableError, "ChronoForge:#{workflow.class}(#{workflow.key}) is not in an executable state"
+          end
+        end
       end
     end
   end

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

@@ -3,7 +3,7 @@ module ChronoForge
     module Methods
       module WorkflowStates
         private
-        
+
         def complete_workflow!
           # Create an execution log for workflow completion
           execution_log = ExecutionLog.create_or_find_by!(

data/lib/chrono_forge/executor.rb

@@ -22,22 +22,22 @@ module ChronoForge
           if !key.is_a?(String)
             raise ArgumentError, "Workflow key must be a string as the first argument"
           end
-          super(key, **kwargs)
+          super
         end
-        
+
         # Enforce expected signature for perform_later with key as first arg and keywords after
         def perform_later(key, **kwargs)
           if !key.is_a?(String)
             raise ArgumentError, "Workflow key must be a string as the first argument"
           end
-          super(key, **kwargs)
+          super
         end
-        
+
         # Add retry_now class method that calls perform_now with retry_workflow: true
         def retry_now(key, **kwargs)
           perform_now(key, retry_workflow: true, **kwargs)
         end
-        
+
         # Add retry_later class method that calls perform_later with retry_workflow: true
         def retry_later(key, **kwargs)
           perform_later(key, retry_workflow: true, **kwargs)
@@ -52,8 +52,8 @@ module ChronoForge
         return
       end
 
-      # Find or create job with comprehensive tracking
-      setup_workflow(key, options, kwargs)
+      # Find or create workflow instance
+      setup_workflow!(key, options, kwargs)
 
       # Handle retry parameter - unlock and continue execution
       retry_workflow! if retry_workflow
@@ -62,37 +62,35 @@ module ChronoForge
       lock_acquired = false
 
       begin
-        # Raise error if workflow cannot be executed
-        unless workflow.executable?
-          raise NotExecutableError, "#{self.class}(#{key}) is not in an executable state"
-        end
-
         # Acquire lock with advanced concurrency protection
         @workflow = self.class::LockStrategy.acquire_lock(job_id, workflow, max_duration: max_duration)
         lock_acquired = true
 
+        # Setup context
+        setup_context!
+
         # Execute core job logic
         super(**workflow.kwargs.symbolize_keys)
 
         # Mark as complete
         complete_workflow!
       rescue ExecutionFailedError => e
-        Rails.logger.error { "ChronoForge:#{self.class} execution step failed for workflow(#{key})" }
+        Rails.logger.error { "ChronoForge:#{self.class}(#{key}) step execution failed" }
         self.class::ExecutionTracker.track_error(workflow, e)
         workflow.stalled!
         nil
       rescue HaltExecutionFlow
         # Halt execution
-        Rails.logger.debug { "ChronoForge:#{self.class} execution halted for workflow(#{key})" }
+        Rails.logger.debug { "ChronoForge:#{self.class}(#{key}) execution halted" }
         nil
       rescue ConcurrentExecutionError
         # Graceful handling of concurrent execution
-        Rails.logger.warn { "ChronoForge:#{self.class} concurrent execution detected for job #{key}" }
+        Rails.logger.warn { "ChronoForge:#{self.class}(#{key}) concurrent execution detected" }
         nil
       rescue NotExecutableError
         raise
       rescue => e
-        Rails.logger.error { "ChronoForge:#{self.class} an error occurred during execution of workflow(#{key})" }
+        Rails.logger.error { "ChronoForge:#{self.class}(#{key}) workflow execution failed" }
         error_log = self.class::ExecutionTracker.track_error(workflow, e)
 
         # Retry if applicable
@@ -102,8 +100,7 @@ module ChronoForge
           fail_workflow! error_log
         end
       ensure
-        # Only release lock if we acquired it
-        if lock_acquired
+        if lock_acquired # Only release lock if we acquired it
           context.save!
           self.class::LockStrategy.release_lock(job_id, workflow)
         end
@@ -112,19 +109,18 @@ module ChronoForge
 
     private
 
-    def setup_workflow(key, options, kwargs)
-      @workflow = find_workflow(key, options, kwargs)
-      @context = Context.new(@workflow)
-    end
-
-    def find_workflow(key, options, kwargs)
-      Workflow.create_or_find_by!(job_class: self.class.to_s, key: key) do |workflow|
+    def setup_workflow!(key, options, kwargs)
+      @workflow = Workflow.create_or_find_by!(job_class: self.class.to_s, key: key) do |workflow|
         workflow.options = options
         workflow.kwargs = kwargs
         workflow.started_at = Time.current
       end
     end
 
+    def setup_context!
+      @context = Context.new(workflow)
+    end
+
     def should_retry?(error, attempt_count)
       attempt_count < 3
     end

data/lib/chrono_forge/version.rb

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

data/lib/chrono_forge.rb

@@ -11,6 +11,6 @@ module ChronoForge
   end
 
   class Error < StandardError; end
-  
-  def self.ApplicationRecord() = defined?(::ApplicationRecord) ? ::ApplicationRecord : ActiveRecord::Base
+
+  def self.ApplicationRecord = defined?(::ApplicationRecord) ? ::ApplicationRecord : ActiveRecord::Base
 end

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

@@ -28,22 +28,22 @@ class InstallChronoForge < ActiveRecord::Migration[7.1]
     end
 
     create_table :chrono_forge_execution_logs, id: primary_key_type do |t|
-      t.references :workflow, null: false, 
-                  foreign_key: {to_table: :chrono_forge_workflows},
-                  type: reference_type
+      t.references :workflow, null: false,
+        foreign_key: {to_table: :chrono_forge_workflows},
+        type: reference_type
 
       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
@@ -53,14 +53,14 @@ class InstallChronoForge < ActiveRecord::Migration[7.1]
     end
 
     create_table :chrono_forge_error_logs, id: primary_key_type do |t|
-      t.references :workflow, null: false, 
-                  foreign_key: {to_table: :chrono_forge_workflows},
-                  type: reference_type
-                  
+      t.references :workflow, null: false,
+        foreign_key: {to_table: :chrono_forge_workflows},
+        type: reference_type
+
       t.string :error_class
       t.text :error_message
       t.text :backtrace
-      
+
       if t.respond_to?(:jsonb)
         t.jsonb :context
       else
@@ -76,29 +76,29 @@ class InstallChronoForge < ActiveRecord::Migration[7.1]
   def primary_key_type
     # Check if the application is configured to use UUIDs
     if ActiveRecord.respond_to?(:default_id) && ActiveRecord.default_id.respond_to?(:to_s) &&
-      ActiveRecord.default_id.to_s.include?('uuid')
+        ActiveRecord.default_id.to_s.include?("uuid")
       return :uuid
     end
-    
+
     # Rails 6+ configuration style
-    if ActiveRecord.respond_to?(:primary_key_type) && 
-      ActiveRecord.primary_key_type.to_s == 'uuid'
+    if ActiveRecord.respond_to?(:primary_key_type) &&
+        ActiveRecord.primary_key_type.to_s == "uuid"
       return :uuid
     end
-    
+
     # Check application config
     app_config = Rails.application.config.generators
     if app_config.options.key?(:active_record) &&
-      app_config.options[:active_record].key?(:primary_key_type) &&
-      app_config.options[:active_record][:primary_key_type].to_s == 'uuid'
+        app_config.options[:active_record].key?(:primary_key_type) &&
+        app_config.options[:active_record][:primary_key_type].to_s == "uuid"
       return :uuid
     end
-    
+
     # Default to traditional integer keys
-    return :bigint
+    :bigint
   end
 
   def reference_type
-    primary_key_type == :uuid ? :uuid : nil
+    (primary_key_type == :uuid) ? :uuid : nil
   end
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chrono_forge
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Stefan Froelich
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-05-01 00:00:00.000000000 Z
+date: 2025-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord