ruby_cms 0.2.1.0 → 1.0.0

data/lib/generators/ruby_cms/templates/routes/system_health.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+get "system_health", to: "system_health#index", as: :system_health

data/lib/generators/ruby_cms/templates/routes/trash.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+get    "trash",                      to: "trash#index",   as: :trash
+post   "trash/:model/:id/restore",   to: "trash#restore", as: :restore_trash
+delete "trash/:model/:id",           to: "trash#destroy", as: :purge_trash

data/lib/generators/ruby_cms/templates/routes/users.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+resources :users, only: %i[index show create destroy] do
+  member { delete :sessions, action: :destroy_sessions }
+  collection { delete :bulk_delete }
+  resources :permissions, only: %i[index create destroy],
+                          controller: "user_permissions", path: "permissions" do
+    collection { delete :bulk_delete }
+  end
+end

data/lib/generators/ruby_cms/templates/routes/visual_editor.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+get   "visual_editor",               to: "visual_editor#index",          as: :visual_editor
+get   "visual_editor/page_preview",  to: "visual_editor#page_preview",   as: :visual_editor_page_preview
+patch "visual_editor/quick_update",  to: "visual_editor#quick_update",   as: :visual_editor_quick_update

data/lib/generators/ruby_cms/templates/services/admin/health_check.rb

