decision_agent 0.1.2 → 0.1.3

data/lib/decision_agent/versioning/file_storage_adapter.rb

@@ -4,21 +4,41 @@ require "fileutils"
 
 module DecisionAgent
   module Versioning
+    # Status validation shared by adapters
+    module StatusValidator
+      VALID_STATUSES = %w[draft active archived].freeze
+
+      def validate_status!(status)
+        return if VALID_STATUSES.include?(status)
+
+        raise DecisionAgent::ValidationError,
+              "Invalid status '#{status}'. Must be one of: #{VALID_STATUSES.join(', ')}"
+      end
+    end
+
     # File-based version storage adapter for non-Rails applications
     # Stores versions as JSON files in a directory structure
     class FileStorageAdapter < Adapter
+      include StatusValidator
+
       attr_reader :storage_path
 
       # Initialize with a storage directory
       # @param storage_path [String] Path to store version files (default: ./versions)
       def initialize(storage_path: "./versions")
         @storage_path = storage_path
-        @mutex = Mutex.new
+        # Per-rule mutex for better concurrency - allows different rules to be processed in parallel
+        @rule_mutexes = Hash.new { |h, k| h[k] = Mutex.new }
+        @rule_mutexes_lock = Mutex.new # Protects the hash itself
+        # Index cache: version_id => rule_id mapping for O(1) lookups
+        @version_index = {}
+        @version_index_lock = Mutex.new
         FileUtils.mkdir_p(@storage_path)
+        load_version_index
       end
 
       def create_version(rule_id:, content:, metadata: {})
-        @mutex.synchronize do
+        with_rule_lock(rule_id) do
           create_version_unsafe(rule_id: rule_id, content: content, metadata: metadata)
         end
       end
@@ -27,14 +47,16 @@ module DecisionAgent
 
       def create_version_unsafe(rule_id:, content:, metadata: {})
         # Get the next version number
-        versions = list_versions(rule_id: rule_id)
+        versions = list_versions_unsafe(rule_id: rule_id)
         next_version_number = versions.empty? ? 1 : versions.first[:version_number] + 1
 
+        # Validate status if provided
+        status = metadata[:status] || "active"
+        validate_status!(status)
+
         # Deactivate previous active versions
         versions.each do |v|
-          if v[:status] == "active"
-            update_version_status(v[:id], "archived")
-          end
+          update_version_status_unsafe(v[:id], "archived", rule_id) if v[:status] == "active"
         end
 
         # Create version data
@@ -47,7 +69,7 @@ module DecisionAgent
           created_by: metadata[:created_by] || "system",
           created_at: Time.now.utc.iso8601,
           changelog: metadata[:changelog] || "Version #{next_version_number}",
-          status: metadata[:status] || "active"
+          status: status
         }
 
         # Write to file
@@ -59,43 +81,53 @@ module DecisionAgent
       public
 
       def list_versions(rule_id:, limit: nil)
-        versions = []
-        rule_dir = File.join(@storage_path, sanitize_filename(rule_id))
-
-        return versions unless Dir.exist?(rule_dir)
-
-        Dir.glob(File.join(rule_dir, "*.json")).each do |file|
-          versions << JSON.parse(File.read(file), symbolize_names: true)
+        with_rule_lock(rule_id) do
+          list_versions_unsafe(rule_id: rule_id, limit: limit)
         end
-
-        versions.sort_by! { |v| -v[:version_number] }
-        limit ? versions.take(limit) : versions
       end
 
       def get_version(version_id:)
-        all_versions.find { |v| v[:id] == version_id }
+        # Use index to find rule_id quickly - O(1) instead of O(n)
+        rule_id = get_rule_id_from_index(version_id)
+        return nil unless rule_id
+
+        # Now lock on the specific rule
+        with_rule_lock(rule_id) do
+          # Read only this rule's versions
+          versions = list_versions_unsafe(rule_id: rule_id)
+          versions.find { |v| v[:id] == version_id }
+        end
       end
 
       def get_version_by_number(rule_id:, version_number:)
-        versions = list_versions(rule_id: rule_id)
-        versions.find { |v| v[:version_number] == version_number }
+        with_rule_lock(rule_id) do
+          versions = list_versions_unsafe(rule_id: rule_id)
+          versions.find { |v| v[:version_number] == version_number }
+        end
       end
 
       def get_active_version(rule_id:)
