rails_nexus 2.0.0

data/app/models/rails_nexus/backup.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module RailsNexus
+  class Backup < BaseRecord
+    self.table_name = "rails_nexus_backups"
+
+    validates :model_name, presence: true
+    validates :status, presence: true, inclusion: { in: %w[running success failed] }
+    validates :started_at, presence: true
+
+    scope :recent, ->(hours = 24) { where("started_at >= ?", hours.hours.ago) }
+    scope :successful, -> { where(status: "success") }
+    scope :failed, -> { where(status: "failed") }
+    scope :running, -> { where(status: "running") }
+    scope :by_model, ->(name) { where(model_name: name) }
+    scope :latest_first, -> { order(started_at: :desc) }
+
+    # Start tracking a backup run
+    def self.start!(model_name:, triggered_by: "system")
+      create!(
+        model_name: model_name,
+        status: "running",
+        triggered_by: triggered_by,
+        started_at: Time.current
+      )
+    end
+
+    # Mark backup as completed
+    def succeed!(file_path: nil, file_size: nil)
+      update!(
+        status: "success",
+        file_path: file_path,
+        file_size: file_size,
+        duration: (Time.current - started_at).round(2),
+        completed_at: Time.current
+      )
+    end
+
+    # Mark backup as failed
+    def fail!(error_message:)
+      update!(
+        status: "failed",
+        error_message: error_message,
+        duration: (Time.current - started_at).round(2),
+        completed_at: Time.current
+      )
+    end
+
+    # Get success rate for a model over the last N days
+    def self.success_rate(model_name:, days: 7)
+      records = by_model(model_name).where("started_at >= ?", days.days.ago).where.not(status: "running")
+      return 0 if records.empty?
+      (records.successful.count.to_f / records.count * 100).round(1)
+    end
+
+    # Get backup health summary
+    def self.health_summary(alert_threshold_hours: 24)
+      models = RailsNexus.configuration.backup_models || []
+      results = models.map do |model_name|
+        latest = by_model(model_name).successful.latest_first.first
+        age_hours = latest ? ((Time.current - latest.started_at) / 3600).round(1) : nil
+
+        {
+          model_name: model_name,
+          last_backup: latest&.started_at,
+          age_hours: age_hours,
+          status: age_hours.nil? ? "unknown" : (age_hours < alert_threshold_hours ? "healthy" : "stale"),
+          success_rate: success_rate(model_name: model_name),
+          last_file_size: latest&.file_size
+        }
+      end
+
+      {
+        healthy: results.all? { |r| r[:status] == "healthy" },
+        models: results,
+        alerts: results.select { |r| r[:status] == "stale" || r[:status] == "unknown" }
+      }
+    end
+
+    # Cleanup old backup records
+    def self.cleanup!(retention_days: 30)
+      where("started_at < ?", retention_days.days.ago).delete_all
+    end
+
+    # Format file size
+    def file_size_human
+      return "—" unless file_size
+      units = ["B", "KB", "MB", "GB"]
+      size = file_size.to_f
+      units.each do |unit|
+        return "#{size.round(1)} #{unit}" if size < 1024
+        size /= 1024
+      end
+      "#{size.round(1)} TB"
+    end
+
+    # Duration formatted
+    def duration_human
+      return "—" unless duration
+      if duration < 60
+        "#{duration.round(1)}s"
+      else
+        "#{(duration / 60).floor}m #{(duration % 60).round}s"
+      end
+    end
+  end
+end

data/app/models/rails_nexus/base_record.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RailsNexus
+  # Abstract base class for all RailsNexus models.
+  # Supports connecting to a separate database via configuration.
+  #
+  # When NO database config is set, this behaves identically to ApplicationRecord.
+  # The host app's default connection is used for all queries.
+  #
+  # Config options:
+  #   config.database_url = "mysql2://user:pass@localhost/rails_nexus"
+  #   config.database_name = "rails_nexus"   # looks up in config/database.yml
+  #   config.database_yml = "config/rails_nexus_database.yml"
+  #
+  class BaseRecord < ApplicationRecord
+    self.abstract_class = true
+
+    class << self
+      # Check if a separate database is configured
+      def separate_database?
+        config = RailsNexus.configuration
+        config.database_url.present? || config.database_name.present? || config.database_yml.present?
+      end
+    end
+  end
+end

data/app/models/rails_nexus/comment.rb

@@ -0,0 +1,13 @@
+module RailsNexus
+  class Comment < ActiveRecord::Base
+    self.table_name = "rails_nexus_comments"
+
+    belongs_to :logged_exception, counter_cache: :comments_count
+
+    validates :author, presence: true
+    validates :body, presence: true
+
+    scope :recent, -> { order(created_at: :desc) }
+    scope :by_type, ->(type) { where(comment_type: type) }
+  end
+end

