solid_queue_tui 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 362a8f6c4d4bd257ed5bdc4a7eaf93fb986b978313a5847bffd3dfe8e9f963ed
-  data.tar.gz: 9aabeac6f1fa7404ff7a485b2a47669ed1313244348fc29dc4bc34a751ab9bd8
+  metadata.gz: ea9a6cc3e42df6d7c5f50f91ed2bbf360bbd3e65c9fabb6f53bcf649b69826f1
+  data.tar.gz: 3cd1c06f2c4ea19f2c59e0c5dc79962211d8f18b8200b4f46955910c2fcd78e6
 SHA512:
-  metadata.gz: 7de0862123508768172c46a17458c55651b6bda487d79e76f7e61933d223e29e848ba0614b4fc116acc8222dc5a245ac590fc92cff595b3c65c67367537589c1
-  data.tar.gz: b8d145ba61da8f1de1fe3a4c1b3678e06ca36e19e6e4622acc67942adf194228eb6c96e09cfa114168cc8c3b3b28140ffd2d53b05d653081394c89406fdf6648
+  metadata.gz: 2364ad1bd990fca2ec78ad80a744c3d820e07b3add19dcbfcfeb88cebb5c07b47dc9b29acefafc27dac06a24b333cb11cd894ffba070435d4fbdcbb051d79941
+  data.tar.gz: af34ecfb3046c67d8aac92f227d37740130946ee5f3abb919b55c2d8edd86b40ba242970dc9bda05e2191c397e42548f200295f8259ca05653a7992fa5d3731a

data/exe/sqtui

@@ -19,7 +19,24 @@ require env_file
 # Log ActiveRecord queries to the Rails log file so TUI operations
 # are visible in log/development.log (or whichever environment is active).
 # Tag all TUI logs with [SQTUI] so they're easy to distinguish from app logs.
-ActiveRecord::Base.logger = Rails.logger
-Rails.logger.push_tags("SQTUI") if Rails.logger.respond_to?(:push_tags)
+# CORRUPTING TERMINAL
+# ActiveRecord::Base.logger = Rails.logger
+# Rails.logger.push_tags("SQTUI") if Rails.logger.respond_to?(:push_tags)
+
+# Logs must never hit STDOUT/STDERR — that would corrupt the TUI.
+# If a log/ directory exists (traditional Rails), write there.
+# Otherwise (Rails 8 defaults), silence logging.
+#TODO: figure out logging for rails 8, docker
+
+log_dir = File.join(Dir.pwd, "log")
+if Dir.exist?(log_dir)
+  log_file = File.join(log_dir, "#{Rails.env}.log")
+  tui_logger = ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new(log_file))
+  tui_logger.push_tags("SQTUI")
+else
+  tui_logger = ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new(File::NULL))
+end
+ActiveRecord::Base.logger = tui_logger
+Rails.logger = tui_logger
 
 SolidQueueTui::CLI.run(ARGV)

data/lib/solid_queue_tui/application.rb

@@ -143,10 +143,17 @@ module SolidQueueTui
         return false
       end
 
-      # If view is in a modal state (filter, confirm), it gets all input
+      # If view is in a modal state (filter, confirm, detail sub-view), it gets all input
       if current_view.respond_to?(:capturing_input?) && current_view.capturing_input?
         result = current_view.handle_input(event)
-        refresh_data! if result == :refresh
+        case result
+        when :refresh, :enter_queue, :exit_queue
+          refresh_data!
+        when :load_more
+          load_more_data!
+        when :open_detail
+          open_detail
+        end
         return false
       end
 
@@ -241,11 +248,21 @@ module SolidQueueTui
       return unless item
 
       case @current_view
+      when VIEW_QUEUES
+        if current_view.detail_mode?
+          @job_detail.show(job: item) if item.respond_to?(:id)
+        else
+          result = current_view.handle_input({ type: :key, code: "enter" })
+          refresh_data! if result == :enter_queue
+        end
       when VIEW_FAILED
         failed_job = Data::FailedQuery.fetch_one(item.id) if item.respond_to?(:id)
         @job_detail.show(failed_job: failed_job || item)
       when VIEW_IN_PROGRESS, VIEW_BLOCKED, VIEW_SCHEDULED, VIEW_FINISHED
         @job_detail.show(job: item) if item.respond_to?(:id)
