rails_nexus 2.0.0 → 2.0.1

data/app/models/rails_nexus/database_stat.rb

@@ -1,128 +0,0 @@
-# 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

@@ -1,101 +0,0 @@
-# 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

data/app/models/rails_nexus/metric.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-module RailsNexus
-  class Metric < BaseRecord
-    self.table_name = "rails_nexus_metrics"
-
-    validates :metric_type, presence: true
-    validates :value, presence: true
-    validates :recorded_at, presence: true
-
-    scope :recent, ->(hours = 24) { where("recorded_at >= ?", hours.hours.ago) }
-    scope :by_type, ->(type) { where(metric_type: type) }
-    scope :cpu, -> { by_type("cpu") }
-    scope :memory, -> { by_type("memory") }
-    scope :threads, -> { by_type("threads") }
-    scope :db_pool, -> { by_type("db_pool") }
-    scope :disk, -> { by_type("disk") }
-
-    # Collect current system metrics
-    def self.collect!
-      now = Time.current
-
-      # CPU usage
-      cpu_usage = detect_cpu_usage
-      create!(metric_type: "cpu", value: cpu_usage, unit: "%", recorded_at: now) if cpu_usage
-
-      # Memory
-      mem = detect_memory_usage
-      if mem
-        create!(metric_type: "memory_total", value: mem[:total], unit: "mb", recorded_at: now)
-        create!(metric_type: "memory_used", value: mem[:used], unit: "mb", recorded_at: now)
-        create!(metric_type: "memory_free", value: mem[:free], unit: "mb", recorded_at: now)
-      end
-
-      # Threads
-      create!(metric_type: "threads", value: Thread.list.size, unit: "count", recorded_at: now)
-
-      # DB pool
-      db_pool = detect_db_pool
-      if db_pool
-        create!(metric_type: "db_pool_size", value: db_pool[:size], unit: "count", recorded_at: now)
-        create!(metric_type: "db_pool_busy", value: db_pool[:busy], unit: "count", recorded_at: now)
-        create!(metric_type: "db_pool_idle", value: db_pool[:idle], unit: "count", recorded_at: now)
-      end
-
-      # GC stats
-      gc = GC.stat
-      create!(metric_type: "gc_count", value: gc[:count].to_f, unit: "count", recorded_at: now)
-      create!(metric_type: "gc_heap_allocated", value: (gc[:heap_allocated_objects].to_f / 1_000_000), unit: "m", recorded_at: now)
-    end
-
-    # Get metric as a time series for charts
-    def self.time_series(type, hours: 24, interval: 15)
-      by_type(type)
-        .where("recorded_at >= ?", hours.hours.ago)
-        .order(:recorded_at)
-        .group_by { |m| (m.recorded_at.to_i / (interval * 60)) * (interval * 60) }
-        .map { |ts, records| { time: Time.at(ts), value: records.map(&:value).sum / records.size.to_f } }
-    end
-
-    # Cleanup old metrics
-    def self.cleanup!(retention_hours: 168)
-      where("recorded_at < ?", retention_hours.hours.ago).delete_all
-    end
-
-    private
-
-    def self.detect_cpu_usage
-      # Linux: read /proc/stat
-      if File.exist?("/proc/stat")
-        line = File.readlines("/proc/stat").first
-        values = line.split[1..].map(&:to_f)
-        idle = values[3]
-        total = values.sum
-        # Approximate — real implementation needs two readings
-        ((total - idle) / total * 100).round(1)
-      end
-    rescue StandardError
-      nil
-    end
-
-    def self.detect_memory_usage
-      if File.exist?("/proc/meminfo")
-        info = {}
-        File.readlines("/proc/meminfo").each do |line|
-          key, val = line.split(":")
-          info[key.strip] = val.strip.split.first.to_i if key && val
-        end
-        total = (info["MemTotal"] || 0) / 1024
-        free = (info["MemAvailable"] || info["MemFree"] || 0) / 1024
-        used = total - free
-        { total: total.round, used: used.round, free: free.round }
-      end
-    rescue StandardError
-      nil
-    end
-
-    def self.detect_db_pool
-      if ActiveRecord::Base.connection_pool
-        pool = ActiveRecord::Base.connection_pool
-        { size: pool.size, busy: pool.connections.size, idle: pool.size - pool.connections.size }
-      end
-    rescue StandardError
-      nil
-    end
-  end
-end

