decision_agent 0.1.2 → 0.1.4

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

@@ -0,0 +1,43 @@
+class CreateDecisionAgentABTestingTables < ActiveRecord::Migration[7.0]
+  def change
+    # A/B Tests table
+    create_table :ab_test_models do |t|
+      t.string :name, null: false
+      t.string :champion_version_id, null: false
+      t.string :challenger_version_id, null: false
+      t.text :traffic_split, null: false # JSON: { champion: 90, challenger: 10 }
+      t.datetime :start_date
+      t.datetime :end_date
+      t.string :status, null: false, default: "scheduled" # scheduled, running, completed, cancelled
+      t.timestamps
+    end
+
+    add_index :ab_test_models, :status
+    add_index :ab_test_models, :start_date
+    add_index :ab_test_models, %i[status start_date], name: "index_ab_tests_on_status_and_start_date"
+
+    # A/B Test Assignments table
+    create_table :ab_test_assignment_models do |t|
+      t.references :ab_test_model, null: false, foreign_key: true, index: true
+      t.string :user_id # Optional: for consistent assignment to same users
+      t.string :variant, null: false # "champion" or "challenger"
+      t.string :version_id, null: false
+      t.datetime :timestamp, null: false, default: -> { "CURRENT_TIMESTAMP" }
+
+      # Decision results (populated after decision is made)
+      t.string :decision_result
+      t.float :confidence
+      t.text :context # JSON: additional context
+
+      t.timestamps
+    end
+
+    add_index :ab_test_assignment_models, :user_id
+    add_index :ab_test_assignment_models, :variant
+    add_index :ab_test_assignment_models, :timestamp
+    add_index :ab_test_assignment_models, %i[ab_test_model_id variant], name: "index_assignments_on_test_and_variant"
+
+    # Optional: Index for querying assignments with decisions
+    add_index :ab_test_assignment_models, :decision_result, where: "decision_result IS NOT NULL", name: "index_assignments_with_decisions"
+  end
+end

data/lib/generators/decision_agent/install/templates/ab_testing_tasks.rake