data/app/models/rails_nexus/cron_job.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RailsNexus
+  class CronJob < BaseRecord
+    self.table_name = "rails_nexus_cron_jobs"
+
+    STATUSES = %w[pending running success failed].freeze
+
+    validates :name, presence: true
+    validates :status, inclusion: { in: STATUSES }
+
+    scope :recent, -> { order(created_at: :desc) }
+    scope :by_status, ->(status) { where(status: status) }
+    scope :failed, -> { by_status("failed") }
+    scope :successful, -> { by_status("success") }
+    scope :running, -> { by_status("running") }
+    scope :last_24h, -> { where("created_at >= ?", 24.hours.ago) }
+    scope :last_7d, -> { where("created_at >= ?", 7.days.ago) }
+
+    # Start a new cron job run
+    def self.start!(name, metadata: {})
+      create!(
+        name: name,
+        status: "running",
+        started_at: Time.current,
+        hostname: Socket.gethostname,
+        metadata: metadata
+      )
+    end
+
+    # Mark as successful
+    def succeed!(output: nil, duration: nil)
+      update!(
+        status: "success",
+        finished_at: Time.current,
+        output: output,
+        duration: duration || ((finished_at || Time.current) - (started_at || created_at))
+      )
+    end
+
+    # Mark as failed
+    def fail!(error: nil, duration: nil)
+      update!(
+        status: "failed",
+        finished_at: Time.current,
+        error_message: error,
+        duration: duration || ((finished_at || Time.current) - (started_at || created_at))
+      )
+    end
+
+    # Stats summary
+    def self.summary
+      {
+        total: count,
+        successful: successful.count,
+        failed: failed.count,
+        running: running.count,
+        last_run: recent.first,
+        failure_rate: count > 0 ? (failed.count.to_f / count * 100).round(1) : 0
+      }
+    end
+
+    # Success rate over last N days
+    def self.success_rate(days: 7)
+      recent_jobs = where("created_at >= ?", days.days.ago)
+      total = recent_jobs.count
+      return 0 if total == 0
+
+      (recent_jobs.successful.count.to_f / total * 100).round(1)
+    end
+  end
+end

data/app/models/rails_nexus/database_stat.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module RailsNexus
+  class DatabaseStat < BaseRecord
+    self.table_name = "rails_nexus_database_stats"
+
+    validates :recorded_at, presence: true
+
+    scope :recent, ->(hours = 24) { where("recorded_at >= ?", hours.hours.ago) }
+    scope :with_tables, -> { where.not(table_name: nil) }
+    scope :pool_stats, -> { where(table_name: nil) }
+
+    # Collect database health snapshot
+    def self.collect!
+      now = Time.current
+      adapter = ActiveRecord::Base.connection.adapter_name.downcase
+
+      # Connection pool stats
+      pool = ActiveRecord::Base.connection_pool
+      stats = pool_stats(pool)
+      create!(stats.merge(recorded_at: now))
+
+      # Table stats (MySQL only)
+      if adapter.include?("mysql")
+        collect_mysql_stats(now)
+      elsif adapter.include?("postgresql")
+        collect_postgresql_stats(now)
+      end
+    end
+
+    # Get pool utilization over time
+    def self.pool_utilization(hours: 24)
+      pool_stats
+        .where("recorded_at >= ?", hours.hours.ago)
+        .order(:recorded_at)
+        .map { |s| { time: s.recorded_at, utilization: s.utilization, busy: s.busy, idle: s.idle } }
+    end
+
+    # Get slow queries
+    def self.slow_queries(limit: 10)
+      where.not(slow_queries: nil)
+        .order(recorded_at: :desc)
+        .limit(1)
+        .flat_map(&:slow_queries)
+        .first(limit)
+    end
+
+    # Get N+1 patterns
+    def self.n1_patterns
+      where.not(n1_patterns: nil)
+        .order(recorded_at: :desc)
+        .limit(1)
+        .flat_map(&:n1_patterns)
+    end
+
+    private
+
+    def self.pool_stats(pool)
+      {
+        pool_size: pool.size,
+        busy: pool.connections.size,
+        idle: pool.size - pool.connections.size,
+        dead: 0,
+        waiting: pool.stat[:waiting] || 0,
+        utilization: pool.size > 0 ? (pool.connections.size.to_f / pool.size * 100).round(1) : 0
+      }
+    end
+
+    def self.collect_mysql_stats(now)
+      conn = ActiveRecord::Base.connection
+      tables = conn.execute(<<~SQL)
+        SELECT table_name, table_rows, data_length, index_length, data_free
+        FROM information_schema.tables
+        WHERE table_schema = DATABASE()
+        ORDER BY data_length + index_length DESC
+        LIMIT 50
+      SQL
+
+      tables.each do |row|
+        create!(
+          table_name: row["TABLE_NAME"],
+          table_rows: row["TABLE_ROWS"],
+          table_size: format_size(row["DATA_LENGTH"]),
+          index_size: format_size(row["INDEX_LENGTH"]),
+          data_free: format_size(row["DATA_FREE"]),
+          recorded_at: now
+        )
+      end
+    rescue StandardError => e
+      Rails.logger.error("[RailsNexus] Failed to collect MySQL stats: #{e.message}") if defined?(Rails)
+    end
+
+    def self.collect_postgresql_stats(now)
+      conn = ActiveRecord::Base.connection
+      tables = conn.execute(<<~SQL)
+        SELECT schemaname, relname, n_tup_ins, n_tup_upd, n_tup_del,
+               pg_size_pretty(pg_total_relation_size(relid)) as total_size,
+               pg_size_pretty(pg_indexes_size(relid)) as index_size
+        FROM pg_stat_user_tables
+        ORDER BY pg_total_relation_size(relid) DESC
+        LIMIT 50
+      SQL
+
+      tables.each do |row|
+        create!(
+          table_name: row["relname"],
+          table_rows: (row["n_tup_ins"].to_i + row["n_tup_upd"].to_i - row["n_tup_del"].to_i),
+          table_size: row["total_size"],
+          index_size: row["index_size"],
+          recorded_at: now
+        )
+      end
+    rescue StandardError => e
+      Rails.logger.error("[RailsNexus] Failed to collect PostgreSQL stats: #{e.message}") if defined?(Rails)
+    end
+
+    def self.format_size(bytes)
+      return "0 B" unless bytes
+      units = ["B", "KB", "MB", "GB", "TB"]
+      size = bytes.to_f
+      units.each do |unit|
+        return "#{size.round(1)} #{unit}" if size < 1024
+        size /= 1024
+      end
+      "#{size.round(1)} PB"
+    end
+  end
+end