+      when VIEW_WORKERS
+        running_jobs = Data::ProcessesQuery.fetch_running_jobs(process_id: item.id)
+        @job_detail.show(process: item, running_jobs: running_jobs)
       end
     end
 
@@ -262,8 +279,16 @@ module SolidQueueTui
         @stats = Data::Stats.fetch
         current_view.update(stats: @stats)
       when VIEW_QUEUES
-        queues = Data::QueuesQuery.fetch
-        current_view.update(queues: queues)
+        if current_view.detail_mode?
+          q = current_view.selected_queue_name
+          f = current_view.filters
+          current_view.total_count = Data::JobsQuery.count_pending(queue: q, filter: f[:class_name])
+          jobs = Data::JobsQuery.fetch_pending(queue: q, filter: f[:class_name], limit: SolidQueueTui.page_size, offset: 0)
+          current_view.update_detail(jobs: jobs)
+        else
+          queues = Data::QueuesQuery.fetch
+          current_view.update(queues: queues)
+        end
       when VIEW_FAILED
         f = current_view.filters
         current_view.total_count = Data::FailedQuery.count(filter: f[:class_name], queue: f[:queue])
@@ -305,6 +330,13 @@ module SolidQueueTui
       offset = view.current_offset
 
       case @current_view
+      when VIEW_QUEUES
+        if view.detail_mode?
+          q = view.selected_queue_name
+          f = view.filters
+          more = Data::JobsQuery.fetch_pending(queue: q, filter: f[:class_name], limit: SolidQueueTui.page_size, offset: offset)
+          view.append(jobs: more)
+        end
       when VIEW_FAILED
         f = view.filters
         more = Data::FailedQuery.fetch(filter: f[:class_name], queue: f[:queue], limit: SolidQueueTui.page_size, offset: offset)

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,
@@ -49,9 +51,6 @@ module SolidQueueTui
         text + " "
       end
 
-      def format_number(n)
-        n.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse
-      end
 
       def render_table(frame, area, table_state)
         widths = @columns.map do |col|

data/lib/solid_queue_tui/data/jobs_query.rb

@@ -13,6 +13,7 @@ module SolidQueueTui
 
       def self.fetch(status:, filter: nil, queue: nil, limit: 100, offset: 0)
         case status
+        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)
@@ -25,6 +26,7 @@ module SolidQueueTui
 
       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)
@@ -35,6 +37,35 @@ module SolidQueueTui
         0
       end
 
