solid_queue_tui 0.1.1 → 0.1.3

data/lib/solid_queue_tui/components/job_table.rb

@@ -3,6 +3,8 @@
 module SolidQueueTui
   module Components
     class JobTable
+      include FormattingHelpers
+
       STATUS_COLORS = {
         "ready" => :green,
         "claimed" => :yellow,
@@ -12,15 +14,18 @@ module SolidQueueTui
         "completed" => :dark_gray,
         "active" => :green,
         "paused" => :red,
+        "delayed" => :red,
+        "pending" => :dark_gray,
         "unknown" => :white
       }.freeze
 
-      def initialize(tui, title:, columns:, rows:, selected_row: nil, empty_message: "No data")
+      def initialize(tui, title:, columns:, rows:, selected_row: nil, total_count: nil, empty_message: "No data")
         @tui = tui
         @title = title
         @columns = columns
         @rows = rows
         @selected_row = selected_row
+        @total_count = total_count
         @empty_message = empty_message
       end
 
@@ -36,11 +41,17 @@ module SolidQueueTui
       private
 
       def title_text
-        text = " #{@title} [#{@rows.size}]"
+        count_text = if @total_count && @total_count > @rows.size
+                       "#{@rows.size}/#{format_number(@total_count)}"
+                     else
+                       @rows.size.to_s
+                     end
+        text = " #{@title} [#{count_text}]"
         text += "  #{@selected_row + 1}/#{@rows.size}" if @selected_row && @rows.size > 0
         text + " "
       end
 
+
       def render_table(frame, area, table_state)
         widths = @columns.map do |col|
           case col[:width]

data/lib/solid_queue_tui/data/failed_query.rb

@@ -10,109 +10,55 @@ module SolidQueueTui
         keyword_init: true
       )
 
-      def self.fetch(filter: nil, limit: 200)
-        conn = ActiveRecord::Base.connection
+      def self.fetch(filter: nil, queue: nil, limit: 100, offset: 0)
+        scope = SolidQueue::FailedExecution.joins(:job).includes(:job)
+        scope = scope.merge(SolidQueue::Job.where("class_name LIKE ?", "%#{filter}%")) if filter.present?
+        scope = scope.merge(SolidQueue::Job.where(queue_name: queue)) if queue.present?
+        scope = scope.order(created_at: :desc).offset(offset).limit(limit)
 
-        sql = <<~SQL
-          SELECT
-            fe.id,
-            fe.job_id,
-            j.queue_name,
-            j.class_name,
-            j.priority,
-            j.active_job_id,
-            j.arguments,
-            j.created_at AS job_created_at,
-            fe.error,
-            fe.created_at AS failed_at
-          FROM solid_queue_failed_executions fe
-          JOIN solid_queue_jobs j ON j.id = fe.job_id
-        SQL
-
-        if filter && !filter.empty?
-          sql += " WHERE j.class_name LIKE #{conn.quote("%#{filter}%")}"
-        end
-
-        sql += " ORDER BY fe.created_at DESC LIMIT #{limit.to_i}"
-
-        rows = conn.select_all(sql)
-        rows.map do |row|
-          error = parse_json(row["error"])
-
-          FailedJob.new(
-            id: row["id"].to_i,
-            job_id: row["job_id"].to_i,
-            queue_name: row["queue_name"],
-            class_name: row["class_name"],
-            priority: row["priority"].to_i,
-            error_class: error["exception_class"] || error["class"] || "Unknown",
-            error_message: error["message"] || "No message",
-            backtrace: error["backtrace"] || [],
-            active_job_id: row["active_job_id"],
-            arguments: parse_json(row["arguments"]),
-            failed_at: parse_time(row["failed_at"]),
-            created_at: parse_time(row["job_created_at"])
-          )
-        end
+        scope.map { |fe| build_failed_job(fe) }
       rescue => e
+        Rails.logger.tagged("SQTUI") { Rails.logger.error("FailedQuery.fetch error: #{e.class}: #{e.message}") } if defined?(Rails) && Rails.logger
         []
       end
 