-        versions = list_versions(rule_id: rule_id)
-        versions.find { |v| v[:status] == "active" }
+        with_rule_lock(rule_id) do
+          versions = list_versions_unsafe(rule_id: rule_id)
+          versions.find { |v| v[:status] == "active" }
+        end
       end
 
       def activate_version(version_id:)
-        @mutex.synchronize do
-          version = get_version(version_id: version_id)
+        # Use index to find rule_id quickly - O(1) instead of O(n)
+        rule_id = get_rule_id_from_index(version_id)
+        raise DecisionAgent::NotFoundError, "Version not found: #{version_id}" unless rule_id
+
+        # Now lock on the specific rule
+        with_rule_lock(rule_id) do
+          # Read only this rule's versions
+          versions = list_versions_unsafe(rule_id: rule_id)
+          version = versions.find { |v| v[:id] == version_id }
           raise DecisionAgent::NotFoundError, "Version not found: #{version_id}" unless version
 
           # Deactivate all other versions for this rule
-          list_versions(rule_id: version[:rule_id]).each do |v|
-            if v[:id] != version_id && v[:status] == "active"
-              update_version_status(v[:id], "archived")
-            end
+          versions.each do |v|
+            update_version_status_unsafe(v[:id], "archived", rule_id) if v[:id] != version_id && v[:status] == "active"
           end
 
           # Activate this version
@@ -107,8 +139,15 @@ module DecisionAgent
       end
 
       def delete_version(version_id:)
-        @mutex.synchronize do
-          version = get_version(version_id: version_id)
+        # Use index to find rule_id quickly - O(1) instead of O(n)
+        rule_id = get_rule_id_from_index(version_id)
+        raise DecisionAgent::NotFoundError, "Version not found: #{version_id}" unless rule_id
+
+        # Now lock on the specific rule
+        with_rule_lock(rule_id) do
+          # Read only this rule's versions
+          versions = list_versions_unsafe(rule_id: rule_id)
+          version = versions.find { |v| v[:id] == version_id }
           raise DecisionAgent::NotFoundError, "Version not found: #{version_id}" unless version
 
           # Prevent deletion of active versions
@@ -117,12 +156,14 @@ module DecisionAgent
           end
 
           # Delete the file
-          rule_dir = File.join(@storage_path, sanitize_filename(version[:rule_id]))
+          rule_dir = File.join(@storage_path, sanitize_filename(rule_id))
           filename = "#{version[:version_number]}.json"
           filepath = File.join(rule_dir, filename)
 
           if File.exist?(filepath)
             File.delete(filepath)
+            # Remove from index
+            remove_from_index(version_id)
             true
           else
             false
@@ -132,7 +173,21 @@ module DecisionAgent
 
       private
 
-      def all_versions
+      def list_versions_unsafe(rule_id:, limit: nil)
+        versions = []
+        rule_dir = File.join(@storage_path, sanitize_filename(rule_id))
+
+        return versions unless Dir.exist?(rule_dir)
+
+        Dir.glob(File.join(rule_dir, "*.json")).each do |file|
+          versions << JSON.parse(File.read(file), symbolize_names: true)
+        end
+
+        versions.sort_by! { |v| -v[:version_number] }
+        limit ? versions.take(limit) : versions
+      end
+
+      def all_versions_unsafe
         versions = []
         return versions unless Dir.exist?(@storage_path)
 
@@ -143,8 +198,17 @@ module DecisionAgent
         versions
       end
 
-      def update_version_status(version_id, status)
-        version = get_version(version_id: version_id)
+      def update_version_status_unsafe(version_id, status, rule_id = nil)
+        # Validate status first
+        validate_status!(status)
+
+        # Use provided rule_id or look it up from index
+        rule_id ||= get_rule_id_from_index(version_id)
+        return unless rule_id
+
+        # Read only this rule's versions
+        versions = list_versions_unsafe(rule_id: rule_id)
+        version = versions.find { |v| v[:id] == version_id }
         return unless version
 
         version[:status] = status
@@ -164,9 +228,11 @@ module DecisionAgent
         begin
           File.write(temp_file, JSON.pretty_generate(version))
           File.rename(temp_file, filepath)
+          # Update index after successful write
+          add_to_index(version[:id], version[:rule_id])
         ensure
           # Clean up temp file if rename failed