+      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)
+
+        scope.includes(:job).map do |re|
+          job = re.job
+          Job.new(
+            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.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
+
       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

data/lib/solid_queue_tui/data/processes_query.rb

@@ -29,6 +29,29 @@ module SolidQueueTui
         end
       end
 
+      RunningJob = Struct.new(
+        :job_id, :class_name, :queue_name, :started_at,
+        keyword_init: true
+      )
+
+      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(

data/lib/solid_queue_tui/formatting_helpers.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module SolidQueueTui
+  module FormattingHelpers
+    def time_ago(time)
+      return "n/a" unless time
+      seconds = (Time.now.utc - time).to_i
+      case seconds
+      when 0..59       then "#{seconds}s ago"
+      when 60..3599    then "#{seconds / 60}m ago"
+      when 3600..86399 then "#{seconds / 3600}h ago"
+      else "#{seconds / 86400}d ago"
+      end
+    end
+
+    def format_time(time)
+      return "n/a" unless time
+      time.strftime("%Y-%m-%d %H:%M:%S")
+    end
+
+    def format_duration(seconds)
+      return "n/a" unless seconds
+      seconds = seconds.to_i
+      if seconds < 1
+        "<1s"
+      elsif seconds < 60
+        "#{seconds}s"
+      elsif seconds < 3600
+        "#{seconds / 60}m #{seconds % 60}s"
+      elsif seconds < 86400
+        "#{seconds / 3600}h #{(seconds % 3600) / 60}m"
+      else
+        "#{seconds / 86400}d #{(seconds % 86400) / 3600}h"
+      end
+    end
+
+    def format_number(n)
+      return "0" if n.nil? || n == 0
+      n.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse
+    end
+
+    def truncate(str, max)
+      return "" unless str
+      str.length > max ? "#{str[0...max - 3]}..." : str
+    end
+
+    def humanize_duration(seconds)
+      case seconds.abs
+      when 0..59       then "#{seconds.abs}s"
+      when 60..3599    then "#{seconds.abs / 60}m"
+      when 3600..86399 then "#{seconds.abs / 3600}h"
+      else "#{seconds.abs / 86400}d"
+      end
+    end
+
+    def time_until(time)
+      return "n/a" unless time
+      seconds = (time - Time.now.utc).to_i
+      return "now" if seconds <= 0
+      "in #{humanize_duration(seconds)}"
+    end
+  end
+end

data/lib/solid_queue_tui/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SolidQueueTui
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/lib/solid_queue_tui/views/blocked_view.rb

@@ -4,47 +4,21 @@ module SolidQueueTui
   module Views
     class BlockedView
       include Filterable
-
-
-      LOAD_THRESHOLD = 10
+      include Paginatable
+      include FormattingHelpers
 
       def initialize(tui)
         @tui = tui
-        @table_state = RatatuiRuby::TableState.new(nil)
-        @table_state.select(0)
-        @selected_row = 0
-        @jobs = []
-        @total_count = nil
-        @all_loaded = false
+        init_pagination
         init_filter
       end
 
       def update(jobs:)
-        @jobs = jobs
-        @all_loaded = jobs.size < SolidQueueTui.page_size
-        @selected_row = @selected_row.clamp(0, [@jobs.size - 1, 0].max)
-        @table_state.select(@selected_row)
+        update_items(jobs)
       end
 
       def append(jobs:)
-        @jobs.concat(jobs)
-        @all_loaded = jobs.size < SolidQueueTui.page_size
-      end
-
-      def total_count=(count)
-        @total_count = count
-      end
-
-      def current_offset
-        @jobs.size
-      end
-
-      def reset_pagination!
-        @jobs = []
-        @total_count = nil
-        @all_loaded = false
-        @selected_row = 0
-        @table_state.select(0)
+        append_items(jobs)
       end
 
       def render(frame, area)
@@ -72,11 +46,6 @@ module SolidQueueTui
         end
       end
 
-      def selected_item
-        return nil if @jobs.empty? || @selected_row >= @jobs.size
-        @jobs[@selected_row]
-      end
-
       def bindings
         if filter_mode?
           filter_bindings
@@ -100,10 +69,6 @@ module SolidQueueTui
 
       private
 
-      def needs_more?
-        !@all_loaded && @selected_row >= @jobs.size - LOAD_THRESHOLD
-      end
-
       def handle_normal_input(event)
         case event
         in { type: :key, code: "j" } | { type: :key, code: "up" }
@@ -126,25 +91,6 @@ module SolidQueueTui
         end
       end
 
-      def move_selection(delta)
-        return if @jobs.empty?
-        @selected_row = (@selected_row + delta).clamp(0, @jobs.size - 1)
-        @table_state.select(@selected_row)
-        :load_more if needs_more?
-      end
-
-      def jump_to_top
-        @selected_row = 0
-        @table_state.select(0)
-      end
-
-      def jump_to_bottom
-        return if @jobs.empty?
-        @selected_row = @jobs.size - 1
-        @table_state.select(@selected_row)
-        return :load_more if needs_more?
-      end
-
       def render_table(frame, area)
         columns = [
           { key: :id,              label: "ID",              width: 8 },
@@ -156,7 +102,7 @@ module SolidQueueTui
           { key: :blocked_since,   label: "BLOCKED SINCE",    width: 14 }
         ]
 
-        rows = @jobs.map do |job|
+        rows = items.map do |job|
           {
             id: job.id,
             queue_name: job.queue_name,
@@ -181,21 +127,6 @@ module SolidQueueTui
         table.render(frame, area, @table_state)
       end
 
-      def format_time(time)
-        return "n/a" unless time
-        time.strftime("%Y-%m-%d %H:%M:%S")
-      end
-
-      def time_ago(time)
-        return "n/a" unless time
-        seconds = (Time.now.utc - time).to_i
-        case seconds
-        when 0..59       then "#{seconds}s ago"
-        when 60..3599    then "#{seconds / 60}m ago"
-        when 3600..86399 then "#{seconds / 3600}h ago"
-        else "#{seconds / 86400}d ago"
-        end
-      end
     end
   end
 end

data/lib/solid_queue_tui/views/concerns/confirmable.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module SolidQueueTui
+  module Views
+    module Confirmable
+      def init_confirm
+        @confirm_action = nil
+      end
+
+      def confirm_mode? = !!@confirm_action
+
+      def confirm_bindings
+        [{ key: "y", action: "Confirm" }, { key: "n/Esc", action: "Cancel" }]
+      end
+
+      def handle_confirm_input(event)
+        case event
+        in { type: :key, code: "y" }
+          action = @confirm_action
+          @confirm_action = nil
+          execute_confirm_action(action)
+        in { type: :key, code: "n" } | { type: :key, code: "esc" }
+          @confirm_action = nil
+          nil
+        else
+          nil
+        end
+      end
+
+      def render_confirm_popup(frame, area)
+        popup_area = area.centered(
+          @tui.constraint_percentage(50),
+          @tui.constraint_length(5)
+        )
+        frame.render_widget(@tui.clear(), popup_area)
+        frame.render_widget(
+          @tui.paragraph(
+            text: " #{confirm_message}",
+            style: @tui.style(fg: :yellow, modifiers: [:bold]),
+            block: @tui.block(
+              title: " Confirm ",
+              title_style: @tui.style(fg: :red, modifiers: [:bold]),
+              borders: [:all],
+              border_type: :rounded,
+              border_style: @tui.style(fg: :red)
+            )
+          ),
+          popup_area
+        )
+      end
+    end
+  end
+end

data/lib/solid_queue_tui/views/concerns/paginatable.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module SolidQueueTui
+  module Views
+    module Paginatable
+      LOAD_THRESHOLD = 10
+
+      def init_pagination
+        @table_state = RatatuiRuby::TableState.new(nil)
+        @table_state.select(0)
+        @selected_row = 0
+        @items = []
+        @total_count = nil
+        @all_loaded = false
+      end
+
+      def items = @items
+
+      def selected_item
+        return nil if @items.empty? || @selected_row >= @items.size
+        @items[@selected_row]
+      end
+
+      def total_count=(count)
+        @total_count = count
+      end
+
+      def current_offset
+        @items.size
+      end
+
+      def reset_pagination!
+        @items = []
+        @total_count = nil
+        @all_loaded = false
+        @selected_row = 0
+        @table_state.select(0)
+      end
+
+      private
+
+      def update_items(new_items)
+        @selected_row = 0 if @selected_row >= new_items.size
+        @items = new_items
+        @all_loaded = new_items.size < SolidQueueTui.page_size
+        @selected_row = @selected_row.clamp(0, [@items.size - 1, 0].max)
+        @table_state.select(@selected_row)
+      end
+
+      def append_items(more_items)
+        @items.concat(more_items)
+        @all_loaded = more_items.size < SolidQueueTui.page_size
+      end
+
+      def needs_more?
+        !@all_loaded && @selected_row >= @items.size - LOAD_THRESHOLD
+      end
+
+      def move_selection(delta)
+        return if @items.empty?
+        @selected_row = (@selected_row + delta).clamp(0, @items.size - 1)
+        @table_state.select(@selected_row)
+        :load_more if needs_more?
+      end
+
+      def jump_to_top
+        @selected_row = 0
+        @table_state.select(0)
+      end
+
+      def jump_to_bottom
+        return if @items.empty?
+        @selected_row = @items.size - 1
+        @table_state.select(@selected_row)
+        :load_more if needs_more?
+      end
+    end
+  end
+end

data/lib/solid_queue_tui/views/dashboard_view.rb

@@ -3,6 +3,8 @@
 module SolidQueueTui
   module Views
     class DashboardView
+      include FormattingHelpers
+
       def initialize(tui)
         @tui = tui
         @selected_row = 0
@@ -179,10 +181,6 @@ module SolidQueueTui
         ])
       end
 
-      def format_number(n)
-        return "0" if n.nil? || n == 0
-        n.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse
-      end
     end
   end
 end