-      def self.fetch_one(id)
-        conn = ActiveRecord::Base.connection
-
-        row = conn.select_one(<<~SQL)
-          SELECT
-            fe.id,
-            fe.job_id,
-            j.queue_name,
-            j.class_name,
-            j.priority,
-            j.active_job_id,
-            j.arguments,
-            j.created_at AS job_created_at,
-            fe.error,
-            fe.created_at AS failed_at
-          FROM solid_queue_failed_executions fe
-          JOIN solid_queue_jobs j ON j.id = fe.job_id
-          WHERE fe.id = #{conn.quote(id.to_i)}
-        SQL
-
-        return nil unless row
+      def self.count(filter: nil, queue: nil)
+        scope = SolidQueue::FailedExecution.joins(:job)
+        scope = scope.merge(SolidQueue::Job.where("class_name LIKE ?", "%#{filter}%")) if filter.present?
+        scope = scope.merge(SolidQueue::Job.where(queue_name: queue)) if queue.present?
+        scope.count
+      rescue => e
+        Rails.logger.tagged("SQTUI") { Rails.logger.error("FailedQuery.count error: #{e.class}: #{e.message}") } if defined?(Rails) && Rails.logger
+        0
+      end
 
-        error = parse_json(row["error"])
+      def self.fetch_one(id)
+        fe = SolidQueue::FailedExecution.includes(:job).find_by(id: id)
+        return nil unless fe
 
-        FailedJob.new(
-          id: row["id"].to_i,
-          job_id: row["job_id"].to_i,
-          queue_name: row["queue_name"],
-          class_name: row["class_name"],
-          priority: row["priority"].to_i,
-          error_class: error["exception_class"] || error["class"] || "Unknown",
-          error_message: error["message"] || "No message",
-          backtrace: error["backtrace"] || [],
-          active_job_id: row["active_job_id"],
-          arguments: parse_json(row["arguments"]),
-          failed_at: parse_time(row["failed_at"]),
-          created_at: parse_time(row["job_created_at"])
-        )
+        build_failed_job(fe)
       rescue => e
         nil
       end
 
-      private_class_method def self.parse_json(value)
-        return {} if value.nil?
-        value.is_a?(Hash) || value.is_a?(Array) ? value : JSON.parse(value.to_s)
-      rescue JSON::ParserError
-        {}
-      end
-
-      private_class_method def self.parse_time(value)
-        return nil if value.nil?
-        value.is_a?(Time) ? value : Time.parse(value.to_s)
-      rescue
-        nil
+      def self.build_failed_job(fe)
+        job = fe.job
+        FailedJob.new(
+          id: fe.id,
+          job_id: job.id,
+          queue_name: job.queue_name,
+          class_name: job.class_name,
+          priority: job.priority,
+          error_class: fe.exception_class || "Unknown",
+          error_message: fe.message || "No message",
+          backtrace: fe.backtrace || [],
+          active_job_id: job.active_job_id,
+          arguments: job.arguments,
+          failed_at: fe.created_at,
+          created_at: job.created_at
+        )
       end
+      private_class_method :build_failed_job
     end
   end
 end

data/lib/solid_queue_tui/data/jobs_query.rb

@@ -11,167 +11,165 @@ module SolidQueueTui
         keyword_init: true
       )
 
-      def self.fetch(status:, filter: nil, queue: nil, limit: 200)
+      def self.fetch(status:, filter: nil, queue: nil, limit: 100, offset: 0)
         case status
-        when "claimed"   then fetch_claimed(filter: filter, queue: queue, limit: limit)
-        when "blocked"   then fetch_blocked(filter: filter, queue: queue, limit: limit)
-        when "scheduled" then fetch_scheduled(filter: filter, queue: queue, limit: limit)
-        when "completed" then fetch_finished(filter: filter, queue: queue, limit: limit)
+        when "pending"   then fetch_pending(queue: queue, filter: filter, limit: limit, offset: offset)
+        when "claimed"   then fetch_claimed(filter: filter, queue: queue, limit: limit, offset: offset)
+        when "blocked"   then fetch_blocked(filter: filter, queue: queue, limit: limit, offset: offset)
+        when "scheduled" then fetch_scheduled(filter: filter, queue: queue, limit: limit, offset: offset)
+        when "completed" then fetch_finished(filter: filter, queue: queue, limit: limit, offset: offset)
         else []
         end
       rescue => e
         []
       end
 