data/app/models/rails_nexus/nginx_metric.rb

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-module RailsNexus
-  class NginxMetric < BaseRecord
-    self.table_name = "rails_nexus_nginx_metrics"
-
-    validates :status_code, presence: true
-    validates :recorded_at, presence: true
-
-    scope :recent, ->(hours = 24) { where("recorded_at >= ?", hours.hours.ago) }
-    scope :by_status, ->(code) { where(status_code: code) }
-    scope :errors, -> { where("status_code >= 400") }
-    scope :by_path, ->(path) { where(request_path: path) }
-
-    # Parse nginx access log file
-    def self.parse_log!(log_path, limit: 1000)
-      return unless File.exist?(log_path)
-      return unless File.readable?(log_path)
-
-      entries = []
-      File.foreach(log_path).last(limit).each do |line|
-        entry = parse_log_line(line)
-        entries << entry if entry
-      end
-
-      insert_all(entries) if entries.any?
-      entries.size
-    end
-
-    # Get status code distribution
-    def self.status_distribution(hours: 24)
-      recent(hours)
-        .group(:status_code)
-        .order("count_all DESC")
-        .count
-    end
-
-    # Get top slow endpoints
-    def self.slow_endpoints(hours: 24, limit: 10)
-      recent(hours)
-        .where.not(response_time: nil)
-        .group(:request_path)
-        .order("AVG(response_time) DESC")
-        .limit(limit)
-        .average(:response_time)
-        .map { |path, avg_time| { path: path, avg_response_time: avg_time&.round(3) } }
-    end
-
-    # Get requests per minute over time
-    def self.requests_over_time(hours: 24, interval_minutes: 5)
-      recent(hours)
-        .order(:recorded_at)
-        .group_by { |r| (r.recorded_at.to_i / (interval_minutes * 60)) * (interval_minutes * 60) }
-        .map do |ts, records|
-          {
-            time: Time.at(ts),
-            total: records.size,
-            errors: records.count { |r| r.status_code >= 400 },
-            avg_response_time: records.filter_map(&:response_time).then { |t| t.any? ? (t.sum / t.size).round(3) : nil }
-          }
-        end
-    end
-
-    # Get error rate
-    def self.error_rate(hours: 24)
-      total = recent(hours).count
-      return 0 if total.zero?
-      errors = recent(hours).errors.count
-      (errors.to_f / total * 100).round(2)
-    end
-
-    # Cleanup old metrics
-    def self.cleanup!(retention_days: 7)
-      where("recorded_at < ?", retention_days.days.ago).delete_all
-    end
-
-    private
-
-    # Parse a single nginx log line (combined format)
-    # Format: $remote_addr - $remote_user [$time_local] "$request" $status $body_bytes_sent "$http_referer" "$http_user_agent" $request_time $upstream_response_time
-    def self.parse_log_line(line)
-      pattern = /^(\S+) \S+ (\S+) \[([^\]]+)\] "(\S+) (\S+)(?:\s+\S+)?" (\d{3}) (\d+|-) "([^"]*)" "([^"]*)" ?(\d+\.?\d*)? ?(\d+\.?\d*)?$/
-
-      match = line.match(pattern)
-      return unless match
-
-      status_code = match[6].to_i
-      response_time = match[10]&.to_f
-      upstream_time = match[11]&.to_f
-
-      {
-        status_code: status_code,
-        request_method: match[4],
-        request_path: match[5],
-        response_time: response_time,
-        upstream_time: upstream_time,
-        remote_addr: match[1],
-        user_agent: match[9],
-        referer: match[8] != "-" ? match[8] : nil,
-        recorded_at: parse_nginx_time(match[3])
-      }
-    rescue StandardError
-      nil
-    end
-
-    def self.parse_nginx_time(time_str)
-      Time.parse(time_str)
-    rescue StandardError
-      Time.current
-    end
-  end
-end

data/app/models/rails_nexus/server_metric.rb

@@ -1,168 +0,0 @@
-# frozen_string_literal: true
-
-module RailsNexus
-  class ServerMetric < BaseRecord
-    self.table_name = "rails_nexus_server_metrics"
-
-    validates :recorded_at, presence: true
-
-    scope :recent, ->(hours = 24) { where("recorded_at >= ?", hours.hours.ago) }
-    scope :latest, -> { order(recorded_at: :desc).first }
-
-    # Collect current server metrics
-    def self.collect!
-      now = Time.current
-      data = {
-        hostname: Socket.gethostname,
-        ruby_version: RUBY_VERSION,
-        rails_version: defined?(Rails) ? Rails::VERSION::STRING : nil,
-        os_info: detect_os,
-        recorded_at: now
-      }
-
-      # CPU
-      cpu = detect_cpu
-      data.merge!(cpu) if cpu
-
-      # Memory
-      mem = detect_memory
-      data.merge!(mem) if mem
-
-      # Load averages
-      load_avg = detect_load_average
-      data.merge!(load_avg) if load_avg
-
-      # Disk
-      disk = detect_disk
-      data.merge!(disk) if disk
-
-      # Processes
-      procs = detect_processes
-      data.merge!(procs) if procs
-
-      # Uptime
-      data[:uptime_seconds] = detect_uptime
-
-      create!(data)
-    end
-
-    # Get latest metrics
-    def self.current
-      latest || collect!
-    end
-
-    # Get metric trend over time
-    def self.trend(field, hours: 24)
-      where("recorded_at >= ?", hours.hours.ago)
-        .order(:recorded_at)
-        .pluck(:recorded_at, field.to_sym)
-        .map { |time, value| { time: time, value: value&.to_f } }
-    end
-
-    # Cleanup old metrics
-    def self.cleanup!(retention_days: 7)
-      where("recorded_at < ?", retention_days.days.ago).delete_all
-    end
-
-    private
-
-    def self.detect_os
-      if File.exist?("/etc/os-release")
-        info = {}
-        File.readlines("/etc/os-release").each do |line|
-          key, val = line.split("=", 2)
-          info[key.strip] = val&.strip&.gsub('"', '') if key && val
-        end
-        "#{info['PRETTY_NAME'] || info['NAME']} #{info['VERSION']}"
-      elsif RUBY_PLATFORM =~ /darwin/
-        `sw_vers -productVersion`.strip
-      else
-        RUBY_PLATFORM
-      end
-    rescue StandardError
-      RUBY_PLATFORM
-    end
-
-    def self.detect_cpu
-      return unless File.exist?("/proc/cpuinfo")
-      cores = File.readlines("/proc/cpuinfo").count { |l| l =~ /^processor\s*:/ }
-      { cpu_cores: cores }
-    rescue StandardError
-      nil
-    end
-
-    def self.detect_memory
-      return unless File.exist?("/proc/meminfo")
-      info = {}
-      File.readlines("/proc/meminfo").each do |line|
-        key, val = line.split(":")
-        next unless key && val
-        kb = val.strip.split.first.to_i
-        case key.strip
-        when "MemTotal" then info[:memory_total] = kb / 1024
-        when "MemAvailable" then info[:memory_free] = kb / 1024
-        when "MemFree" then info[:memory_free] ||= kb / 1024
-        when "SwapTotal" then info[:swap_total] = kb / 1024
-        when "SwapFree" then info[:swap_used] = ((info[:swap_total] || 0) - (kb / 1024))
-        end
-      end
-      info[:memory_used] = (info[:memory_total] || 0) - (info[:memory_free] || 0) if info[:memory_total]
-      info
-    rescue StandardError
-      nil
-    end
-
-    def self.detect_load_average
-      if File.exist?("/proc/loadavg")
-        parts = File.read("/proc/loadavg").split
-        { load_avg_1m: parts[0].to_f, load_avg_5m: parts[1].to_f, load_avg_15m: parts[2].to_f }
-      end
-    rescue StandardError
-      nil
-    end
-
-    def self.detect_disk
-      output = `df -B1 / 2>/dev/null`.lines.last
-      return unless output
-      parts = output.split
-      total = parts[1].to_i
-      used = parts[2].to_i
-      { disk_total: total, disk_used: used, disk_usage_percent: total > 0 ? (used.to_f / total * 100).round(1) : 0 }
-    rescue StandardError
-      nil
-    end
-
-    def self.detect_processes
-      data = {}
-
-      # Puma
-      if defined?(Puma) && Puma.respond_to?(:stats)
-        stats = Puma.stats_hash rescue {}
-        data[:puma_workers] = stats[:workers]&.size || 0
-        data[:puma_threads] = stats[:workers]&.sum { |w| w[:last_status]&.dig(:max_threads) || 0 } || 0
-      end
-
-      # Sidekiq
-      if defined?(Sidekiq)
-        require "sidekiq/api"
-        stats = Sidekiq::Stats.new
-        data[:sidekiq_processed] = stats.processed
-        data[:sidekiq_failed] = stats.failed
-        data[:sidekiq_enqueued] = stats.enqueued
-        data[:sidekiq_workers] = Sidekiq::ProcessSet.new.size rescue 0
-      end
-
-      data
-    rescue StandardError
-      {}
-    end
-
-    def self.detect_uptime
-      if File.exist?("/proc/uptime")
-        File.read("/proc/uptime").split.first.to_f
-      end
-    rescue StandardError
-      nil
-    end
-  end
-end