rails_nexus 2.0.6 → 2.1.2

data/app/models/rails_nexus/backup.rb

@@ -4,7 +4,7 @@ module RailsNexus
   class Backup < BaseRecord
     self.table_name = "rails_nexus_backups"
 
-    validates :model_name, presence: true
+    validates :config_name, presence: true
     validates :status, presence: true, inclusion: { in: %w[running success failed] }
     validates :started_at, presence: true
 
@@ -12,13 +12,13 @@ module RailsNexus
     scope :successful, -> { where(status: "success") }
     scope :failed, -> { where(status: "failed") }
     scope :running, -> { where(status: "running") }
-    scope :by_model, ->(name) { where(model_name: name) }
+    scope :by_config, ->(name) { where(config_name: name) }
     scope :latest_first, -> { order(started_at: :desc) }
 
     # Start tracking a backup run
-    def self.start!(model_name:, triggered_by: "system")
+    def self.start!(config_name:, triggered_by: "system")
       create!(
-        model_name: model_name,
+        config_name: config_name,
         status: "running",
         triggered_by: triggered_by,
         started_at: Time.current
@@ -47,25 +47,25 @@ module RailsNexus
     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")
+    def self.success_rate(config_name:, days: 7)
+      records = by_config(config_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
+      configs = RailsNexus::BackupConfig.pluck(:name)
+      results = configs.map do |config_name|
+        latest = by_config(config_name).successful.latest_first.first
         age_hours = latest ? ((Time.current - latest.started_at) / 3600).round(1) : nil
 
         {
-          model_name: model_name,
+          config_name: config_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),
+          success_rate: success_rate(config_name: config_name),
           last_file_size: latest&.file_size
         }
       end

data/app/models/rails_nexus/backup_config.rb

@@ -13,6 +13,7 @@ module RailsNexus
     attribute :enabled,            :boolean, default: true
     attribute :compress,           :boolean, default: true
     attribute :encrypted,          :boolean, default: false
+    attribute :encrypt_base64,     :boolean, default: false
     attribute :rsync_enabled,      :boolean, default: false
     attribute :rsync_mirror,       :boolean, default: false
     attribute :notify_on_success,  :boolean, default: true
@@ -25,6 +26,10 @@ module RailsNexus
     attribute :split_chunks,       :boolean, default: false
 
     validates :name, presence: true, uniqueness: true
+    validates :name, format: {
+      with: /\A[a-zA-Z0-9_$][a-zA-Z0-9_$.-]*\z/,
+      message: "may contain only letters, numbers, dots, underscores, dollar signs, and hyphens"
+    }
     validates :database_name, presence: true, if: -> { adapter != "redis" }
     validates :adapter, presence: true, inclusion: { in: ADAPTERS }
     validates :storage_path, presence: true
@@ -37,6 +42,11 @@ module RailsNexus
     validates :s3_secret_key, presence: true, if: :s3_enabled?
     validates :gpg_password, presence: true, if: :gpg_enabled?
     validates :email_to, presence: true, if: :email_notify?
+    validates :port, :rsync_port,
+      numericality: { only_integer: true, greater_than: 0, less_than_or_equal_to: 65_535 },
+      allow_nil: true
+    validate :database_identifier_is_safe
+    validate :remote_sync_values_are_safe
 
     scope :enabled,  -> { where(enabled: true) }
     scope :disabled, -> { where(enabled: false) }
@@ -113,11 +123,15 @@ module RailsNexus
 
     # ─── Stats ─────────────────────────────────────────────────────
     def recent_backups(limit: 10)
-      RailsNexus::Backup.where(model_name: name).order(started_at: :desc).limit(limit)
+      RailsNexus::Backup.where(config_name: name).order(started_at: :desc).limit(limit)
+    end
+
+    def last_failure
+      RailsNexus::Backup.where(config_name: name, status: "failed").order(started_at: :desc).first
     end
 
     def stats
-      backups = RailsNexus::Backup.where(model_name: name)
+      backups = RailsNexus::Backup.where(config_name: name)
       recent = backups.where("started_at >= ?", 7.days.ago)
       {
         total: backups.count,
@@ -134,6 +148,28 @@ module RailsNexus
 
     private
 
+    def database_identifier_is_safe
+      return if database_name.blank? || sqlite?
+
+      unless database_name.match?(/\A[a-zA-Z0-9_$][a-zA-Z0-9_$.-]*\z/) && !database_name.include?("..")
+        errors.add(:database_name, "contains unsupported characters")
+      end
+    end
+
+    def remote_sync_values_are_safe
+      return unless rsync_enabled?
+
+      unless rsync_host.to_s.match?(/\A[a-zA-Z0-9](?:[a-zA-Z0-9.-]*[a-zA-Z0-9])?\z/)
+        errors.add(:rsync_host, "is not a valid hostname")
+      end
+      unless rsync_user.to_s.match?(/\A[a-zA-Z0-9_][a-zA-Z0-9_.-]*\z/)
+        errors.add(:rsync_user, "contains unsupported characters")
+      end
+      unless rsync_path.to_s.start_with?("/") && !rsync_path.to_s.match?(/[\0\r\n]/)
+        errors.add(:rsync_path, "must be an absolute remote path")
+      end
+    end
+
     def dump_extension
       parts = ["sql"]
       parts << "gz" if compress? && !bzip2_compress?

data/app/models/rails_nexus/logged_exception.rb

@@ -24,14 +24,14 @@ module RailsNexus
     scope :unassigned, -> { where(assigned_to: [nil, ""]) }
     scope :active, -> { not_muted.not_snoozed }
 
-    def self.ransackable_attributes(auth_object = nil)
+    def self.ransackable_attributes(_auth_object = nil)
       %w[action_name backtrace cause_chain controller_name created_at device_type environment
          assigned_to comments_count exception_class fingerprint id instance_variables local_variables
          message muted occurrence_count platform platform_version priority remote_ip request
          snoozed_until system_health updated_at user_agent user_id user_info]
     end
 
-    def self.ransackable_associations(auth_object = nil)
+    def self.ransackable_associations(_auth_object = nil)
       []
     end
 
@@ -299,8 +299,8 @@ module RailsNexus
 
           # Look for ActiveRecord collection iteration patterns:
           # e.g., .each, .map, .find_each near ActiveRecord calls
-          has_iteration = app_lines.any? { |l| l.match?(/\.each|\.map|\.select|\.reject|\.flat_map|\.find_each/) }
-          has_ar_call = app_lines.any? { |l| l.match?(/ActiveRecord|_callback|association|belongs_to|has_many|load_target|reload/) }
+          app_lines.any? { |l| l.match?(/\.each|\.map|\.select|\.reject|\.flat_map|\.find_each/) }
+          app_lines.any? { |l| l.match?(/ActiveRecord|_callback|association|belongs_to|has_many|load_target|reload/) }
 
           # Also detect: repeated similar backtrace across multiple exceptions of same class
           fingerprint = backtrace_fingerprint(app_lines)
@@ -435,9 +435,11 @@ module RailsNexus
       end
 
       begin
+        stdout, _stderr, status = Open3.capture3("ps", "-o", "rss=,vsz=", "-p", Process.pid.to_s)
+        memory = status.success? ? stdout.split.map(&:to_i) : []
         health[:memory] = {
-          rss_kb: `ps -o rss= -p #{Process.pid} 2>/dev/null`.strip.to_i,
-          vsz_kb: `ps -o vsz= -p #{Process.pid} 2>/dev/null`.strip.to_i
+          rss_kb: memory[0] || 0,
+          vsz_kb: memory[1] || 0
         }
       rescue StandardError
         health[:memory] = { error: "unable to capture" }
@@ -495,17 +497,28 @@ module RailsNexus
       if request.is_a?(String)
         write_attribute :request, request
       elsif request.respond_to?(:env) && request.env.is_a?(Hash)
-        max = request.env.keys.max { |a, b| a.length <=> b.length }
-        env = request.env.keys.sort.inject [] do |memo, key|
-          memo << "* %-*s: %s" % [max.length, key, request.env[key].to_s.strip]
+        filtered_env = RailsNexus.filter_sensitive_data(request.env)
+        keys = filtered_env.keys.map(&:to_s).sort
+        max_length = keys.map(&:length).max || 0
+        env = keys.each_with_object([]) do |key, memo|
+          value = filtered_env[key] || filtered_env[key.to_sym]
+          memo << ("* %-*s: %s" % [max_length, key, value.to_s.strip])
         end
         write_attribute(:environment, (env << "* Process: #{$$}" << "* Server : #{self.class.host_name}").join("\n"))
 
         method_str = request.respond_to?(:get?) && request.get? ? "" : " #{request.respond_to?(:method) ? request.method.to_s.upcase : "GET"}"
+        parameters = request.respond_to?(:parameters) ? RailsNexus.filter_sensitive_data(request.parameters) : {}
+        request_path = if request.respond_to?(:path)
+                         request.path
+                       elsif request.respond_to?(:fullpath)
+                         request.fullpath.to_s.split("?", 2).first
+                       else
+                         "/"
+                       end
         write_attribute(:request, [
-          "* URL:#{method_str} #{request.respond_to?(:protocol) ? request.protocol : "http://"}#{request.respond_to?(:env) ? request.env["HTTP_HOST"] : "localhost"}#{request.respond_to?(:fullpath) ? request.fullpath : "/"}",
+          "* URL:#{method_str} #{request.respond_to?(:protocol) ? request.protocol : "http://"}#{filtered_env["HTTP_HOST"] || "localhost"}#{request_path}",
           "* Format: #{request.respond_to?(:format) ? request.format.to_s : "html"}",
-          "* Parameters: #{request.respond_to?(:parameters) ? request.parameters.inspect : "{}"}",
+          "* Parameters: #{parameters.inspect}",
           "* Rails Root: #{rails_root}"
         ].join("\n"))
       else
@@ -545,10 +558,11 @@ module RailsNexus
 
     # Build hourly time series of error counts
     def self.build_time_series(days: 30)
+      days = (Integer(days, exception: false) || 30).clamp(1, 90)
       start_time = days.days.ago.beginning_of_hour
+      bucket = RailsNexus::DatabaseAdapter.time_bucket_expression
       raw = where("created_at >= ?", start_time)
-        .group(Arel.sql("DATE_FORMAT(created_at, '%Y-%m-%d %H:00')"))
-        .order(Arel.sql("DATE_FORMAT(created_at, '%Y-%m-%d %H:00')"))
+        .group(Arel.sql(bucket))
         .count
 
       # Fill gaps with zeros