-          File.delete(temp_file) if File.exist?(temp_file)
+          FileUtils.rm_f(temp_file)
         end
       end
 
@@ -177,6 +243,48 @@ module DecisionAgent
       def sanitize_filename(name)
         name.to_s.gsub(/[^a-zA-Z0-9_-]/, "_")
       end
+
+      # Get or create a mutex for a specific rule_id
+      # This allows different rules to be processed in parallel
+      def with_rule_lock(rule_id, &block)
+        mutex = @rule_mutexes_lock.synchronize { @rule_mutexes[rule_id] }
+        mutex.synchronize(&block)
+      end
+
+      # Index management methods for O(1) version_id -> rule_id lookups
+      # This prevents the need to scan all 50,000 files when looking up a single version
+
+      def load_version_index
+        @version_index_lock.synchronize do
+          return unless Dir.exist?(@storage_path)
+
+          Dir.glob(File.join(@storage_path, "*", "*.json")).each do |file|
+            version = JSON.parse(File.read(file), symbolize_names: true)
+            @version_index[version[:id]] = version[:rule_id]
+          rescue JSON::ParserError
+            # Skip corrupted files
+            next
+          end
+        end
+      end
+
+      def get_rule_id_from_index(version_id)
+        @version_index_lock.synchronize do
+          @version_index[version_id]
+        end
+      end
+
+      def add_to_index(version_id, rule_id)
+        @version_index_lock.synchronize do
+          @version_index[version_id] = rule_id
+        end
+      end
+
+      def remove_from_index(version_id)
+        @version_index_lock.synchronize do
+          @version_index.delete(version_id)
+        end
+      end
     end
   end
 end

data/lib/decision_agent/versioning/version_manager.rb

@@ -54,22 +54,14 @@ module DecisionAgent
         @adapter.get_active_version(rule_id: rule_id)
       end
 
-      # Rollback to a previous version (activate it)
+      # Rollback to a previous version (activate it without creating a duplicate)
       # @param version_id [String, Integer] The version to rollback to
       # @param performed_by [String] User performing the rollback
       # @return [Hash] The activated version
       def rollback(version_id:, performed_by: "system")
-        version = @adapter.activate_version(version_id: version_id)
-
-        # Create an audit trail of the rollback
-        save_version(
-          rule_id: version[:rule_id],
-          rule_content: version[:content],
-          created_by: performed_by,
-          changelog: "Rolled back to version #{version[:version_number]}"
-        )
-
-        version
+        # Simply activate the previous version without creating a duplicate
+        # The version history already contains the full record
+        @adapter.activate_version(version_id: version_id)
       end
 
       # Compare two versions

data/lib/decision_agent/web/public/index.html

@@ -237,7 +237,7 @@
     </div>
 
     <footer class="footer">
-        <p>DecisionAgent Rule Builder | <a href="https://github.com/yourusername/decision_agent" target="_blank">Documentation</a></p>
+        <p>DecisionAgent Rule Builder | <a href="https://github.com/samaswin87/decision_agent" target="_blank">Documentation</a></p>
     </footer>
 
     <script src="app.js"></script>

data/lib/decision_agent/web/server.rb

@@ -43,14 +43,12 @@ module DecisionAgent
             valid: true,
             message: "Rules are valid!"
           }.to_json
-
         rescue JSON::ParserError => e
           status 400
           {
             valid: false,
             errors: ["Invalid JSON: #{e.message}"]
           }.to_json
-
         rescue DecisionAgent::InvalidRuleDslError => e
           # Validation failed
           status 422
@@ -58,8 +56,7 @@ module DecisionAgent
             valid: false,
             errors: parse_validation_errors(e.message)
           }.to_json
-
-        rescue => e
+        rescue StandardError => e
           # Unexpected error
           status 500
           {
@@ -102,8 +99,7 @@ module DecisionAgent
               message: "No rules matched the given context"
             }.to_json
           end
-
-        rescue => e
+        rescue StandardError => e
           status 500
           {
             success: false,
@@ -136,7 +132,7 @@ module DecisionAgent
                 },
                 {
                   id: "high_amount_review",
-                  if: { field: "amount", op: "gte", value: 10000 },
+                  if: { field: "amount", op: "gte", value: 10_000 },
                   then: { decision: "manual_review", weight: 0.9, reason: "High amount requires review" }
                 }
               ]