-      def self.fetch_claimed(filter: nil, queue: nil, limit: 200)
-        conn = ActiveRecord::Base.connection
-
-        sql = <<~SQL
-          SELECT
-            j.id, j.queue_name, j.class_name, j.priority,
-            j.active_job_id, j.concurrency_key, j.created_at,
-            ce.process_id AS worker_id,
-            ce.created_at AS started_at
-          FROM solid_queue_claimed_executions ce
-          JOIN solid_queue_jobs j ON j.id = ce.job_id
-        SQL
-
-        conditions = []
-        conditions << "j.queue_name = #{conn.quote(queue)}" if queue
-        conditions << "j.class_name LIKE #{conn.quote("%#{filter}%")}" if filter && !filter.empty?
+      def self.count(status:, filter: nil, queue: nil)
+        case status
+        when "pending"   then count_pending(queue: queue, filter: filter)
+        when "claimed"   then count_scope(SolidQueue::ClaimedExecution.joins(:job), filter: filter, queue: queue)
+        when "blocked"   then count_scope(SolidQueue::BlockedExecution.joins(:job), filter: filter, queue: queue)
+        when "scheduled" then count_scope(SolidQueue::ScheduledExecution.joins(:job), filter: filter, queue: queue)
+        when "completed" then count_finished(filter: filter, queue: queue)
+        else 0
+        end
+      rescue => e
+        0
+      end
 
-        sql += " WHERE #{conditions.join(' AND ')}" unless conditions.empty?
-        sql += " ORDER BY ce.job_id ASC LIMIT #{limit.to_i}"
+      def self.fetch_pending(queue:, filter: nil, limit: 100, offset: 0)
+        scope = SolidQueue::ReadyExecution.joins(:job)
+        scope = scope.where(queue_name: queue) if queue
+        scope = apply_class_name_filter(scope, filter)
+        scope = scope.order(priority: :asc, job_id: :asc).offset(offset).limit(limit)
 
-        conn.select_all(sql).map do |row|
+        scope.includes(:job).map do |re|
+          job = re.job
           Job.new(
-            id: row["id"].to_i,
-            queue_name: row["queue_name"],
-            class_name: row["class_name"],
-            priority: row["priority"].to_i,
-            status: "claimed",
-            active_job_id: row["active_job_id"],
-            concurrency_key: row["concurrency_key"],
-            created_at: parse_time(row["created_at"]),
-            worker_id: row["worker_id"]&.to_i,
-            started_at: parse_time(row["started_at"])
+            id: job.id,
+            queue_name: job.queue_name,
+            class_name: job.class_name,
+            priority: job.priority,
+            status: "pending",
+            active_job_id: job.active_job_id,
+            arguments: job.arguments,
+            scheduled_at: job.scheduled_at,
+            created_at: job.created_at
           )
         end
       end
 
-      def self.fetch_blocked(filter: nil, queue: nil, limit: 200)
-        conn = ActiveRecord::Base.connection
+      def self.count_pending(queue:, filter: nil)
+        scope = SolidQueue::ReadyExecution.joins(:job)
+        scope = scope.where(queue_name: queue) if queue
+        scope = apply_class_name_filter(scope, filter)
+        scope.count
+      end
 
-        sql = <<~SQL
-          SELECT
-            j.id, j.queue_name, j.class_name, j.priority,
-            j.active_job_id, j.concurrency_key, j.created_at,
-            be.expires_at,
-            be.created_at AS blocked_since
-          FROM solid_queue_blocked_executions be
-          JOIN solid_queue_jobs j ON j.id = be.job_id
-        SQL
+      def self.fetch_claimed(filter: nil, queue: nil, limit: 100, offset: 0)
+        scope = SolidQueue::ClaimedExecution.joins(:job)
+        scope = scope.merge(SolidQueue::Job.where(queue_name: queue)) if queue
+        scope = apply_class_name_filter(scope, filter)
+        scope = scope.order(job_id: :asc).offset(offset).limit(limit)
 
