decision_agent 0.1.3 → 0.1.6

data/lib/decision_agent.rb

@@ -36,5 +36,64 @@ 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"
+
+require_relative "decision_agent/testing/test_scenario"
+require_relative "decision_agent/testing/batch_test_importer"
+require_relative "decision_agent/testing/batch_test_runner"
+require_relative "decision_agent/testing/test_result_comparator"
+require_relative "decision_agent/testing/test_coverage_analyzer"
+
+require_relative "decision_agent/auth/user"
+require_relative "decision_agent/auth/role"
+require_relative "decision_agent/auth/permission"
+require_relative "decision_agent/auth/session"
+require_relative "decision_agent/auth/session_manager"
+require_relative "decision_agent/auth/password_reset_token"
+require_relative "decision_agent/auth/password_reset_manager"
+require_relative "decision_agent/auth/authenticator"
+require_relative "decision_agent/auth/rbac_adapter"
+require_relative "decision_agent/auth/rbac_config"
+require_relative "decision_agent/auth/permission_checker"
+require_relative "decision_agent/auth/access_audit_logger"
+
 module DecisionAgent
+  # Global RBAC configuration
+  @rbac_config = Auth::RbacConfig.new
+
+  class << self
+    attr_reader :rbac_config
+
+    # Configure RBAC adapter
+    # @param adapter_type [Symbol] :default, :devise_cancan, :pundit, or :custom
+    # @param options [Hash] Options for the adapter
+    # @yield [RbacConfig] Configuration block
+    # @example
+    #   DecisionAgent.configure_rbac(:devise_cancan, ability_class: Ability)
+    # @example
+    #   DecisionAgent.configure_rbac(:custom) do |config|
+    #     config.adapter = MyCustomAdapter.new
+    #   end
+    def configure_rbac(adapter_type = nil, **options)
+      if block_given?
+        yield @rbac_config
+      elsif adapter_type
+        @rbac_config.use(adapter_type, **options)
+      end
+      @rbac_config
+    end
+
+    # Get the configured permission checker
+    def permission_checker
+      @permission_checker ||= Auth::PermissionChecker.new(adapter: @rbac_config.adapter)
+    end
+
+    # Set a custom permission checker
+    attr_writer :permission_checker
+  end
 end

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

@@ -10,6 +10,14 @@ module DecisionAgent
 
       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)
@@ -19,11 +27,40 @@ module DecisionAgent
         migration_template "migration.rb",
                            "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

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