rails_nexus 2.0.0

data/app/models/rails_nexus/logged_exception_n1.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module RailsNexus
+  module LoggedExceptionN1
+    # N+1 Query Pattern Detection
+    # Analyzes breadcrumbs for repeated similar SQL queries
+    def self.n_plus_one_patterns(limit: 20)
+      patterns = {}
+
+      LoggedException.where.not(breadcrumbs: nil)
+        .where("created_at >= ?", 7.days.ago)
+        .order(created_at: :desc)
+        .limit(500)
+        .find_each do |exception|
+          crumbs = parse_breadcrumbs(exception.breadcrumbs)
+          next unless crumbs.is_a?(Array)
+
+          sql_crumbs = crumbs.select { |c| c[:type] == "sql" }
+          next if sql_crumbs.empty?
+
+          sql_crumbs.group_by { |c| sql_fingerprint(c[:name]) }.each do |fingerprint, queries|
+            next if queries.length < 3
+
+            table = extract_table_name(queries.first[:name])
+            patterns[fingerprint] ||= {
+              fingerprint: fingerprint,
+              sql_sample: queries.first[:name]&.truncate(200),
+              table: table,
+              count: 0,
+              exception_ids: [],
+              avg_duration: 0
+            }
+            patterns[fingerprint][:count] += queries.length
+            patterns[fingerprint][:exception_ids] << exception.id
+            durations = queries.map { |q| q[:duration] }.compact
+            if durations.any?
+              patterns[fingerprint][:avg_duration] = (durations.sum / durations.size).round(2)
+            end
+          end
+        end
+
+      patterns.values
+        .sort_by { |p| -p[:count] }
+        .first(limit)
+        .map { |p| p.merge(exception_ids: p[:exception_ids].uniq.first(5)) }
+    end
+
+    def self.n_plus_one_summary
+      patterns = n_plus_one_patterns(limit: 100)
+      {
+        total_patterns: patterns.sum { |p| p[:count] },
+        unique_patterns: patterns.size,
+        worst_pattern: patterns.first,
+        top_tables: patterns.group_by { |p| p[:table] }
+          .transform_values { |ps| ps.sum { |p| p[:count] } }
+          .sort_by { |_, count| -count }
+          .first(5)
+          .map { |table, count| { table: table, count: count } }
+      }
+    end
+
+    def self.parse_breadcrumbs(data)
+      return data if data.is_a?(Array)
+      JSON.parse(data, symbolize_names: true) rescue []
+    end
+
+    def self.sql_fingerprint(sql)
+      return "" if sql.blank?
+      sql.strip
+        .gsub(/\s+/, " ")
+        .gsub(/\d+/, "?")
+        .gsub(/'[^']*'/, "'?'")
+        .gsub(/\b\d+\.\d+\b/, "?")
+        .gsub(/\b0x[0-9a-f]+\b/i, "?")
+        .strip
+    end
+
+    def self.extract_table_name(sql)
+      return "unknown" if sql.blank?
+      if sql =~ /(?:FROM|INTO|UPDATE|JOIN)\s+[`"']?(\w+)[`"']?/i
+        $1.downcase
+      else
+        "unknown"
+      end
+    end
+  end
+end

data/app/models/rails_nexus/metric.rb

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

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

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

data/app/models/rails_nexus/webhook_delivery.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RailsNexus
+  class WebhookDelivery < BaseRecord
+    self.table_name = "rails_nexus_webhook_deliveries"
+
+    STATUSES = %w[pending success failed].freeze
+
+    validates :url, 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 :last_24h, -> { where("created_at >= ?", 24.hours.ago) }
+    scope :last_7d, -> { where("created_at >= ?", 7.days.ago) }
+
+    # Log a successful delivery
+    def self.log_success!(url:, request_body:, response_code:, response_body:, duration:, event_type: nil)
+      create!(
+        url: url,
+        status: "success",
+        request_body: request_body,
+        response_code: response_code,
+        response_body: response_body&.truncate(1000),
+        duration: duration,
+        event_type: event_type
+      )
+    end
+
+    # Log a failed delivery
+    def self.log_failure!(url:, request_body:, error_message:, response_code: nil, response_body: nil, duration: nil, event_type: nil)
+      create!(
+        url: url,
+        status: "failed",
+        request_body: request_body,
+        response_code: response_code,
+        response_body: response_body&.truncate(1000),
+        error_message: error_message,
+        duration: duration,
+        event_type: event_type
+      )
+    end
+
+    # Stats summary
+    def self.summary
+      {
+        total: count,
+        successful: successful.count,
+        failed: failed.count,
+        last_delivery: recent.first
+      }
+    end
+
+    def failed?
+      status == "failed"
+    end
+
+    def success?
+      status == "success"
+    end
+  end
+end