decision_agent 0.1.3 → 0.1.4

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/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

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+class PerformanceMetric < ApplicationRecord
+  validates :operation, presence: true
+  validates :duration_ms, numericality: { greater_than_or_equal_to: 0 }, 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 :by_operation, ->(operation) { where(operation: operation) }
+  scope :successful, -> { where(status: "success") }
+  scope :failed, -> { where(status: "failure") }
+  scope :with_errors, -> { where(status: "error") }
+  scope :slow, ->(threshold_ms = 1000) { where("duration_ms > ?", threshold_ms) }
+
+  # Performance statistics
+  def self.average_duration(time_range: 3600)
+    recent(time_range).where.not(duration_ms: nil).average(:duration_ms).to_f
+  end
+
+  def self.percentile(pct, time_range: 3600)
+    durations = recent(time_range).where.not(duration_ms: nil).order(:duration_ms).pluck(:duration_ms)
+    return 0.0 if durations.empty?
+
+    index = ((durations.length - 1) * pct).ceil
+    durations[index].to_f
+  end
+
+  def self.p50(time_range: 3600)
+    percentile(0.50, time_range: time_range)
+  end
+
+  def self.p95(time_range: 3600)
+    percentile(0.95, time_range: time_range)
+  end
+
+  def self.p99(time_range: 3600)
+    percentile(0.99, time_range: time_range)
+  end
+
+  def self.max_duration(time_range: 3600)
+    recent(time_range).maximum(:duration_ms).to_f
+  end
+
+  def self.min_duration(time_range: 3600)
+    recent(time_range).minimum(:duration_ms).to_f
+  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
+
+  def self.count_by_operation(time_range: 3600)
+    recent(time_range).group(:operation).count
+  end
+
+  # Time series aggregation
+  def self.average_duration_by_time(bucket_size: 60, time_range: 3600)
+    recent(time_range)
+      .where.not(duration_ms: nil)
+      .group("(EXTRACT(EPOCH FROM created_at)::bigint / #{bucket_size}) * #{bucket_size}")
+      .average(:duration_ms)
+  end
+
+  # Parse JSON metadata field
+  def parsed_metadata
+    return {} if metadata.nil?
+
+    JSON.parse(metadata, symbolize_names: true)
+  rescue JSON::ParserError
+    {}
+  end
+end