decision_agent 0.1.2 → 0.1.4

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,18 @@ 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
+
+require_relative "decision_agent/ab_testing/ab_test"
+require_relative "decision_agent/ab_testing/ab_test_assignment"
+require_relative "decision_agent/ab_testing/ab_test_manager"
+require_relative "decision_agent/ab_testing/ab_testing_agent"
+require_relative "decision_agent/ab_testing/storage/adapter"
+require_relative "decision_agent/ab_testing/storage/memory_adapter"
+
 module DecisionAgent
 end

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

@@ -1,15 +1,23 @@
-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"
 
+      class_option :monitoring, type: :boolean,
+                                default: false,
+                                desc: "Install monitoring tables and models for persistent metrics storage"
+
+      class_option :ab_testing, type: :boolean,
+                                default: false,
+                                desc: "Install A/B testing tables and models for variant testing"
+
       def self.next_migration_number(dirname)
         next_migration_number = current_migration_number(dirname) + 1
         ActiveRecord::Migration.next_migration_number(next_migration_number)
@@ -17,13 +25,42 @@ 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
+
+        if options[:monitoring]
+          migration_template "monitoring_migration.rb",
+                             "db/migrate/create_decision_agent_monitoring_tables.rb",
+                             migration_version: migration_version
+        end
+
+        return unless options[:ab_testing]
+
+        migration_template "ab_testing_migration.rb",
+                           "db/migrate/create_decision_agent_ab_testing_tables.rb",
+                           migration_version: migration_version
       end
 
       def copy_models
         copy_file "rule.rb", "app/models/rule.rb"
         copy_file "rule_version.rb", "app/models/rule_version.rb"
+
+        if options[:monitoring]
+          copy_file "decision_log.rb", "app/models/decision_log.rb"
+          copy_file "evaluation_metric.rb", "app/models/evaluation_metric.rb"
+          copy_file "performance_metric.rb", "app/models/performance_metric.rb"
+          copy_file "error_metric.rb", "app/models/error_metric.rb"
+        end
+
+        return unless options[:ab_testing]
+
+        copy_file "ab_test_model.rb", "app/models/ab_test_model.rb"
+        copy_file "ab_test_assignment_model.rb", "app/models/ab_test_assignment_model.rb"
+      end
+
+      def copy_rake_tasks
+        copy_file "decision_agent_tasks.rake", "lib/tasks/decision_agent.rake" if options[:monitoring]
+        copy_file "ab_testing_tasks.rake", "lib/tasks/ab_testing.rake" if options[:ab_testing]
       end
 
       def show_readme

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

@@ -0,0 +1,45 @@
+# A/B Test Assignment model for decision_agent gem
+# Tracks individual variant assignments and their results
+class ABTestAssignmentModel < ActiveRecord::Base
+  belongs_to :ab_test_model
+
+  validates :variant, presence: true, inclusion: { in: %w[champion challenger] }
+  validates :version_id, presence: true
+  validates :timestamp, presence: true
+
+  before_validation :set_defaults
+
+  # Scopes
+  scope :champion, -> { where(variant: "champion") }
+  scope :challenger, -> { where(variant: "challenger") }
+  scope :with_decisions, -> { where.not(decision_result: nil) }
+  scope :recent, -> { order(timestamp: :desc) }
+  scope :for_user, ->(user_id) { where(user_id: user_id) }
+
+  serialize :context, JSON
+
+  # Check if decision has been recorded
+  def decision_recorded?
+    decision_result.present?
+  end
+
+  # Get the test this assignment belongs to
+  def test
+    ab_test_model
+  end
+
+  # Record decision result
+  def record_decision!(decision, confidence_score)
+    update!(
+      decision_result: decision,
+      confidence: confidence_score
+    )
+  end
+
+  private
+
+  def set_defaults
+    self.timestamp ||= Time.current
+    self.context ||= {}
+  end
+end

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

@@ -0,0 +1,54 @@
+# A/B Test model for decision_agent gem
+# Stores A/B test configurations
+class ABTestModel < ActiveRecord::Base
+  has_many :ab_test_assignment_models, dependent: :destroy
+
+  validates :name, presence: true
+  validates :champion_version_id, presence: true
+  validates :challenger_version_id, presence: true
+  validates :status, presence: true, inclusion: { in: %w[scheduled running completed cancelled] }
+
+  serialize :traffic_split, JSON
+
+  before_validation :set_defaults
+
+  # Scopes
+  scope :active, -> { where(status: "running") }
+  scope :scheduled, -> { where(status: "scheduled") }
+  scope :completed, -> { where(status: "completed") }
+  scope :running_or_scheduled, -> { where(status: %w[running scheduled]) }
+
+  # Check if test is currently running
+  def running?
+    status == "running" &&
+      (start_date.nil? || start_date <= Time.current) &&
+      (end_date.nil? || end_date > Time.current)
+  end
+
+  # Get statistics for this test
+  def statistics
+    {
+      total_assignments: ab_test_assignment_models.count,
+      champion_count: ab_test_assignment_models.where(variant: "champion").count,
+      challenger_count: ab_test_assignment_models.where(variant: "challenger").count,
+      with_decisions: ab_test_assignment_models.where.not(decision_result: nil).count,
+      avg_confidence: ab_test_assignment_models.where.not(confidence: nil).average(:confidence)&.to_f
+    }
+  end
+
+  # Get assignments by variant
+  def champion_assignments
+    ab_test_assignment_models.where(variant: "champion")
+  end
+
+  def challenger_assignments
+    ab_test_assignment_models.where(variant: "challenger")
+  end
+
+  private
+
+  def set_defaults
+    self.traffic_split ||= { champion: 90, challenger: 10 }
+    self.status ||= "scheduled"
+  end
+end