data/app/models/rails_nexus/event.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module RailsNexus
+  class Event < BaseRecord
+    self.table_name = "rails_nexus_events"
+
+    belongs_to :eventable, polymorphic: true, optional: true
+
+    validates :event_type, presence: true, inclusion: { in: %w[
+      breadcrumb storm_start storm_end
+      assignment priority_change snooze unsnooze
+      mute unmute comment note status_change
+      backup_start backup_complete backup_failed
+      exception_created exception_resolved
+    ] }
+
+    validates :created_at, presence: true
+
+    scope :recent, ->(hours = 24) { where("created_at >= ?", hours.hours.ago) }
+    scope :by_type, ->(type) { where(event_type: type) }
+    scope :breadcrumbs, -> { by_type("breadcrumb") }
+    scope :workflow_events, -> { where(event_type: %w[assignment priority_change snooze unsnooze mute unmute comment note]) }
+    scope :storm_events, -> { where(event_type: %w[storm_start storm_end]) }
+    scope :audit_trail, ->(eventable) { where(eventable: eventable).order(created_at: :desc) }
+
+    # Record a breadcrumb
+    def self.breadcrumb!(message:, metadata: {}, author: nil)
+      create!(
+        event_type: "breadcrumb",
+        message: message,
+        metadata: metadata,
+        author: author,
+        created_at: Time.current
+      )
+    end
+
+    # Record a storm event
+    def self.storm_start!(threshold:, current_rate:)
+      create!(
+        event_type: "storm_start",
+        message: "Error storm detected: #{current_rate} errors/sec (threshold: #{threshold}/sec)",
+        metadata: { threshold: threshold, current_rate: current_rate },
+        created_at: Time.current
+      )
+    end
+
+    def self.storm_end!(duration_seconds:)
+      create!(
+        event_type: "storm_end",
+        message: "Error storm ended after #{duration_seconds.round(1)}s",
+        metadata: { duration_seconds: duration_seconds },
+        created_at: Time.current
+      )
+    end
+
+    # Record a workflow event
+    def self.workflow!(event_type:, eventable:, message:, author: nil, metadata: {})
+      create!(
+        event_type: event_type,
+        eventable: eventable,
+        message: message,
+        author: author,
+        metadata: metadata,
+        created_at: Time.current
+      )
+    end
+
+    # Get event timeline for an exception
+    def self.timeline_for(exception)
+      where(eventable: exception).order(created_at: :asc)
+    end
+
+    # Cleanup old events
+    def self.cleanup!(retention_days: 30)
+      where("created_at < ?", retention_days.days.ago).delete_all
+    end
+
+    # Human-readable event type
+    def type_label
+      case event_type
+      when "breadcrumb" then "🔍 Breadcrumb"
+      when "storm_start" then "🌪️ Storm Start"
+      when "storm_end" then "☀️ Storm End"
+      when "assignment" then "👤 Assigned"
+      when "priority_change" then " priority Changed"
+      when "snooze" then "😴 Snoozed"
+      when "unsnooze" then "⏰ Unsnoozed"
+      when "mute" then "🔇 Muted"
+      when "unmute" then "🔊 Unmuted"
+      when "comment" then "💬 Comment"
+      when "note" then "📝 Note"
+      when "backup_start" then "💾 Backup Started"
+      when "backup_complete" then "✅ Backup Complete"
+      when "backup_failed" then "❌ Backup Failed"
+      when "exception_created" then "🚨 Exception Created"
+      when "exception_resolved" then "✓ Exception Resolved"
+      else event_type.humanize
+      end
+    end
+  end
+end