@@ -0,0 +1,362 @@
+# frozen_string_literal: true
+
+module Admin
+  # Aggregates a read-only snapshot of system health for the admin dashboard.
+  #
+  # Every probe is independently rescued so one broken check cannot take down
+  # the page. Result is cached for 30 seconds because the page polls.
+  #
+  # TODO: model `HealthIncident` is not in scope yet — `:incidents` returns [].
+  class HealthCheck
+    CACHE_KEY = "admin.health"
+    CACHE_TTL = 30.seconds
+
+    # Latency thresholds (ms) for status grading on the Postgres ping.
+    DB_WARN_MS = 100
+    DB_DOWN_MS = 500
+
+    def self.call
+      Rails.cache.fetch(CACHE_KEY, expires_in: CACHE_TTL) { new.call }
+    end
+
+    def call
+      services = [
+        web_service,
+        db_service,
+        redis_service,
+        sidekiq_service,
+        storage_service,
+        cdn_service,
+        smtp_service
+      ].compact
+
+      {
+        overall: worst_status(services.map { |s| s[:status] }),
+        uptime_days: uptime_days,
+        deploy: deploy_info,
+        services: services,
+        queues: sidekiq_queues,
+        db: db_info,
+        incidents: incidents
+      }
+    end
+
+    private
+
+    # ---------------------------------------------------------------------------
+    # Service probes
+    # ---------------------------------------------------------------------------
+
+    def web_service
+      meta =
+        begin
+          puma_meta
+        rescue StandardError => e
+          Rails.logger.warn("[Health] web meta #{e.class}: #{e.message}")
+          "puma"
+        end
+
+      { id: "web", label: "Web server", status: :ok, meta: meta, lat: 0, note: nil }
+    end
+
+    def puma_meta
+      return "puma" unless defined?(Puma)
+
+      config = Puma.cli_config&.options if Puma.respond_to?(:cli_config)
+      workers = config&.dig(:workers) || ENV["WEB_CONCURRENCY"].to_i
+      threads = config&.dig(:max_threads) || ENV.fetch("RAILS_MAX_THREADS", 5).to_i
+      parts = []
+      parts << "#{workers} puma workers" if workers.positive?
+      parts << "#{threads} threads" if threads.positive?
+      parts.any? ? parts.join(" · ") : "puma"
+    end
+
+    def db_service
+      lat_ms, error = measure_ms { ActiveRecord::Base.connection.execute("SELECT 1") }
+
+      status =
+        if error
+          :down
+        elsif lat_ms >= DB_DOWN_MS
+          :down
+        elsif lat_ms >= DB_WARN_MS
+          :warn
+        else
+          :ok
+        end
+
+      meta =
+        begin
+          conn = ActiveRecord::Base.connection
+          db_name = conn.current_database
+          pool = ActiveRecord::Base.connection_pool
+          "#{db_name} · #{pool.connections.size} connections / #{pool.size}"
+        rescue StandardError => e
+          Rails.logger.warn("[Health] db meta #{e.class}: #{e.message}")
+          "postgresql"
+        end
+
+      { id: "db", label: "PostgreSQL", status: status, meta: meta, lat: lat_ms, note: error&.message }
+    end
+
+    def redis_service
+      return nil unless defined?(Sidekiq)
+
+      lat_ms, error = measure_ms { Sidekiq.redis { |r| r.ping } }
+      meta =
+        begin
+          info = Sidekiq.redis { |r| r.info }
+          used = info["used_memory_human"] || "?"
+          max  = info["maxmemory_human"].presence || "∞"
+          "#{used} / #{max}"
+        rescue StandardError => e
+          Rails.logger.warn("[Health] redis meta #{e.class}: #{e.message}")
+          "redis"
+        end
+
+      status = if error
+                 :down
+      else
+                 (lat_ms >= 50 ? :warn : :ok)
+      end
+      { id: "redis", label: "Redis", status: status, meta: meta, lat: lat_ms, note: error&.message }
+    end
+
+    def sidekiq_service
+      return nil unless defined?(Sidekiq)
+
+      processes = 0
+      retries = 0
+      dead = 0
+      enqueued = 0
+
+      begin
+        processes = ::Sidekiq::ProcessSet.new.size if defined?(::Sidekiq::ProcessSet)
+        retries   = ::Sidekiq::RetrySet.new.size   if defined?(::Sidekiq::RetrySet)
+        dead      = ::Sidekiq::DeadSet.new.size    if defined?(::Sidekiq::DeadSet)
+        enqueued = ::Sidekiq::Queue.all.sum(&:size) if defined?(::Sidekiq::Queue)
+      rescue StandardError => e
+        Rails.logger.warn("[Health] sidekiq probe #{e.class}: #{e.message}")
+        return { id: "sidekiq", label: "Sidekiq", status: :down, meta: "Niet bereikbaar", lat: 0, note: e.message }
+      end
+
+      meta = "#{processes} processes · #{retries} retries · #{dead} dead · #{enqueued} wachten"
+
+      status =
+        if processes.zero?
+          :down
+        elsif retries.positive? || dead.positive?
+          :warn
+        else
+          :ok
+        end
+
+      note = retries.positive? ? "#{retries} jobs in retry queue" : nil
+      { id: "sidekiq", label: "Sidekiq", status: status, meta: meta, lat: 0, note: note }
+    end
+
+    def storage_service
+      configured = Rails.application.config.active_storage.service
+      return nil unless configured
+
+      begin
+        if configured.to_s == "local"
+          dir = Rails.root.join("storage")
+          if dir.exist?
+            { id: "storage", label: "Active Storage", status: :ok, meta: "local · #{configured}", lat: 0, note: nil }
+          else
+            { id: "storage", label: "Active Storage", status: :warn, meta: "local · directory missing", lat: 0, note: "storage/ directory ontbreekt" }
+          end
+        else
+          lat_ms, error = measure_ms { ActiveStorage::Blob.service.exist?("__healthcheck__") }
+          status = error ? :down : :ok
+          { id: "storage", label: "Active Storage", status: status, meta: configured.to_s, lat: lat_ms, note: error&.message }
+        end
+      rescue StandardError => e
+        Rails.logger.warn("[Health] storage #{e.class}: #{e.message}")
+        { id: "storage", label: "Active Storage", status: :warn, meta: configured.to_s, lat: 0, note: e.message }
+      end
+    end
+
+    def cdn_service
+      host = ENV["CDN_HOST"].presence || Rails.application.config.action_controller&.asset_host
+      return nil if host.blank?
+
+      { id: "cdn", label: "CDN", status: :ok, meta: host.to_s, lat: 0, note: nil }
+    end
+
+    def smtp_service
+      settings = begin
+        ActionMailer::Base.smtp_settings
+      rescue StandardError
+        {}
+      end
+      host = settings&.dig(:address)
+
+      return { id: "mail", label: "SMTP", status: :warn, meta: "—", lat: 0, note: "Niet geconfigureerd" } if host.blank?
+
+      port = (settings[:port] || 25).to_i
+      lat_ms, error = measure_ms do
+        require "net/smtp"
+        smtp = Net::SMTP.new(host, port)
+        smtp.open_timeout = 3
+        smtp.read_timeout = 3
+        smtp.start(settings[:domain] || "localhost") do |s|
+          s.helo(settings[:domain] || "localhost")
+        end
+      end
+
+      status = error ? :down : :ok
+      meta = "#{host}:#{port}"
+      { id: "mail", label: "SMTP", status: status, meta: meta, lat: lat_ms, note: error&.message }
+    end
+
+    # ---------------------------------------------------------------------------
+    # Deploy / uptime
+    # ---------------------------------------------------------------------------
+
+    def deploy_info
+      {
+        version: safe_const("Rubycms::VERSION") || safe_const("RubyCms::VERSION") || "unknown",
+        sha: deploy_sha,
+        deployed_at: deployed_at,
+        ruby: RUBY_VERSION,
+        rails: Rails::VERSION::STRING,
+        rubycms: safe_const("RubyCms::VERSION") || "dev"
+      }
+    end
+
+    def deploy_sha
+      ENV["GIT_SHA"].presence || begin
+        File.read(Rails.root.join("REVISION")).strip
+      rescue StandardError
+        "dev"
+      end
+    end
+
+    def deployed_at
+      File.mtime(Rails.root.join("REVISION"))
+    rescue StandardError
+      begin
+        if Rails.application.config.cache_classes
+          File.mtime(Rails.root.join("Gemfile.lock"))
+        else
+          Time.current
+        end
+      rescue StandardError
+        Time.current
+      end
+    end
+
+    def uptime_days
+      pid_file = Rails.root.join("tmp/pids/server.pid")
+      ((Time.current - File.mtime(pid_file)).to_i / 86_400.0).round(2)
+    rescue StandardError
+      0.0
+    end
+
+    # ---------------------------------------------------------------------------
+    # Sidekiq queues
+    # ---------------------------------------------------------------------------
+
+    def sidekiq_queues
+      return [] unless defined?(Sidekiq) && defined?(::Sidekiq::Queue)
+
+      ::Sidekiq::Queue.all.map do |q|
+        { name: q.name, enq: q.size, busy: 0, latency: q.latency.to_i }
+      end
+    rescue StandardError => e
+      Rails.logger.warn("[Health] queues #{e.class}: #{e.message}")
+      []
+    end
+
+    # ---------------------------------------------------------------------------
+    # Database info
+    # ---------------------------------------------------------------------------
+
+    def db_info
+      { size_mb: db_size_mb, tables: db_tables }
+    end
+
+    def db_size_mb
+      result = ActiveRecord::Base.connection.execute(
+        "SELECT pg_database_size(current_database()) AS s"
+      ).first
+      (result["s"].to_i / 1024.0 / 1024.0).round
+    rescue StandardError => e
+      Rails.logger.warn("[Health] db_size #{e.class}: #{e.message}")
+      0
+    end
+
+    def db_tables
+      conn = ActiveRecord::Base.connection
+      conn.tables.first(20).map do |name|
+        rows =
+          begin
+            row = conn.exec_query(
+              "SELECT reltuples::bigint AS rows FROM pg_class WHERE relname = $1",
+              "health",
+              [ name ]
+            ).first
+            row ? row["rows"].to_i : 0
+          rescue StandardError => e
+            Rails.logger.warn("[Health] db row count for #{name} #{e.class}: #{e.message}")
+            0
+          end
+
+        indexes =
+          begin
+            conn.indexes(name).size
+          rescue StandardError => e
+            Rails.logger.warn("[Health] db indexes for #{name} #{e.class}: #{e.message}")
+            0
+          end
+
+        { name:, rows:, indexes: }
+      end
+    rescue StandardError => e
+      Rails.logger.warn("[Health] db_tables #{e.class}: #{e.message}")
+      []
+    end
+
+    # ---------------------------------------------------------------------------
+    # Incidents — out of scope (no model yet)
+    # ---------------------------------------------------------------------------
+
+    # TODO: introduce a HealthIncident model and replace this stub.
+    def incidents
+      []
+    end
+
+    # ---------------------------------------------------------------------------
+    # Helpers
+    # ---------------------------------------------------------------------------
+
+    def measure_ms
+      error = nil
+      started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      begin
+        yield
+      rescue StandardError => e
+        Rails.logger.warn("[Health] probe #{e.class}: #{e.message}")
+        error = e
+      end
+      elapsed_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000).round
+      [ elapsed_ms, error ]
+    end
+
+    STATUS_RANK = { ok: 0, warn: 1, down: 2 }.freeze
+
+    def worst_status(statuses)
+      return :ok if statuses.empty?
+
+      statuses.compact.max_by { |s| STATUS_RANK[s] || 0 } || :ok
+    end
+
+    def safe_const(name)
+      Object.const_get(name)
+    rescue NameError
+      nil
+    end
+  end
+end