sidekiq 8.1.0 → 8.1.2

data/lib/sidekiq/tui/tabs/queues.rb

@@ -0,0 +1,95 @@
+require_relative "base_tab"
+
+module Sidekiq
+  class TUI
+    module Tabs
+      class Queues < BaseTab
+        def features
+          %i[selectable]
+        end
+
+        def controls
+          @controls ||= super + [
+            {code: "D", modifiers: ["shift"], display: "D", description: "Delete",
+             action: ->(tui, tab) { tab.delete_queue! }, refresh: true},
+            {code: "p", description: "Pause/Unpause Queue",
+             action: ->(tui, tab) { tab.toggle_pause_queue! }}
+          ]
+        end
+
+        def delete_queue!
+          each_selection do |qname|
+            Sidekiq::Queue.new(qname).clear
+          end
+        end
+
+        def toggle_pause_queue!
+          return unless Sidekiq.pro?
+
+          each_selection do |qname|
+            queue = Sidekiq::Queue.new(qname)
+            if queue.paused?
+              queue.unpause!
+            else
+              queue.pause!
+            end
+          end
+        end
+
+        def refresh_data
+          refresh_data_for_stats
+
+          queue_summaries = Sidekiq::Stats.new.queue_summaries.sort_by(&:name)
+
+          selected = Array(@data[:selected])
+          queues = queue_summaries.map { |queue_summary|
+            row_cells = [
+              selected.index(queue_summary.name) ? "✅" : "",
+              queue_summary.name,
+              queue_summary.size.to_s,
+              number_with_delimiter(queue_summary.latency, {precision: 2})
+            ]
+            row_cells << (queue_summary.paused? ? "✅" : "") if Sidekiq.pro?
+            row_cells
+          }
+
+          table_row_ids = queue_summaries.map(&:name)
+
+          @data[:queues] = queues
+          @data[:table] = {row_ids: table_row_ids}
+        end
+
+        def render(tui, frame, area)
+          header = ["☑️", "Queue", "Size", "Latency"].map { |x| t(x) }
+          header << "Paused?" if Sidekiq.pro?
+
+          chunks = tui.layout_split(
+            area,
+            direction: :vertical,
+            constraints: [
+              tui.constraint_length(4), # Stats
+              tui.constraint_fill(1) # Table
+            ]
+          )
+
+          render_stats_section(tui, frame, chunks[0])
+          render_table(tui, frame, chunks[1]) do
+            {
+              title: t(name),
+              header:,
+              widths: header.map.with_index { |_, idx|
+                tui.constraint_length((idx == 1) ? 60 : 10)
+              },
+              rows: @data[:queues].map.with_index { |cells, idx|
+                tui.table_row(
+                  cells:,
+                  style: idx.even? ? nil : tui.style(bg: :dark_gray)
+                )
+              }
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/tui/tabs/retries.rb

@@ -0,0 +1,19 @@
+require_relative "base_tab"
+require_relative "set_tab"
+
+module Sidekiq
+  class TUI
+    module Tabs
+      class Retries < BaseTab
+        include SetTab
+
+        def set_class = Sidekiq::RetrySet
+
+        def refresh_data
+          refresh_data_for_stats
+          refresh_data_for_set
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/tui/tabs/scheduled.rb

@@ -0,0 +1,19 @@
+require_relative "base_tab"
+require_relative "set_tab"
+
+module Sidekiq
+  class TUI
+    module Tabs
+      class Scheduled < BaseTab
+        include SetTab
+
+        def set_class = Sidekiq::ScheduledSet
+
+        def refresh_data
+          refresh_data_for_stats
+          refresh_data_for_set
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/tui/tabs/set_tab.rb

@@ -0,0 +1,96 @@
+module Sidekiq
+  class TUI
+    module Tabs
+      module SetTab
+        include Sidekiq::Paginator
+        include Filtering
+
+        def features
+          %i[selectable pageable filterable]
+        end
+
+        def controls
+          @controls ||= super + [{code: "D", modifiers: ["shift"], display: "D", description: "Delete",
+                                  action: ->(tui, tab) { tab.alter_rows!(:delete) }, refresh: true},
+            {code: "R", modifiers: ["shift"], display: "R", description: "Retry",
+             action: ->(tui, tab) { tab.alter_rows!(:retry) }, refresh: true},
+            {code: "E", modifiers: ["shift"], display: "E", description: "Enqueue",
+             action: ->(tui, tab) { tab.alter_rows!(:add_to_queue) }, refresh: true},
+            {code: "K", modifiers: ["shift"], display: "K", description: "Kill",
+             action: ->(tui, tab) { tab.alter_rows!(:kill) }, refresh: true}]
+        end
+
+        def alter_rows!(action)
+          # log(to_s, @data[:selected])
+          set = set_class.new
+          each_selection do |id|
+            score, jid = id.split("|")
+            item = set.fetch(score, jid)&.first
+            item&.send(action)
+          end
+        end
+
+        def refresh_data_for_set
+          set = set_class.new
+          f = current_filter
+          pager, rows, current, total = if f && f.size > 2
+            rows = set.scan(f).to_a
+            sz = rows.size
+            [Sidekiq::TUI::PageOptions.new(1, sz), rows, 1, sz]
+          else
+            pager = @data.dig(:table, :pager) || Sidekiq::TUI::PageOptions.new(1, 25)
+            current, total, items = page(set.name, pager.page, pager.size)
+            rows = items.map { |msg, score| Sidekiq::SortedEntry.new(nil, score, msg) }
+            [pager, rows, current, total]
+          end
+
+          @data.merge!(
+            table: {pager:, rows:, current_page: current, total:,
+                    next_page: (current * pager.size < total) ? pager.page + 1 : nil,
+                    row_ids: rows.map { |job| [job.score, job["jid"]].join("|") }}
+          )
+        end
+
+        def render(tui, frame, area)
+          chunks = tui.layout_split(
+            area,
+            direction: :vertical,
+            constraints: [
+              tui.constraint_length(4), # Stats
+              tui.constraint_fill(1)   # Table
+            ]
+          )
+
+          render_stats_section(tui, frame, chunks[0])
+          render_table(tui, frame, chunks[1]) do
+            {
+              title: t(name),
+              header: ["☑️", "When", "Queue", "Job", "Arguments"].map { |x| t(x) },
+              widths: [
+                tui.constraint_length(5),
+                tui.constraint_length(24),
+                tui.constraint_length(20),
+                tui.constraint_length(30),
+                tui.constraint_fill(1)
+              ]
+            }.tap do |h|
+              rows = @data[:table][:rows].map.with_index { |entry, idx|
+                tui.table_row(
+                  cells: [
+                    selected?(entry) ? "✅" : "",
+                    entry.at,
+                    entry.queue,
+                    entry.display_class,
+                    entry.display_args
+                  ],
+                  style: idx.even? ? nil : tui.style(bg: :dark_gray)
+                )
+              }
+              h[:rows] = rows
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/tui/tabs.rb

@@ -0,0 +1,15 @@
+require_relative "tabs/home"
+require_relative "tabs/busy"
+require_relative "tabs/queues"
+require_relative "tabs/scheduled"
+require_relative "tabs/retries"
+require_relative "tabs/dead"
+require_relative "tabs/metrics"
+
+module Sidekiq
+  class TUI
+    module Tabs
+      All = Set.new([Home, Busy, Queues, Scheduled, Retries, Dead, Metrics])
+    end
+  end
+end

data/lib/sidekiq/tui.rb

@@ -0,0 +1,380 @@
+# https://sr.ht/~kerrick/ratatui_ruby/
+# https://git.sr.ht/~kerrick/ratatui_ruby/tree/stable/item/examples/
+gem "ratatui_ruby", ">=1.4.0"
+require "ratatui_ruby"
+
+RatatuiRuby.debug_mode! if !!ENV["DEBUG"]
+
+require "sidekiq/api"
+require "sidekiq/paginator"
+
+require_relative "tui/filtering"
+require_relative "tui/controls"
+require_relative "tui/tabs"
+
+module Sidekiq
+  class TUI
+    include Sidekiq::Component
+
+    PageOptions = Data.define(:page, :size)
+
+    REFRESH_INTERVAL_SECONDS = 2
+    LOCALE_DIRECTORIES = [File.expand_path("#{File.dirname(__FILE__)}/../../web/locales")]
+
+    # language is meant to be a locale code, e.g.
+    # LANG=en_US.utf-8
+    def initialize(cfg, language: ENV["LANG"] || "en")
+      @lang = language
+      @config = cfg
+      @base_style = nil
+      @last_refresh = Time.at(0)
+      @fps = Array.new(2) { 0 }
+      @previous_fps = 0
+      @showing = :main
+    end
+
+    def prepare(tui)
+      load_locale
+
+      @tui = tui
+      @highlight_style = @tui.style(fg: :light_red, modifiers: [:underlined])
+      @hotkey_style = @tui.style(modifiers: [:bold, :underlined])
+      # eager load tabs
+      all
+    end
+
+    def run_loop
+      # Must log to a file, terminal is now controlled by Ratatui
+      config.logger = Logger.new("tui.log")
+
+      loop do
+        refresh_data if should_refresh?
+        render
+        break if handle_input == :quit
+      end
+    end
+
+    def render
+      track_fps do
+        if @showing == :main
+          @tui.draw do |frame|
+            main_area, controls_area = @tui.layout_split(
+              frame.area,
+              direction: :vertical,
+              constraints: [
+                @tui.constraint_fill(1),
+                @tui.constraint_length(5)
+              ]
+            )
+
+            # Split main area into tabs and content
+            tabs_area, content_area = @tui.layout_split(
+              main_area,
+              direction: :vertical,
+              constraints: [
+                @tui.constraint_length(3),
+                @tui.constraint_fill(1)
+              ]
+            )
+
+            all_tabs = all
+            tabs = @tui.tabs(
+              titles: all_tabs.map { |tab| t(tab.name) },
+              selected_index: all_tabs.index(current_tab),
+              block: @tui.block(title: " #{Sidekiq::NAME}", borders: [:all], title_style: @tui.style(fg: :light_red, modifiers: [:bold])),
+              divider: " | ",
+              highlight_style: @highlight_style,
+              style: @base_style
+            )
+            frame.render_widget(tabs, tabs_area)
+
+            render_content_area(frame, content_area)
+            render_controls(frame, controls_area)
+          end
+        end
+
+        if @showing == :help
+          @tui.draw do |frame|
+            main_area, controls_area = @tui.layout_split(
+              frame.area,
+              direction: :vertical,
+              constraints: [
+                @tui.constraint_fill(1),
+                @tui.constraint_length(4)
+              ]
+            )
+            content = @tui.block(
+              title: " #{Sidekiq::NAME} ",
+              borders: [:all],
+              title_style: @tui.style(fg: :light_red, modifiers: [:bold]),
+              children: [
+                # TODO convert to table
+                @tui.paragraph(
+                  text: [
+                    @tui.text_line(spans: ["Welcome to the Sidekiq Terminal UI"], alignment: :center),
+                    @tui.text_line(spans: [
+                      @tui.text_span(content: "Global hotkeys")
+                    ]),
+                    @tui.text_line(spans: []),
+                    @tui.text_line(spans: [
+                      @tui.text_span(content: "Esc", style: @hotkey_style),
+                      @tui.text_span(content: ": Close this window")
+                    ]),
+                    @tui.text_line(spans: [
+                      @tui.text_span(content: "←/→", style: @hotkey_style),
+                      @tui.text_span(content: ": Move between tabs")
+                    ]),
+                    @tui.text_line(spans: [
+                      @tui.text_span(content: "h/l", style: @hotkey_style),
+                      @tui.text_span(content: ": Move to prev/next page of data")
+                    ]),
+                    @tui.text_line(spans: [
+                      @tui.text_span(content: "j/k", style: @hotkey_style),
+                      @tui.text_span(content: ": Move to prev/next row in current page")
+                    ]),
+                    @tui.text_line(spans: [
+                      @tui.text_span(content: "x", style: @hotkey_style),
+                      @tui.text_span(content: ": Select/deselect current row")
+                    ]),
+                    @tui.text_line(spans: [
+                      @tui.text_span(content: "A", style: @hotkey_style),
+                      @tui.text_span(content: ": Select/deselect All rows in current page")
+                    ]),
+                    @tui.text_line(spans: [
+                      @tui.text_span(content: "q", style: @hotkey_style),
+                      @tui.text_span(content: ": Quit")
+                    ])
+                  ]
+                )
+              ]
+            )
+            frame.render_widget(content, main_area)
+            controls = @tui.block(
+              title: t("Controls"),
+              borders: [:all],
+              children: [
+                @tui.paragraph(
+                  text: [
+                    @tui.text_line(spans: [
+                      @tui.text_span(content: "Esc", style: @hotkey_style),
+                      @tui.text_span(content: ": Close  ")
+                    ])
+                  ]
+                )
+              ]
+            )
+            frame.render_widget(controls, controls_area)
+          end
+        end
+      end
+    end
+
+    def render_content_area(frame, content_area)
+      return render_error(frame, content_area, current_tab.error) if current_tab.error
+
+      current_tab.render(@tui, frame, content_area)
+    end
+
+    def render_controls(frame, area)
+      active_keys = current_tab.controls.filter { |hash| hash[:description] }
+
+      # Split controls into two lines, 8 is arbitrary
+      # TODO Dynamically split based on term width?
+      first = active_keys[...8]
+      lines = []
+      lines << @tui.text_line(spans: first.map { |hash|
+        [
+          @tui.text_span(content: hash[:display] || hash[:code], style: @hotkey_style),
+          @tui.text_span(content: ": #{t(hash[:description])}  ")
+        ]
+      }.flatten)
+
+      last = active_keys[8...]
+      lines << if last && last.size > 0
+        @tui.text_line(spans: last.map { |hash|
+          [
+            @tui.text_span(content: hash[:display] || hash[:code], style: @hotkey_style),
+            @tui.text_span(content: ": #{t(hash[:description])}  ")
+          ]
+        }.flatten)
+      else
+        @tui.text_line(spans: [])
+      end
+
+      footer = [
+        @tui.text_span(content: "Redis: #{redis_url}    "),
+        @tui.text_span(content: "#{t("Now")}: #{Time.now.utc}    "),
+        @tui.text_span(content: "#{t("Locale")}: #{@lang}")
+      ]
+
+      if current_tab.data[:filter]
+        @filter_style = @tui.style(fg: :white, bg: :dark_gray)
+        footer += [
+          @tui.text_span(content: "   #{t("Filter")}: ", style: @filter_style),
+          @tui.text_span(content: current_tab.data[:filter], style: @filter_style),
+          @tui.text_span(content: "_", style: @tui.style(fg: :white, bg: :dark_gray, modifiers: [:slow_blink]))
+        ]
+      end
+      footer << @tui.text_span(content: "  FPS: #{previous_fps}") if debugging?
+      lines << @tui.text_line(spans: footer)
+
+      controls = @tui.block(title: t("Controls"), borders: [:all],
+        children: [@tui.paragraph(text: lines)])
+      frame.render_widget(controls, area)
+    end
+
+    def handle_input
+      # We shouldn't need more than 10 FPS for a data-oriented app.
+      # This throttles down our CPU usage. Default is 60 FPS.
+      case @tui.poll_event(timeout: 0.1)
+      in {type: :key, code: "esc"} if @showing == :help
+        @showing = :main
+      in {type: :key, code: code} if current_tab.filtering? && code.length == 1
+        current_tab.append_to_filter(code)
+        current_tab.refresh_data
+      in {type: :key, code:, modifiers:}
+        control = current_tab.controls.find { |ctrl|
+          ctrl[:code] == code &&
+            (ctrl[:modifiers] || []) == (modifiers || [])
+        }
+        return unless control
+        control[:action].call(self, current_tab).tap {
+          refresh_data if control[:refresh]
+        }
+      else
+        # Ignore other events
+      end
+    rescue => ex
+      logger.error { [ex.message, ex.backtrace] }
+    end
+
+    def redis_url
+      Sidekiq.redis do |conn|
+        conn.config.server_url
+      end
+    rescue
+      "N/A"
+    end
+
+    def should_refresh?
+      Time.now - @last_refresh >= REFRESH_INTERVAL_SECONDS
+    end
+
+    def refresh_data
+      # logger.info GC.stat
+      current_tab.refresh_data
+      @last_refresh = Time.now
+    rescue => e
+      handle_exception(e)
+      current_tab.error = e
+    end
+
+    def render_error(frame, area, err)
+      header = [@tui.text_line(
+        spans: [@tui.text_span(content: err.message, style: @tui.style(modifiers: [:bold]))],
+        alignment: :center
+      )]
+      lines = Array(err.backtrace).map { |line| @tui.text_line(spans: [@tui.text_span(content: line)]) }
+
+      frame.render_widget(
+        @tui.paragraph(
+          text: header + lines,
+          alignment: :left,
+          block: @tui.block(title: t("Error"), borders: [:all], border_style: @tui.style(fg: :light_red))
+        ),
+        area
+      )
+    end
+
+    def show_help
+      @showing = :help
+    end
+
+    def all
+      @all ||= Tabs::All.map { |kls| kls.new(self) }
+    end
+
+    def current_tab
+      @current ||= @all.first
+    end
+
+    # Navigate tabs to the left or right.
+    # @param direction [Symbol] :left or :right
+    def navigate(direction)
+      index_change = (direction == :right) ? 1 : -1
+      @current = @all[(@all.index(current_tab) + index_change) % @all.size]
+      @current.reset_data
+    end
+
+    public def t(msg, options = nil)
+      string = @strings[msg] || msg
+      if options.nil?
+        string
+      else
+        string % options
+      end
+    end
+
+    def load_strings(lang)
+      {}.tap do |all|
+        find_locale_files(lang).each do |file|
+          strs = YAML.safe_load_file(file)
+          all.merge! strs[lang]
+        end
+      end
+    end
+
+    def locale_files
+      @@locale_files ||= LOCALE_DIRECTORIES.flat_map { |path|
+        Dir["#{path}/*.yml"]
+      }
+    end
+
+    def available_locales
+      @@available_locales ||= Set.new(locale_files.map { |path| File.basename(path, ".yml") })
+    end
+
+    def find_locale_files(lang)
+      locale_files.select { |file| file =~ /\/#{lang}\.yml$/ }
+    end
+
+    def load_locale
+      require "yaml"
+      lang = @lang.split(".").first # "en_US"
+      while lang.size > 0
+        hash = load_strings(lang)
+        if hash.size > 0
+          # found a working language dataset
+          @lang = lang
+          @strings = hash
+          Sidekiq.logger.debug { "using the #{lang} locale" }
+          break
+        end
+        # Try "en_US", "en_U", "en_", "en"
+        # It's ugly and bruteforce but it works
+        lang = lang[..-2]
+      end
+    end
+
+    def track_fps
+      # We hold two fps buckets: one for current second, one for previous second
+      idx = Time.now.to_i % 2
+      @fps[idx] += 1
+      yield
+    end
+
+    def previous_fps
+      curidx = Time.now.to_i % 2
+      prev = (curidx == 1) ? 0 : 1
+      if (val = @fps[prev]) != 0
+        @previous_fps = val
+        @fps[prev] = 0
+      end
+      @previous_fps
+    end
+
+    def debugging?
+      !!ENV["DEBUG"]
+    end
+  end
+end

data/lib/sidekiq/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Sidekiq
-  VERSION = "8.1.0"
+  VERSION = "8.1.2"
   MAJOR = 8
 
   def self.gem_version

data/lib/sidekiq/web/application.rb

@@ -99,8 +99,8 @@ module Sidekiq
         if url_params("identity")
           pro = Sidekiq::ProcessSet[url_params("identity")]
 
-          pro.quiet! if url_params("quiet")
-          pro.stop! if url_params("stop")
+          pro&.quiet! if url_params("quiet")
+          pro&.stop! if url_params("stop")
         else
           processes.each do |pro|
             next if pro.embedded?

data/lib/sidekiq/web/helpers.rb

@@ -287,6 +287,17 @@ module Sidekiq
       %(<time class="ltr" dir="ltr" title="#{stamp}" datetime="#{stamp}">#{time}</time>)
     end
 
+    def queue_names_by_capsule(pro)
+      cap = pro.capsules
+      if cap
+        cap.map { |k, v| v["weights"].keys.join(", ") }.join("; ")
+      else
+        # DEPRECATED Backwards compatibility with older processes.
+        # 'capsules' element added in v8.0.9
+        pro.queues.join(", ")
+      end
+    end
+
     def job_params(job, score)
       "#{score}-#{job["jid"]}"
     end

data/lib/sidekiq.rb

@@ -47,6 +47,13 @@ module Sidekiq
     puts "Take a deep breath and count to ten..."
   end
 
+  def self.testing!(mode = :fake, &block)
+    raise "Unknown testing mode: #{mode}" unless %i[fake disable inline].include?(mode)
+
+    require "sidekiq/test_api"
+    Sidekiq::Testing.__set_test_mode(mode, &block)
+  end
+
   def self.server?
     defined?(Sidekiq::CLI)
   end

data/sidekiq.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |gem|
   gem.homepage = "https://sidekiq.org"
   gem.license = "LGPL-3.0"
 
-  gem.executables = ["sidekiq", "sidekiqmon"]
+  gem.executables = ["sidekiq", "sidekiqmon", "kiq"]
   gem.files = %w[sidekiq.gemspec README.md Changes.md LICENSE.txt] + `git ls-files | grep -E '^(bin|lib|web)'`.split("\n")
   gem.name = "sidekiq"
   gem.version = Sidekiq::VERSION

data/web/assets/javascripts/application.js

@@ -154,7 +154,7 @@ function livePollCallback() {
 
 function checkResponse(resp) {
   if (!resp.ok) {
-    throw response.error();
+    throw resp.error();
   }
   return resp
 }