-        conditions = []
-        conditions << "j.queue_name = #{conn.quote(queue)}" if queue
-        conditions << "j.class_name LIKE #{conn.quote("%#{filter}%")}" if filter && !filter.empty?
+        scope.includes(:job).map do |ce|
+          job = ce.job
+          Job.new(
+            id: job.id,
+            queue_name: job.queue_name,
+            class_name: job.class_name,
+            priority: job.priority,
+            status: "claimed",
+            active_job_id: job.active_job_id,
+            concurrency_key: job.concurrency_key,
+            created_at: job.created_at,
+            worker_id: ce.process_id,
+            started_at: ce.created_at
+          )
+        end
+      end
 
-        sql += " WHERE #{conditions.join(' AND ')}" unless conditions.empty?
-        sql += " ORDER BY be.job_id ASC LIMIT #{limit.to_i}"
+      def self.fetch_blocked(filter: nil, queue: nil, limit: 100, offset: 0)
+        scope = SolidQueue::BlockedExecution.joins(:job)
+        scope = scope.merge(SolidQueue::Job.where(queue_name: queue)) if queue
+        scope = apply_class_name_filter(scope, filter)
+        scope = scope.order(job_id: :asc).offset(offset).limit(limit)
 
-        conn.select_all(sql).map do |row|
+        scope.includes(:job).map do |be|
+          job = be.job
           Job.new(
-            id: row["id"].to_i,
-            queue_name: row["queue_name"],
-            class_name: row["class_name"],
-            priority: row["priority"].to_i,
+            id: job.id,
+            queue_name: job.queue_name,
+            class_name: job.class_name,
+            priority: job.priority,
             status: "blocked",
-            active_job_id: row["active_job_id"],
-            concurrency_key: row["concurrency_key"],
-            created_at: parse_time(row["blocked_since"]),
-            expires_at: parse_time(row["expires_at"])
+            active_job_id: job.active_job_id,
+            concurrency_key: job.concurrency_key,
+            created_at: be.created_at,
+            expires_at: be.expires_at
           )
         end
       end
 
-      # Scheduled: query from scheduled_executions JOIN jobs
-      def self.fetch_scheduled(filter: nil, queue: nil, limit: 200)
-        conn = ActiveRecord::Base.connection
-
-        sql = <<~SQL
-          SELECT
-            j.id, j.queue_name, j.class_name, j.priority,
-            j.active_job_id, j.arguments, j.created_at,
-            se.scheduled_at
-          FROM solid_queue_scheduled_executions se
-          JOIN solid_queue_jobs j ON j.id = se.job_id
-        SQL
-
-        conditions = []
-        conditions << "j.queue_name = #{conn.quote(queue)}" if queue
-        conditions << "j.class_name LIKE #{conn.quote("%#{filter}%")}" if filter && !filter.empty?
+      def self.fetch_scheduled(filter: nil, queue: nil, limit: 100, offset: 0)
+        scope = SolidQueue::ScheduledExecution.joins(:job)
+        scope = scope.merge(SolidQueue::Job.where(queue_name: queue)) if queue
+        scope = apply_class_name_filter(scope, filter)
+        scope = scope.order(scheduled_at: :asc, priority: :asc).offset(offset).limit(limit)
 
-        sql += " WHERE #{conditions.join(' AND ')}" unless conditions.empty?
-        sql += " ORDER BY se.scheduled_at ASC, se.priority ASC LIMIT #{limit.to_i}"
-
-        conn.select_all(sql).map do |row|
+        scope.includes(:job).map do |se|
+          job = se.job
           Job.new(
-            id: row["id"].to_i,
-            queue_name: row["queue_name"],
-            class_name: row["class_name"],
-            priority: row["priority"].to_i,
+            id: job.id,
+            queue_name: job.queue_name,
+            class_name: job.class_name,
+            priority: job.priority,
             status: "scheduled",
-            active_job_id: row["active_job_id"],
-            arguments: parse_json(row["arguments"]),
-            scheduled_at: parse_time(row["scheduled_at"]),
-            created_at: parse_time(row["created_at"])
+            active_job_id: job.active_job_id,
+            arguments: job.arguments,
+            scheduled_at: se.scheduled_at,
+            created_at: job.created_at
           )
         end
       end
 