@@ -0,0 +1,189 @@
+# rubocop:disable Metrics/BlockLength
+namespace :decision_agent do
+  namespace :ab_testing do
+    desc "List all A/B tests"
+    task list: :environment do
+      require "decision_agent/ab_testing/ab_test_manager"
+
+      manager = DecisionAgent::ABTesting::ABTestManager.new(
+        storage_adapter: DecisionAgent::ABTesting::Storage::ActiveRecordAdapter.new
+      )
+
+      tests = manager.list_tests
+      puts "\n📊 A/B Tests (Total: #{tests.size})\n"
+      puts "=" * 80
+
+      if tests.empty?
+        puts "No A/B tests found."
+      else
+        tests.each do |test|
+          puts "\nID: #{test.id}"
+          puts "Name: #{test.name}"
+          puts "Status: #{test.status}"
+          puts "Champion Version: #{test.champion_version_id}"
+          puts "Challenger Version: #{test.challenger_version_id}"
+          puts "Traffic Split: #{test.traffic_split[:champion]}% / #{test.traffic_split[:challenger]}%"
+          puts "Start Date: #{test.start_date}"
+          puts "End Date: #{test.end_date || 'N/A'}"
+          puts "-" * 80
+        end
+      end
+    end
+
+    desc "Show A/B test results - Usage: rake decision_agent:ab_testing:results[test_id]"
+    task :results, [:test_id] => :environment do |_t, args|
+      require "decision_agent/ab_testing/ab_test_manager"
+
+      test_id = args[:test_id]
+      raise "Test ID is required. Usage: rake decision_agent:ab_testing:results[123]" unless test_id
+
+      manager = DecisionAgent::ABTesting::ABTestManager.new(
+        storage_adapter: DecisionAgent::ABTesting::Storage::ActiveRecordAdapter.new
+      )
+
+      results = manager.get_results(test_id)
+
+      puts "\n📊 A/B Test Results"
+      puts "=" * 80
+      puts "\nTest: #{results[:test][:name]}"
+      puts "Status: #{results[:test][:status]}"
+      puts "Total Assignments: #{results[:total_assignments]}"
+      puts ""
+
+      puts "🏆 Champion (Version #{results[:test][:champion_version_id]})"
+      puts "  Assignments: #{results[:champion][:total_assignments]}"
+      puts "  Decisions Recorded: #{results[:champion][:decisions_recorded]}"
+      if results[:champion][:avg_confidence]
+        puts "  Avg Confidence: #{results[:champion][:avg_confidence]}"
+        puts "  Min/Max Confidence: #{results[:champion][:min_confidence]} / #{results[:champion][:max_confidence]}"
+      end
+      puts ""
+
+      puts "🆕 Challenger (Version #{results[:test][:challenger_version_id]})"
+      puts "  Assignments: #{results[:challenger][:total_assignments]}"
+      puts "  Decisions Recorded: #{results[:challenger][:decisions_recorded]}"
+      if results[:challenger][:avg_confidence]
+        puts "  Avg Confidence: #{results[:challenger][:avg_confidence]}"
+        puts "  Min/Max Confidence: #{results[:challenger][:min_confidence]} / #{results[:challenger][:max_confidence]}"
+      end
+      puts ""
+
+      if results[:comparison][:statistical_significance] == "insufficient_data"
+        puts "⚠️  Insufficient data for statistical comparison"
+      else
+        puts "📈 Statistical Comparison"
+        puts "  Improvement: #{results[:comparison][:improvement_percentage]}%"
+        puts "  Winner: #{results[:comparison][:winner]}"
+        puts "  Statistical Significance: #{results[:comparison][:statistical_significance]}"
+        puts "  Confidence Level: #{(results[:comparison][:confidence_level] * 100).round(0)}%"
+        puts ""
+        puts "💡 Recommendation: #{results[:comparison][:recommendation]}"
+      end
+
+      puts "=" * 80
+    end
+
+    desc "Start an A/B test - Usage: rake decision_agent:ab_testing:start[test_id]"
+    task :start, [:test_id] => :environment do |_t, args|
+      require "decision_agent/ab_testing/ab_test_manager"
+
+      test_id = args[:test_id]
+      raise "Test ID is required. Usage: rake decision_agent:ab_testing:start[123]" unless test_id
+
+      manager = DecisionAgent::ABTesting::ABTestManager.new(
+        storage_adapter: DecisionAgent::ABTesting::Storage::ActiveRecordAdapter.new
+      )
+
+      manager.start_test(test_id)
+      puts "✅ A/B test #{test_id} started successfully!"
+    end
+
+    desc "Complete an A/B test - Usage: rake decision_agent:ab_testing:complete[test_id]"
+    task :complete, [:test_id] => :environment do |_t, args|
+      require "decision_agent/ab_testing/ab_test_manager"
+
+      test_id = args[:test_id]
+      raise "Test ID is required. Usage: rake decision_agent:ab_testing:complete[123]" unless test_id
+
+      manager = DecisionAgent::ABTesting::ABTestManager.new(
+        storage_adapter: DecisionAgent::ABTesting::Storage::ActiveRecordAdapter.new
+      )
+
+      manager.complete_test(test_id)
+      puts "✅ A/B test #{test_id} completed successfully!"
+    end
+
+    desc "Cancel an A/B test - Usage: rake decision_agent:ab_testing:cancel[test_id]"
+    task :cancel, [:test_id] => :environment do |_t, args|
+      require "decision_agent/ab_testing/ab_test_manager"
+
+      test_id = args[:test_id]
+      raise "Test ID is required. Usage: rake decision_agent:ab_testing:cancel[123]" unless test_id
+
+      manager = DecisionAgent::ABTesting::ABTestManager.new(
+        storage_adapter: DecisionAgent::ABTesting::Storage::ActiveRecordAdapter.new
+      )
+
+      manager.cancel_test(test_id)
+      puts "✅ A/B test #{test_id} cancelled successfully!"
+    end
+
+    desc "Create a new A/B test - Usage: rake decision_agent:ab_testing:create[name,champion_id,challenger_id,split]"
+    task :create, %i[name champion_id challenger_id split] => :environment do |_t, args|
+      require "decision_agent/ab_testing/ab_test_manager"
+
+      name = args[:name]
+      champion_id = args[:champion_id]
+      challenger_id = args[:challenger_id]
+      split = args[:split] || "90,10"
+
+      unless name && champion_id && challenger_id
+        raise "Missing arguments. Usage: rake decision_agent:ab_testing:create[name,champion_id,challenger_id,split]"
+      end
+
+      champion_pct, challenger_pct = split.split(",").map(&:to_i)
+
+      manager = DecisionAgent::ABTesting::ABTestManager.new(
+        storage_adapter: DecisionAgent::ABTesting::Storage::ActiveRecordAdapter.new
+      )
+
+      test = manager.create_test(
+        name: name,
+        champion_version_id: champion_id,
+        challenger_version_id: challenger_id,
+        traffic_split: { champion: champion_pct, challenger: challenger_pct }
+      )
+
+      puts "✅ A/B test created successfully!"
+      puts "   ID: #{test.id}"
+      puts "   Name: #{test.name}"
+      puts "   Status: #{test.status}"
+    end
+
+    desc "Show active A/B tests"
+    task active: :environment do
+      require "decision_agent/ab_testing/ab_test_manager"
+
+      manager = DecisionAgent::ABTesting::ABTestManager.new(
+        storage_adapter: DecisionAgent::ABTesting::Storage::ActiveRecordAdapter.new
+      )
+
+      tests = manager.active_tests
+      puts "\n🔄 Active A/B Tests (Total: #{tests.size})\n"
+      puts "=" * 80
+
+      if tests.empty?
+        puts "No active A/B tests found."
+      else
+        tests.each do |test|
+          puts "\nID: #{test.id}"
+          puts "Name: #{test.name}"
+          puts "Champion vs Challenger: #{test.champion_version_id} vs #{test.challenger_version_id}"
+          puts "Traffic Split: #{test.traffic_split[:champion]}% / #{test.traffic_split[:challenger]}%"
+          puts "-" * 80
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/BlockLength