@@ -247,8 +243,7 @@ module DecisionAgent
 
           status 201
           version.to_json
-
-        rescue => e
+        rescue StandardError => e
           status 500
           { error: e.message }.to_json
         end
@@ -265,8 +260,7 @@ module DecisionAgent
           versions = version_manager.get_versions(rule_id: rule_id, limit: limit)
 
           versions.to_json
-
-        rescue => e
+        rescue StandardError => e
           status 500
           { error: e.message }.to_json
         end
@@ -281,8 +275,7 @@ module DecisionAgent
           history = version_manager.get_history(rule_id: rule_id)
 
           history.to_json
-
-        rescue => e
+        rescue StandardError => e
           status 500
           { error: e.message }.to_json
         end
@@ -302,8 +295,7 @@ module DecisionAgent
             status 404
             { error: "Version not found" }.to_json
           end
-
-        rescue => e
+        rescue StandardError => e
           status 500
           { error: e.message }.to_json
         end
@@ -325,8 +317,7 @@ module DecisionAgent
           )
 
           version.to_json
-
-        rescue => e
+        rescue StandardError => e
           status 500
           { error: e.message }.to_json
         end
@@ -351,8 +342,7 @@ module DecisionAgent
             status 404
             { error: "One or both versions not found" }.to_json
           end
-
-        rescue => e
+        rescue StandardError => e
           status 500
           { error: e.message }.to_json
         end
@@ -369,16 +359,13 @@ module DecisionAgent
 
           status 200
           { success: true, message: "Version deleted successfully" }.to_json
-
         rescue DecisionAgent::NotFoundError => e
           status 404
           { error: e.message }.to_json
-
         rescue DecisionAgent::ValidationError => e
           status 422
           { error: e.message }.to_json
-
-        rescue => e
+        rescue StandardError => e
           status 500
           { error: e.message }.to_json
         end
@@ -409,12 +396,20 @@ module DecisionAgent
         errors.empty? ? [error_message] : errors
       end
 
-      # Class method to start the server
+      # Class method to start the server (for CLI usage)
       def self.start!(port: 4567, host: "0.0.0.0")
         set :port, port
         set :bind, host
         run!
       end
+
+      # Rack interface for mounting in Rails/Rack apps
+      # Example:
+      #   # config/routes.rb
+      #   mount DecisionAgent::Web::Server, at: "/decision_agent"
+      def self.call(env)
+        new.call(env)
+      end
     end
   end
 end

data/lib/decision_agent.rb

@@ -2,6 +2,7 @@ require_relative "decision_agent/version"
 require_relative "decision_agent/errors"
 require_relative "decision_agent/context"
 require_relative "decision_agent/evaluation"
+require_relative "decision_agent/evaluation_validator"
 require_relative "decision_agent/decision"
 require_relative "decision_agent/agent"
 
@@ -29,5 +30,11 @@ require_relative "decision_agent/versioning/adapter"
 require_relative "decision_agent/versioning/file_storage_adapter"
 require_relative "decision_agent/versioning/version_manager"
 
+require_relative "decision_agent/monitoring/metrics_collector"
+require_relative "decision_agent/monitoring/prometheus_exporter"
+require_relative "decision_agent/monitoring/alert_manager"
+require_relative "decision_agent/monitoring/monitored_agent"
+# dashboard_server has additional dependencies (faye/websocket) - require it explicitly when needed
+
 module DecisionAgent
 end

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

@@ -1,12 +1,12 @@
-require 'rails/generators'
-require 'rails/generators/migration'
+require "rails/generators"
+require "rails/generators/migration"
 
 module DecisionAgent
   module Generators
     class InstallGenerator < Rails::Generators::Base
       include Rails::Generators::Migration
 
-      source_root File.expand_path('templates', __dir__)
+      source_root File.expand_path("templates", __dir__)
 
       desc "Installs DecisionAgent models and migrations for Rails"
 
@@ -17,8 +17,8 @@ module DecisionAgent
 
       def copy_migration
         migration_template "migration.rb",
-                          "db/migrate/create_decision_agent_tables.rb",
-                          migration_version: migration_version
+                           "db/migrate/create_decision_agent_tables.rb",
+                           migration_version: migration_version
       end
 
       def copy_models

data/lib/generators/decision_agent/install/templates/migration.rb

