sktop 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c99f0dede27934a3422767109eb5d1870b61ee9d0131e83d9731335b5e968f29
+  data.tar.gz: 070bf9de8114f114555b841abf898864070aebdaefb899f4b97e04c62a2dae64
+SHA512:
+  metadata.gz: ce99bdcc62ae52bbf105ae7c9fdeb7735d58e3ce354fb393e96b307d7f2c5d2a3db0672244b318c6dd0d6f4d496ba6134708c7ea6d8233eed93e829311ad0fe4
+  data.tar.gz: 62eb8486ef2c299d937268f26b9ce339119d628f15c0b5dbb33a911c3ed06e2c0a8f21149a3e942d7e4a953e70beed42ec9416872d38e4acd72503065bb36e16

data/README.md

@@ -0,0 +1,104 @@
+# sktop
+
+A CLI tool to monitor Sidekiq queues and processes - like htop for Sidekiq.
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem 'sktop'
+```
+
+Or install directly:
+
+```bash
+gem install sktop
+```
+
+## Usage
+
+```bash
+# Basic usage (auto-refresh every 2 seconds)
+sktop
+
+# Connect to a specific Redis instance
+sktop -r redis://myhost:6379/1
+
+# Custom refresh interval
+sktop -i 5
+
+# Start with a specific view
+sktop -w          # Workers view
+sktop -R          # Retries view
+sktop -d          # Dead jobs view
+
+# Display once and exit (no auto-refresh)
+sktop -1
+sktop -R -1       # Show retries view once and exit
+```
+
+## Options
+
+| Option | Description |
+|--------|-------------|
+| `-r, --redis URL` | Redis URL (default: redis://localhost:6379/0 or REDIS_URL env var) |
+| `-n, --namespace NS` | Redis namespace (e.g., 'myapp') |
+| `-i, --interval SECONDS` | Auto-refresh interval in seconds (default: 2) |
+| `-1, --once` | Display once and exit (no auto-refresh) |
+| `-v, --version` | Show version |
+| `-h, --help` | Show help |
+
+### View Options (set initial view)
+
+| Option | Description |
+|--------|-------------|
+| `-m, --main` | Main view - processes + workers (default) |
+| `-q, --queues` | Queues view |
+| `-p, --processes` | Processes view |
+| `-w, --workers` | Workers view |
+| `-R, --retries` | Retries view |
+| `-s, --scheduled` | Scheduled jobs view |
+| `-d, --dead` | Dead jobs view |
+
+## Keyboard Navigation
+
+| Key | Action |
+|-----|--------|
+| `m` | Main view (processes + workers) |
+| `q` | Queues view |
+| `p` | Processes view |
+| `w` | Workers view |
+| `r` | Retry queue view |
+| `s` | Scheduled jobs view |
+| `d` | Dead jobs view |
+| `↑/↓` | Scroll / select items |
+| `PgUp/PgDn` | Scroll by page |
+| `Esc` | Return to main view |
+| `Ctrl+C` | Quit |
+
+### Process Actions (in Processes view)
+
+| Key | Action |
+|-----|--------|
+| `Ctrl+Q` | Quiet selected process |
+| `Ctrl+K` | Stop/kill selected process |
+
+### Job Actions (in Retry/Dead views)
+
+| Key | Action |
+|-----|--------|
+| `Ctrl+R` | Retry selected job |
+| `Ctrl+X` | Delete selected job |
+| `Alt+R` | Retry all jobs |
+| `Alt+X` | Delete all jobs |
+
+## Environment Variables
+
+- `REDIS_URL` - Default Redis connection URL
+- `SIDEKIQ_NAMESPACE` - Default Redis namespace
+- `DEBUG` - Show stack traces on errors
+
+## License
+
+MIT License

data/bin/sktop

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/sktop"
+
+Sktop::CLI.new.run

data/lib/sktop/cli.rb

@@ -0,0 +1,501 @@
+# frozen_string_literal: true
+
+require "optparse"
+require "redis"
+require "redis-namespace"
+require "io/console"
+require "io/wait"
+
+module Sktop
+  class CLI
+    def initialize(args = ARGV)
+      @args = args
+      @options = {
+        redis_url: ENV["REDIS_URL"] || "redis://localhost:6379/0",
+        namespace: ENV["SIDEKIQ_NAMESPACE"],
+        refresh_interval: 2,
+        initial_view: :main,
+        once: false
+      }
+      @running = true
+    end
+
+    def run
+      parse_options!
+      configure_redis
+      start_watcher
+    rescue Interrupt
+      shutdown
+    rescue RedisClient::CannotConnectError, Redis::CannotConnectError => e
+      shutdown
+      puts "Error: Cannot connect to Redis at #{@options[:redis_url]}"
+      puts "Make sure Redis is running and the URL is correct."
+      puts "You can specify a different URL with: sktop -r redis://host:port/db"
+      exit 1
+    rescue StandardError => e
+      shutdown
+      puts "Error: #{e.message}"
+      puts e.backtrace.first(5).join("\n") if ENV["DEBUG"]
+      exit 1
+    end
+
+    def shutdown
+      @running = false
+      print "\e[?25h"    # Show cursor
+      print "\e[?1049l"  # Restore main screen
+      $stdout.flush
+    end
+
+    private
+
+    def parse_options!
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: sktop [options]"
+        opts.separator ""
+        opts.separator "Options:"
+
+        opts.on("-r", "--redis URL", "Redis URL (default: redis://localhost:6379/0)") do |url|
+          @options[:redis_url] = url
+        end
+
+        opts.on("-n", "--namespace NS", "Redis namespace (e.g., 'myapp')") do |ns|
+          @options[:namespace] = ns
+        end
+
+        opts.on("-i", "--interval SECONDS", Integer, "Refresh interval in seconds (default: 2)") do |interval|
+          @options[:refresh_interval] = interval
+        end
+
+        opts.separator ""
+        opts.separator "Views (set initial view):"
+
+        opts.on("-m", "--main", "Main view (default)") do
+          @options[:initial_view] = :main
+        end
+
+        opts.on("-q", "--queues", "Queues view") do
+          @options[:initial_view] = :queues
+        end
+
+        opts.on("-p", "--processes", "Processes view") do
+          @options[:initial_view] = :processes
+        end
+
+        opts.on("-w", "--workers", "Workers view") do
+          @options[:initial_view] = :workers
+        end
+
+        opts.on("-R", "--retries", "Retries view") do
+          @options[:initial_view] = :retries
+        end
+
+        opts.on("-s", "--scheduled", "Scheduled jobs view") do
+          @options[:initial_view] = :scheduled
+        end
+
+        opts.on("-d", "--dead", "Dead jobs view") do
+          @options[:initial_view] = :dead
+        end
+
+        opts.separator ""
+
+        opts.on("-1", "--once", "Display once and exit (no auto-refresh)") do
+          @options[:once] = true
+        end
+
+        opts.on("-v", "--version", "Show version") do
+          puts "sktop #{Sktop::VERSION}"
+          exit 0
+        end
+
+        opts.on("-h", "--help", "Show this help") do
+          puts opts
+          exit 0
+        end
+      end
+
+      parser.parse!(@args)
+    end
+
+    def configure_redis
+      Sidekiq.configure_client do |config|
+        if @options[:namespace]
+          config.redis = {
+            url: @options[:redis_url],
+            namespace: @options[:namespace]
+          }
+        else
+          config.redis = { url: @options[:redis_url] }
+        end
+      end
+    end
+
+    def start_watcher
+      collector = StatsCollector.new
+      @display = Display.new
+      @display.current_view = @options[:initial_view]
+
+      if @options[:once]
+        # One-shot mode: just print and exit
+        puts @display.render(collector)
+        return
+      end
+
+      # Auto-refresh mode with keyboard input
+      $stdout.sync = true
+
+      # Get terminal size before entering raw mode
+      @display.update_terminal_size
+
+      # Switch to alternate screen buffer (like htop/vim)
+      print "\e[?1049h"  # Enable alternate screen
+      print "\e[?25l"    # Hide cursor
+      print "\e[2J"      # Clear screen
+      $stdout.flush
+
+      # Thread-safe data cache
+      @cached_data = nil
+      @data_version = 0
+      @rendered_version = 0
+      @data_mutex = Mutex.new
+      @fetch_in_progress = false
+      @fetch_mutex = Mutex.new
+
+      # Set up signal handler for Ctrl+C (works even when blocked)
+      Signal.trap("INT") { @running = false }
+
+      # Start background thread for data fetching
+      fetch_thread = Thread.new do
+        while @running
+          # Skip if a fetch is already in progress (defensive guard)
+          can_fetch = @fetch_mutex.synchronize do
+            if @fetch_in_progress
+              false
+            else
+              @fetch_in_progress = true
+            end
+          end
+
+          next unless can_fetch
+
+          begin
+            collector.refresh!
+            # Cache a snapshot of the data
+            snapshot = {
+              overview: collector.overview,
+              queues: collector.queues,
+              processes: collector.processes,
+              workers: collector.workers,
+              retry_jobs: collector.retry_jobs(limit: 500),
+              scheduled_jobs: collector.scheduled_jobs(limit: 500),
+              dead_jobs: collector.dead_jobs(limit: 500)
+            }
+            @data_mutex.synchronize do
+              @cached_data = snapshot
+              @data_version += 1
+            end
+          rescue => e
+            # Ignore fetch errors, will retry next interval
+          ensure
+            @fetch_mutex.synchronize { @fetch_in_progress = false }
+          end
+
+          # Sleep in small increments so we can exit quickly
+          (@options[:refresh_interval] * 10).to_i.times do
+            break unless @running
+            sleep 0.1
+          end
+        end
+      end
+
+      begin
+        # Set up raw mode for keyboard input
+        STDIN.raw do |stdin|
+          # Wait for initial data (with timeout)
+          10.times do
+            break if @data_mutex.synchronize { @cached_data }
+            sleep 0.1
+          end
+
+          # Initial render
+          render_cached_data
+
+          while @running
+            # Wait for keyboard input with short timeout
+            ready = IO.select([stdin], nil, nil, 0.03)
+
+            if ready
+              key = stdin.read_nonblock(1) rescue nil
+              if key
+                handle_keypress(key, stdin)
+                # Immediate refresh on keypress
+                render_cached_data
+              end
+            end
+
+            # Check if background thread has new data
+            current_version = @data_mutex.synchronize { @data_version }
+            if current_version != @rendered_version
+              @rendered_version = current_version
+              render_cached_data
+            end
+          end
+        end
+      ensure
+        # Stop fetch thread
+        @running = false
+        fetch_thread.join(0.5) rescue nil
+
+        # Restore normal screen
+        print "\e[?25h"    # Show cursor
+        print "\e[?1049l"  # Disable alternate screen
+        $stdout.flush
+
+        # Reset signal handler
+        Signal.trap("INT", "DEFAULT")
+      end
+    end
+
+    def render_cached_data
+      data = @data_mutex.synchronize { @cached_data }
+      return unless data
+
+      @display.render_refresh_from_cache(data)
+    end
+
+    def handle_keypress(key, stdin)
+      case key
+      when 'q', 'Q'
+        @display.current_view = :queues
+      when 'p', 'P'
+        @display.current_view = :processes
+      when 'w', 'W'
+        @display.current_view = :workers
+      when 'r', 'R'  # Retries view
+        @display.current_view = :retries
+      when 's', 'S'
+        @display.current_view = :scheduled
+      when 'd', 'D'
+        @display.current_view = :dead
+      when 'm', 'M'
+        @display.current_view = :main
+      when "\x12"  # Ctrl+R - retry job
+        handle_retry_action
+      when "\x18"  # Ctrl+X - delete job
+        handle_delete_action
+      when "\x11"  # Ctrl+Q - quiet process
+        handle_quiet_process_action
+      when "\x0B"  # Ctrl+K - stop/kill process
+        handle_stop_process_action
+      when "\e"  # Escape sequence - could be arrow keys, Alt+key, or just Escape
+        # Try to read more characters (arrow keys send \e[A, \e[B, etc.)
+        if IO.select([stdin], nil, nil, 0.05)
+          seq = stdin.read_nonblock(10) rescue ""
+          case seq
+          when "[A"  # Up arrow
+            @display.select_up
+          when "[B"  # Down arrow
+            @display.select_down
+          when "[C"  # Right arrow (unused for now)
+          when "[D"  # Left arrow (unused for now)
+          when "[5~"  # Page Up
+            @display.page_up
+          when "[6~"  # Page Down
+            @display.page_down
+          when "r", "R"  # Alt+R - Retry All
+            handle_retry_all_action
+          when "x", "X"  # Alt+X - Delete All
+            handle_delete_all_action
+          else
+            # Just Escape key - go to main
+            @display.current_view = :main
+          end
+        else
+          # Just Escape key - go to main
+          @display.current_view = :main
+        end
+      when "\u0003"  # Ctrl+C
+        raise Interrupt
+      end
+    end
+
+    def handle_retry_action
+      return unless [:retries, :dead].include?(@display.current_view)
+
+      data = @data_mutex.synchronize { @cached_data }
+      unless data
+        @display.set_status("No data available")
+        return
+      end
+
+      jobs = @display.current_view == :retries ? data[:retry_jobs] : data[:dead_jobs]
+      selected_idx = @display.selected_index
+
+      if jobs.empty?
+        @display.set_status("No jobs to retry")
+        return
+      end
+
+      if selected_idx >= jobs.length
+        @display.set_status("Invalid selection")
+        return
+      end
+
+      job = jobs[selected_idx]
+      unless job[:jid]
+        @display.set_status("Job has no JID")
+        return
+      end
+
+      begin
+        source = @display.current_view == :retries ? :retry : :dead
+        Sktop::JobActions.retry_job(job[:jid], source)
+        @display.set_status("Retrying #{job[:class]}")
+        # Force data refresh
+        @rendered_version = -1
+      rescue => e
+        @display.set_status("Error: #{e.message}")
+      end
+    end
+
+    def handle_delete_action
+      return unless [:retries, :dead].include?(@display.current_view)
+
+      data = @data_mutex.synchronize { @cached_data }
+      unless data
+        @display.set_status("No data available")
+        return
+      end
+
+      jobs = @display.current_view == :retries ? data[:retry_jobs] : data[:dead_jobs]
+      selected_idx = @display.selected_index
+
+      if jobs.empty?
+        @display.set_status("No jobs to delete")
+        return
+      end
+
+      if selected_idx >= jobs.length
+        @display.set_status("Invalid selection")
+        return
+      end
+
+      job = jobs[selected_idx]
+      unless job[:jid]
+        @display.set_status("Job has no JID")
+        return
+      end
+
+      begin
+        source = @display.current_view == :retries ? :retry : :dead
+        Sktop::JobActions.delete_job(job[:jid], source)
+        @display.set_status("Deleted #{job[:class]}")
+        # Force data refresh
+        @rendered_version = -1
+      rescue => e
+        @display.set_status("Error: #{e.message}")
+      end
+    end
+
+    def handle_retry_all_action
+      return unless [:retries, :dead].include?(@display.current_view)
+
+      begin
+        source = @display.current_view == :retries ? :retry : :dead
+        count = Sktop::JobActions.retry_all(source)
+        @display.set_status("Retrying all #{count} jobs")
+        @rendered_version = -1
+      rescue => e
+        @display.set_status("Error: #{e.message}")
+      end
+    end
+
+    def handle_delete_all_action
+      return unless [:retries, :dead].include?(@display.current_view)
+
+      begin
+        source = @display.current_view == :retries ? :retry : :dead
+        count = Sktop::JobActions.delete_all(source)
+        @display.set_status("Deleted all #{count} jobs")
+        @rendered_version = -1
+      rescue => e
+        @display.set_status("Error: #{e.message}")
+      end
+    end
+
+    def handle_quiet_process_action
+      return unless @display.current_view == :processes
+
+      data = @data_mutex.synchronize { @cached_data }
+      unless data
+        @display.set_status("No data available")
+        return
+      end
+
+      processes = data[:processes]
+      selected_idx = @display.selected_index
+
+      if processes.empty?
+        @display.set_status("No processes")
+        return
+      end
+
+      if selected_idx >= processes.length
+        @display.set_status("Invalid selection")
+        return
+      end
+
+      process = processes[selected_idx]
+      unless process[:identity]
+        @display.set_status("Process has no identity")
+        return
+      end
+
+      begin
+        Sktop::JobActions.quiet_process(process[:identity])
+        @display.set_status("Quieting #{process[:hostname]}:#{process[:pid]}")
+        @rendered_version = -1
+      rescue => e
+        @display.set_status("Error: #{e.message}")
+      end
+    end
+
+    def handle_stop_process_action
+      return unless @display.current_view == :processes
+
+      data = @data_mutex.synchronize { @cached_data }
+      unless data
+        @display.set_status("No data available")
+        return
+      end
+
+      processes = data[:processes]
+      selected_idx = @display.selected_index
+
+      if processes.empty?
+        @display.set_status("No processes")
+        return
+      end
+
+      if selected_idx >= processes.length
+        @display.set_status("Invalid selection")
+        return
+      end
+
+      process = processes[selected_idx]
+      unless process[:identity]
+        @display.set_status("Process has no identity")
+        return
+      end
+
+      begin
+        Sktop::JobActions.stop_process(process[:identity])
+        @display.set_status("Stopping #{process[:hostname]}:#{process[:pid]}")
+        @rendered_version = -1
+      rescue => e
+        @display.set_status("Error: #{e.message}")
+      end
+    end
+
+  end
+end