-      # Finished: query from jobs WHERE finished_at IS NOT NULL
-      def self.fetch_finished(filter: nil, queue: nil, limit: 200)
-        conn = ActiveRecord::Base.connection
-
-        sql = <<~SQL
-          SELECT
-            j.id, j.queue_name, j.class_name, j.priority,
-            j.active_job_id, j.arguments, j.finished_at, j.created_at
-          FROM solid_queue_jobs j
-          WHERE j.finished_at IS NOT NULL
-        SQL
-
-        sql += " AND j.queue_name = #{conn.quote(queue)}" if queue
-        sql += " AND j.class_name LIKE #{conn.quote("%#{filter}%")}" if filter && !filter.empty?
-        sql += " ORDER BY j.finished_at DESC LIMIT #{limit.to_i}"
+      def self.fetch_finished(filter: nil, queue: nil, limit: 100, offset: 0)
+        scope = SolidQueue::Job.finished
+        scope = scope.where(queue_name: queue) if queue
+        scope = scope.where("class_name LIKE ?", "%#{filter}%") if filter.present?
+        scope = scope.order(finished_at: :desc).offset(offset).limit(limit)
 
-        conn.select_all(sql).map do |row|
+        scope.map do |job|
           Job.new(
-            id: row["id"].to_i,
-            queue_name: row["queue_name"],
-            class_name: row["class_name"],
-            priority: row["priority"].to_i,
+            id: job.id,
+            queue_name: job.queue_name,
+            class_name: job.class_name,
+            priority: job.priority,
             status: "completed",
-            active_job_id: row["active_job_id"],
-            arguments: parse_json(row["arguments"]),
-            finished_at: parse_time(row["finished_at"]),
-            created_at: parse_time(row["created_at"])
+            active_job_id: job.active_job_id,
+            arguments: job.arguments,
+            finished_at: job.finished_at,
+            created_at: job.created_at
           )
         end
       end
 
-      private_class_method def self.parse_time(value)
-        return nil if value.nil?
-        value.is_a?(Time) ? value : Time.parse(value.to_s)
-      rescue
-        nil
+      private_class_method def self.apply_class_name_filter(scope, filter)
+        return scope if filter.blank?
+        scope.merge(SolidQueue::Job.where("class_name LIKE ?", "%#{filter}%"))
+      end
+
+      private_class_method def self.count_scope(scope, filter: nil, queue: nil)
+        scope = scope.merge(SolidQueue::Job.where(queue_name: queue)) if queue
+        scope = apply_class_name_filter(scope, filter)
+        scope.count
       end
 
-      private_class_method def self.parse_json(value)
-        return nil if value.nil?
-        value.is_a?(String) ? JSON.parse(value) : value
-      rescue
-        nil
+      private_class_method def self.count_finished(filter: nil, queue: nil)
+        scope = SolidQueue::Job.finished
+        scope = scope.where(queue_name: queue) if queue
+        scope = scope.where("class_name LIKE ?", "%#{filter}%") if filter.present?
+        scope.count
       end
     end
   end

data/lib/solid_queue_tui/data/processes_query.rb

@@ -29,47 +29,46 @@ module SolidQueueTui
         end
       end
 
-      def self.fetch
-        conn = ActiveRecord::Base.connection
-
-        rows = conn.select_all(
-          "SELECT id, kind, pid, hostname, name, last_heartbeat_at, " \
-          "supervisor_id, metadata, created_at " \
-          "FROM solid_queue_processes WHERE kind = 'Worker' ORDER BY id"
-        )
+      RunningJob = Struct.new(
+        :job_id, :class_name, :queue_name, :started_at,
+        keyword_init: true
+      )
 