data/lib/generators/decision_agent/install/templates/decision_agent_tasks.rake

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+namespace :decision_agent do
+  namespace :monitoring do
+    desc "Cleanup old monitoring metrics (default: older than 30 days)"
+    task cleanup: :environment do
+      older_than = ENV.fetch("OLDER_THAN", 30 * 24 * 3600).to_i # Default: 30 days
+
+      puts "Cleaning up metrics older than #{older_than / 86_400} days..."
+
+      count = 0
+      count += DecisionLog.where("created_at < ?", Time.now - older_than).delete_all
+      count += EvaluationMetric.where("created_at < ?", Time.now - older_than).delete_all
+      count += PerformanceMetric.where("created_at < ?", Time.now - older_than).delete_all
+      count += ErrorMetric.where("created_at < ?", Time.now - older_than).delete_all
+
+      puts "Deleted #{count} old metric records"
+    end
+
+    desc "Show monitoring statistics"
+    task stats: :environment do
+      time_range = ENV.fetch("TIME_RANGE", 3600).to_i # Default: 1 hour
+
+      puts "\n=== Decision Agent Monitoring Statistics ==="
+      puts "Time range: Last #{time_range / 3600.0} hours\n\n"
+
+      decisions = DecisionLog.recent(time_range)
+      evaluations = EvaluationMetric.recent(time_range)
+      performance = PerformanceMetric.recent(time_range)
+      errors = ErrorMetric.recent(time_range)
+
+      puts "Decisions:"
+      puts "  Total: #{decisions.count}"
+      puts "  Average confidence: #{decisions.average(:confidence)&.round(4) || 'N/A'}"
+      puts "  Success rate: #{(DecisionLog.success_rate(time_range: time_range) * 100).round(2)}%"
+      puts "  By decision: #{decisions.group(:decision).count}"
+
+      puts "\nEvaluations:"
+      puts "  Total: #{evaluations.count}"
+      puts "  By evaluator: #{evaluations.group(:evaluator_name).count}"
+
+      puts "\nPerformance:"
+      puts "  Total operations: #{performance.count}"
+      puts "  Average duration: #{performance.average_duration(time_range: time_range)&.round(2) || 'N/A'} ms"
+      puts "  P95 latency: #{performance.p95(time_range: time_range).round(2)} ms"
+      puts "  P99 latency: #{performance.p99(time_range: time_range).round(2)} ms"
+      puts "  Success rate: #{(performance.success_rate(time_range: time_range) * 100).round(2)}%"
+
+      puts "\nErrors:"
+      puts "  Total: #{errors.count}"
+      puts "  By type: #{errors.group(:error_type).count}"
+      puts "  By severity: #{errors.group(:severity).count}"
+      puts "  Critical: #{errors.critical.count}"
+
+      puts "\n=== End of Statistics ===\n"
+    end
+
+    desc "Archive old metrics to JSON file"
+    task :archive, [:output_file] => :environment do |_t, args|
+      output_file = args[:output_file] || "metrics_archive_#{Time.now.to_i}.json"
+      older_than = ENV.fetch("OLDER_THAN", 30 * 24 * 3600).to_i
+      cutoff_time = Time.now - older_than
+
+      puts "Archiving metrics older than #{older_than / 86_400} days to #{output_file}..."
+
+      archive_data = {
+        archived_at: Time.now.iso8601,
+        cutoff_time: cutoff_time.iso8601,
+        decisions: DecisionLog.where("created_at < ?", cutoff_time).map do |d|
+          {
+            decision: d.decision,
+            confidence: d.confidence,
+            context: d.parsed_context,
+            status: d.status,
+            created_at: d.created_at.iso8601
+          }
+        end,
+        evaluations: EvaluationMetric.where("created_at < ?", cutoff_time).map do |e|
+          {
+            evaluator_name: e.evaluator_name,
+            score: e.score,
+            success: e.success,
+            details: e.parsed_details,
+            created_at: e.created_at.iso8601
+          }
+        end,
+        performance: PerformanceMetric.where("created_at < ?", cutoff_time).map do |p|
+          {
+            operation: p.operation,
+            duration_ms: p.duration_ms,
+            status: p.status,
+            metadata: p.parsed_metadata,
+            created_at: p.created_at.iso8601
+          }
+        end,
+        errors: ErrorMetric.where("created_at < ?", cutoff_time).map do |e|
+          {
+            error_type: e.error_type,
+            message: e.message,
+            severity: e.severity,
+            context: e.parsed_context,
+            created_at: e.created_at.iso8601
+          }
+        end
+      }
+
+      File.write(output_file, JSON.pretty_generate(archive_data))
+
+      total = archive_data.values.sum { |v| v.is_a?(Array) ? v.size : 0 }
+      puts "Archived #{total} metrics to #{output_file}"
+      puts "Run 'rake decision_agent:monitoring:cleanup' to delete these records from the database"
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+class DecisionLog < ApplicationRecord
+  has_many :evaluation_metrics, dependent: :destroy
+
+  validates :decision, presence: true
+  validates :confidence, numericality: { greater_than_or_equal_to: 0, less_than_or_equal_to: 1 }, allow_nil: true
+  validates :status, inclusion: { in: %w[success failure error] }, allow_nil: true
+
+  scope :recent, ->(time_range = 3600) { where("created_at >= ?", Time.now - time_range) }
+  scope :successful, -> { where(status: "success") }
+  scope :failed, -> { where(status: "failure") }
+  scope :with_errors, -> { where(status: "error") }
+  scope :by_decision, ->(decision) { where(decision: decision) }
+  scope :low_confidence, ->(threshold = 0.5) { where("confidence < ?", threshold) }
+  scope :high_confidence, ->(threshold = 0.8) { where("confidence >= ?", threshold) }
+
+  # Time series aggregation helpers
+  def self.count_by_time_bucket(bucket_size: 60, time_range: 3600)
+    recent(time_range)
+      .group("(EXTRACT(EPOCH FROM created_at)::bigint / #{bucket_size}) * #{bucket_size}")
+      .count
+  end
+
+  def self.average_confidence_by_time(bucket_size: 60, time_range: 3600)
+    recent(time_range)
+      .where.not(confidence: nil)
+      .group("(EXTRACT(EPOCH FROM created_at)::bigint / #{bucket_size}) * #{bucket_size}")
+      .average(:confidence)
+  end
+
+  def self.success_rate(time_range: 3600)
+    total = recent(time_range).where.not(status: nil).count
+    return 0.0 if total.zero?
+
+    successful_count = recent(time_range).successful.count
+    successful_count.to_f / total
+  end
+
+  # Parse JSON context field
+  def parsed_context
+    return {} if context.nil?
+
+    JSON.parse(context, symbolize_names: true)
+  rescue JSON::ParserError
+    {}
+  end
+
+  # Parse JSON metadata field
+  def parsed_metadata
+    return {} if metadata.nil?
+
+    JSON.parse(metadata, symbolize_names: true)
+  rescue JSON::ParserError
+    {}
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+class ErrorMetric < ApplicationRecord
+  validates :error_type, presence: true
+  validates :severity, inclusion: { in: %w[low medium high critical] }, allow_nil: true
+
+  scope :recent, ->(time_range = 3600) { where("created_at >= ?", Time.now - time_range) }
+  scope :by_type, ->(error_type) { where(error_type: error_type) }
+  scope :by_severity, ->(severity) { where(severity: severity) }
+  scope :critical, -> { where(severity: "critical") }
+  scope :high_severity, -> { where(severity: %w[high critical]) }
+
+  # Aggregation helpers
+  def self.count_by_type(time_range: 3600)
+    recent(time_range).group(:error_type).count
+  end
+
+  def self.count_by_severity(time_range: 3600)
+    recent(time_range).group(:severity).count
+  end
+
+  def self.error_rate(time_range: 3600, total_operations: nil)
+    error_count = recent(time_range).count
+    return 0.0 if total_operations.nil? || total_operations.zero?
+
+    error_count.to_f / total_operations
+  end
+
+  # Time series aggregation
+  def self.count_by_time_bucket(bucket_size: 60, time_range: 3600)
+    recent(time_range)
+      .group("(EXTRACT(EPOCH FROM created_at)::bigint / #{bucket_size}) * #{bucket_size}")
+      .count
+  end
+
+  # Parse JSON context field
+  def parsed_context
+    return {} if context.nil?
+
+    JSON.parse(context, symbolize_names: true)
+  rescue JSON::ParserError
+    {}
+  end
+
+  # Parse JSON stack_trace field
+  def parsed_stack_trace
+    return [] if stack_trace.nil?
+
+    JSON.parse(stack_trace)
+  rescue JSON::ParserError
+    []
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+class EvaluationMetric < ApplicationRecord
+  belongs_to :decision_log, optional: true
+
+  validates :evaluator_name, presence: true
+  validates :score, numericality: true, allow_nil: true
+
+  scope :recent, ->(time_range = 3600) { where("created_at >= ?", Time.now - time_range) }
+  scope :by_evaluator, ->(evaluator) { where(evaluator_name: evaluator) }
+  scope :successful, -> { where(success: true) }
+  scope :failed, -> { where(success: false) }
+
+  # Aggregation helpers
+  def self.average_score_by_evaluator(time_range: 3600)
+    recent(time_range)
+      .where.not(score: nil)
+      .group(:evaluator_name)
+      .average(:score)
+  end
+
+  def self.success_rate_by_evaluator(time_range: 3600)
+    recent(time_range)
+      .where.not(success: nil)
+      .group(:evaluator_name)
+      .select("evaluator_name, AVG(CASE WHEN success THEN 1.0 ELSE 0.0 END) as success_rate")
+  end
+
+  def self.count_by_evaluator(time_range: 3600)
+    recent(time_range)
+      .group(:evaluator_name)
+      .count
+  end
+
+  # Parse JSON details field
+  def parsed_details
+    return {} if details.nil?
+
+    JSON.parse(details, symbolize_names: true)
+  rescue JSON::ParserError
+    {}
+  end
+end

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/monitoring_migration.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+class CreateDecisionAgentMonitoringTables < ActiveRecord::Migration[7.0]
+  # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+  def change
+    # Decision logs table
+    create_table :decision_logs do |t|
+      t.string :decision, null: false
+      t.float :confidence
+      t.integer :evaluations_count, default: 0
+      t.float :duration_ms
+      t.string :status # success, failure, error
+      t.text :context # JSON
+      t.text :metadata # JSON
+
+      t.timestamps
+    end
+
+    add_index :decision_logs, :decision
+    add_index :decision_logs, :status
+    add_index :decision_logs, :confidence
+    add_index :decision_logs, :created_at
+    add_index :decision_logs, %i[decision created_at]
+    add_index :decision_logs, %i[status created_at]
+
+    # Evaluation metrics table
+    create_table :evaluation_metrics do |t|
+      t.references :decision_log, foreign_key: true, index: true
+      t.string :evaluator_name, null: false
+      t.float :score
+      t.boolean :success
+      t.float :duration_ms
+      t.text :details # JSON
+
+      t.timestamps
+    end
+
+    add_index :evaluation_metrics, :evaluator_name
+    add_index :evaluation_metrics, :success
+    add_index :evaluation_metrics, :created_at
+    add_index :evaluation_metrics, %i[evaluator_name created_at]
+    add_index :evaluation_metrics, %i[evaluator_name success]
+
+    # Performance metrics table
+    create_table :performance_metrics do |t|
+      t.string :operation, null: false
+      t.float :duration_ms
+      t.string :status # success, failure, error
+      t.text :metadata # JSON
+
+      t.timestamps
+    end
+
+    add_index :performance_metrics, :operation
+    add_index :performance_metrics, :status
+    add_index :performance_metrics, :duration_ms
+    add_index :performance_metrics, :created_at
+    add_index :performance_metrics, %i[operation created_at]
+    add_index :performance_metrics, %i[status created_at]
+
+    # Error metrics table
+    create_table :error_metrics do |t|
+      t.string :error_type, null: false
+      t.text :message
+      t.text :stack_trace # JSON array
+      t.string :severity # low, medium, high, critical
+      t.text :context # JSON
+
+      t.timestamps
+    end
+
+    add_index :error_metrics, :error_type
+    add_index :error_metrics, :severity
+    add_index :error_metrics, :created_at
+    add_index :error_metrics, %i[error_type created_at]
+    add_index :error_metrics, %i[severity created_at]
+
+    # PostgreSQL-specific optimizations (optional)
+    return unless adapter_name == "PostgreSQL"
+
+    # Partial indexes for active records (recent data)
+    execute <<-SQL
+        CREATE INDEX index_decision_logs_on_recent
+        ON decision_logs (created_at DESC)
+        WHERE created_at >= NOW() - INTERVAL '7 days';
+    SQL
+
+    execute <<-SQL
+        CREATE INDEX index_performance_metrics_on_recent
+        ON performance_metrics (created_at DESC)
+        WHERE created_at >= NOW() - INTERVAL '7 days';
+    SQL
+
+    execute <<-SQL
+        CREATE INDEX index_error_metrics_on_recent_critical
+        ON error_metrics (created_at DESC)
+        WHERE severity IN ('high', 'critical') AND created_at >= NOW() - INTERVAL '7 days';
+    SQL
+
+    # Consider table partitioning for large-scale deployments
+    # Example: Partition by month for decision_logs
+    # This is commented out by default - enable if needed
+    # execute <<-SQL
+    #   CREATE TABLE decision_logs_partitioned (LIKE decision_logs INCLUDING ALL)
+    #   PARTITION BY RANGE (created_at);
+    # SQL
+  end
+  # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+end