@@ -5,7 +5,7 @@ class CreateDecisionAgentTables < ActiveRecord::Migration[7.0]
       t.string :rule_id, null: false, index: { unique: true }
       t.string :ruleset, null: false
       t.text :description
-      t.string :status, default: 'active'
+      t.string :status, default: "active"
       t.timestamps
     end
 
@@ -13,14 +13,25 @@ class CreateDecisionAgentTables < ActiveRecord::Migration[7.0]
     create_table :rule_versions do |t|
       t.string :rule_id, null: false, index: true
       t.integer :version_number, null: false
-      t.text :content, null: false  # JSON rule definition
-      t.string :created_by, null: false, default: 'system'
+      t.text :content, null: false # JSON rule definition
+      t.string :created_by, null: false, default: "system"
       t.text :changelog
-      t.string :status, null: false, default: 'draft'  # draft, active, archived
+      t.string :status, null: false, default: "draft" # draft, active, archived
       t.timestamps
     end
 
-    add_index :rule_versions, [:rule_id, :version_number], unique: true
-    add_index :rule_versions, [:rule_id, :status]
+    # ✅ CRITICAL: Unique constraint prevents duplicate version numbers per rule
+    # This protects against race conditions in concurrent version creation
+    add_index :rule_versions, %i[rule_id version_number], unique: true
+
+    # Index for efficient queries by rule_id and status
+    add_index :rule_versions, %i[rule_id status]
+
+    # Optional: Partial unique index for PostgreSQL to enforce one active version per rule
+    # Uncomment if using PostgreSQL:
+    # add_index :rule_versions, [:rule_id, :status],
+    #           unique: true,
+    #           where: "status = 'active'",
+    #           name: 'index_rule_versions_one_active_per_rule'
   end
 end

data/lib/generators/decision_agent/install/templates/rule.rb

@@ -5,12 +5,12 @@ class Rule < ApplicationRecord
   validates :ruleset, presence: true
   validates :status, inclusion: { in: %w[active inactive archived] }
 
-  scope :active, -> { where(status: 'active') }
+  scope :active, -> { where(status: "active") }
   scope :by_ruleset, ->(ruleset) { where(ruleset: ruleset) }
 
   # Get the active version for this rule
   def active_version
-    rule_versions.find_by(status: 'active')
+    rule_versions.find_by(status: "active")
   end
 
   # Get all versions ordered by version number
@@ -19,7 +19,7 @@ class Rule < ApplicationRecord
   end
 
   # Create a new version
-  def create_version(content:, created_by: 'system', changelog: nil)
+  def create_version(content:, created_by: "system", changelog: nil)
     DecisionAgent::Versioning::VersionManager.new.save_version(
       rule_id: rule_id,
       rule_content: content,

data/lib/generators/decision_agent/install/templates/rule_version.rb

@@ -7,7 +7,7 @@ class RuleVersion < ApplicationRecord
   validates :status, inclusion: { in: %w[draft active archived] }
   validates :created_by, presence: true
 
-  scope :active, -> { where(status: 'active') }
+  scope :active, -> { where(status: "active") }
   scope :for_rule, ->(rule_id) { where(rule_id: rule_id).order(version_number: :desc) }
   scope :latest, -> { order(version_number: :desc).limit(1) }
 
@@ -29,12 +29,15 @@ class RuleVersion < ApplicationRecord
   def activate!
     transaction do
       # Deactivate all other versions for this rule
-      self.class.where(rule_id: rule_id, status: 'active')
-                .where.not(id: id)
-                .update_all(status: 'archived')
+      # Use update! instead of update_all to trigger validations
+      self.class.where(rule_id: rule_id, status: "active")
+          .where.not(id: id)
+          .find_each do |v|
+        v.update!(status: "archived")
+      end
 
       # Activate this version
-      update!(status: 'active')
+      update!(status: "active")
     end
   end
 
@@ -51,9 +54,12 @@ class RuleVersion < ApplicationRecord
   def set_next_version_number
     return if version_number.present?
 
+    # Use pessimistic locking to prevent race conditions when calculating version numbers
+    # Lock the last version record to ensure only one thread can read and increment at a time
     last_version = self.class.where(rule_id: rule_id)
-                             .order(version_number: :desc)
-                             .first
+                       .order(version_number: :desc)
+                       .lock
+                       .first
 
     self.version_number = last_version ? last_version.version_number + 1 : 1
   end