-        rows.map do |row|
-          metadata = parse_json(row["metadata"])
+      def self.fetch_running_jobs(process_id:)
+        SolidQueue::ClaimedExecution
+          .where(process_id: process_id)
+          .joins(:job).includes(:job)
+          .order(:created_at)
+          .map do |ce|
+            job = ce.job
+            RunningJob.new(
+              job_id: job.id,
+              class_name: job.class_name,
+              queue_name: job.queue_name,
+              started_at: ce.created_at
+            )
+          end
+      rescue => e
+        []
+      end
 
+      def self.fetch
+        SolidQueue::Process.where(kind: "Worker").order(:id).map do |proc|
           Process.new(
-            id: row["id"].to_i,
-            kind: row["kind"],
-            pid: row["pid"].to_i,
-            hostname: row["hostname"],
-            name: row["name"],
-            last_heartbeat_at: parse_time(row["last_heartbeat_at"]),
-            supervisor_id: row["supervisor_id"]&.to_i,
-            metadata: metadata,
-            created_at: parse_time(row["created_at"])
+            id: proc.id,
+            kind: proc.kind,
+            pid: proc.pid,
+            hostname: proc.hostname,
+            name: proc.name,
+            last_heartbeat_at: proc.last_heartbeat_at,
+            supervisor_id: proc.supervisor_id,
+            metadata: proc.metadata,
+            created_at: proc.created_at
           )
         end
       rescue => e
         []
       end
-
-      private_class_method def self.parse_json(value)
-        return {} if value.nil?
-        value.is_a?(Hash) ? value : JSON.parse(value.to_s)
-      rescue JSON::ParserError
-        {}
-      end
-
-      private_class_method def self.parse_time(value)
-        return nil if value.nil?
-        value.is_a?(Time) ? value : Time.parse(value.to_s)
-      rescue
-        nil
-      end
     end
   end
 end

data/lib/solid_queue_tui/data/queues_query.rb

@@ -9,23 +9,14 @@ module SolidQueueTui
       )
 
       def self.fetch
-        conn = ActiveRecord::Base.connection
+        queues = SolidQueue::Queue.all
+        pauses = SolidQueue::Pause.where(queue_name: queues.map(&:name)).index_by(&:queue_name)
 
-        queue_sizes = conn.select_rows(
-          "SELECT queue_name, COUNT(*) FROM solid_queue_ready_executions GROUP BY queue_name ORDER BY queue_name"
-        ).to_h { |name, count| [name, count.to_i] }
-
-        all_queues = conn.select_values(
-          "SELECT DISTINCT queue_name FROM solid_queue_jobs WHERE queue_name IS NOT NULL ORDER BY queue_name"
-        )
-
-        paused = conn.select_values("SELECT queue_name FROM solid_queue_pauses")
-
-        all_queues.map do |name|
+        queues.map do |queue|
           QueueInfo.new(
-            name: name,
-            size: queue_sizes[name] || 0,
-            paused: paused.include?(name)
+            name: queue.name,
+            size: queue.size,
+            paused: pauses[queue.name].present?
           )
         end
       rescue => e

data/lib/solid_queue_tui/data/recurring_tasks_query.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module SolidQueueTui
+  module Data
+    class RecurringTasksQuery
+      Task = Struct.new(
+        :key, :class_name, :command, :schedule, :queue_name,
+        :priority, :last_enqueued_at, :next_time,
+        keyword_init: true
+      )
+
+      def self.fetch
+        tasks = SolidQueue::RecurringTask.all.to_a
+        return [] if tasks.empty?
+
+        last_enqueued = SolidQueue::RecurringExecution
+          .where(task_key: tasks.map(&:key))
+          .group(:task_key)
+          .maximum(:run_at)
+
+        tasks.map do |task|
+          Task.new(
+            key: task.key,
+            class_name: task.class_name,
+            command: task.command,
+            schedule: task.schedule,
+            queue_name: task.queue_name,
+            priority: task.priority,
+            last_enqueued_at: last_enqueued[task.key],
+            next_time: task.next_time
+          )
+        end
+      end
+    end
+  end
+end