sidekiq 8.1.1 → 8.1.3

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

@@ -0,0 +1,118 @@
+require_relative "base_tab"
+
+module Sidekiq
+  class TUI
+    module Tabs
+      class Busy < BaseTab
+        def features
+          %i[selectable]
+        end
+
+        def controls
+          @controls ||= super + [
+            {code: "T", modifiers: ["shift"], description: "Terminate", action: ->(tui, tab) { tab.terminate! }},
+            {code: "Q", modifiers: ["shift"], description: "Quiet", action: ->(tui, tab) { tab.quiet! }}
+          ]
+        end
+
+        def quiet!
+          each_selection do |id|
+            Sidekiq::Process.new("identity" => id).quiet!
+          end
+        end
+
+        def terminate!
+          each_selection do |id|
+            Sidekiq::Process.new("identity" => id).stop!
+          end
+        end
+
+        def refresh_data
+          refresh_data_for_stats
+
+          busy = []
+          table_row_ids = []
+
+          Sidekiq::ProcessSet.new.each do |p|
+            name = "#{p["hostname"]}:#{p["pid"]}"
+            name += " ⭐️" if p.leader?
+            name += " 🛑" if p.stopping?
+            busy << [
+              selected?(p) ? "✅" : "",
+              name,
+              Time.at(p["started_at"]).utc,
+              format_memory(p["rss"].to_i),
+              number_with_delimiter(p["concurrency"]),
+              number_with_delimiter(p["busy"])
+            ]
+            table_row_ids << p.identity
+          end
+
+          @data[:busy] = busy
+          @data[:table] = {row_ids: table_row_ids}
+        end
+
+        def render(tui, frame, area)
+          chunks = tui.layout_split(
+            area,
+            direction: :vertical,
+            constraints: [
+              tui.constraint_length(4), # Stats
+              tui.constraint_length(4), # Status
+              tui.constraint_fill(1)   # Graph
+            ]
+          )
+
+          render_stats_section(tui, frame, chunks[0])
+          render_status_section(tui, frame, chunks[1])
+          render_table(tui, frame, chunks[2]) do
+            {
+              title: t("Processes"),
+              header: ["☑️", "Name", "Started", "RSS", "Threads", "Busy"].map { |x| t(x) },
+              widths: [
+                tui.constraint_length(5),
+                tui.constraint_fill(1),
+                tui.constraint_length(24),
+                tui.constraint_length(10),
+                tui.constraint_length(6),
+                tui.constraint_length(6)
+              ],
+              rows: @data[:busy].map.with_index { |cells, idx|
+                tui.table_row(
+                  cells:,
+                  style: idx.even? ? nil : tui.style(bg: :dark_gray)
+                )
+              }
+            }
+          end
+        end
+
+        def render_status_section(tui, frame, area)
+          values = []
+          processes = Sidekiq::ProcessSet.new
+          workset = Sidekiq::WorkSet.new
+          ws = workset.size
+          values << (s = processes.size
+                     number_with_delimiter(s))
+          values << (x = processes.total_concurrency
+                     number_with_delimiter(x))
+          values << number_with_delimiter(ws)
+          values << "#{(x == 0) ? 0 : ((ws / x.to_f) * 100).round(0)}%"
+          values << format_memory(processes.total_rss)
+
+          keys = %w[Processes Threads Busy Utilization RSS]
+          keys_line = keys.map { |k| t(k).to_s.ljust(12) }.join("  ")
+          values_line = values.map { |v| v.to_s.ljust(12) }.join("  ")
+
+          frame.render_widget(
+            tui.paragraph(
+              text: [keys_line, values_line],
+              block: tui.block(title: t("Status"), borders: [:all])
+            ),
+            area
+          )
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,144 @@
+require_relative "base_tab"
+
+module Sidekiq
+  class TUI
+    module Tabs
+      class Home < BaseTab
+        def refresh_data
+          refresh_data_for_stats
+
+          stats = Sidekiq::Stats.new
+          @data[:chart] ||= {
+            previous_stats: {
+              processed: stats.processed,
+              failed: stats.failed
+            },
+            deltas: {
+              processed: Array.new(50, 0),
+              failed: Array.new(50, 0)
+            }
+          }
+
+          processed_delta = stats.processed - @data[:chart][:previous_stats][:processed]
+          failed_delta = stats.failed - @data[:chart][:previous_stats][:failed]
+
+          @data[:chart][:deltas][:processed].shift
+          @data[:chart][:deltas][:processed].push(processed_delta)
+          @data[:chart][:deltas][:failed].shift
+          @data[:chart][:deltas][:failed].push(failed_delta)
+
+          @data[:chart][:previous_stats] = {
+            processed: stats.processed,
+            failed: stats.failed
+          }
+
+          redis_info = Sidekiq.default_configuration.redis_info
+
+          @data[:redis_info] = {
+            version: redis_info["redis_version"] || "N/A",
+            uptime_days: redis_info["uptime_in_days"] || "N/A",
+            connected_clients: redis_info["connected_clients"] || "N/A",
+            used_memory: redis_info["used_memory_human"] || "N/A",
+            peak_memory: redis_info["used_memory_peak_human"] || "N/A"
+          }
+        end
+
+        def render(tui, frame, area)
+          chunks = tui.layout_split(
+            area,
+            direction: :vertical,
+            constraints: [
+              tui.constraint_length(4), # Stats
+              tui.constraint_fill(1),   # Graph
+              tui.constraint_length(4) # Redis
+            ]
+          )
+
+          render_stats_section(tui, frame, chunks[0])
+          render_chart_section(tui, frame, chunks[1])
+          render_redis_info_section(tui, frame, chunks[2])
+        end
+
+        def render_chart_section(tui, frame, area)
+          max_value = [@data[:chart][:deltas][:processed].max, @data[:chart][:deltas][:failed].max, 1].max
+          y_max = [max_value, 5].max
+
+          processed_data = @data[:chart][:deltas][:processed].each_with_index.map { |value, idx| [idx.to_f, value.to_f] }
+          failed_data = @data[:chart][:deltas][:failed].each_with_index.map { |value, idx| [idx.to_f, value.to_f] }
+
+          datasets = [
+            tui.dataset(
+              name: "",
+              data: processed_data,
+              style: tui.style(fg: :green),
+              marker: :dot,
+              graph_type: :line
+            ),
+            tui.dataset(
+              name: "",
+              data: failed_data,
+              style: tui.style(fg: :red),
+              marker: :dot,
+              graph_type: :line
+            )
+          ]
+
+          num_labels = 5
+          y_labels = (0...num_labels).map do |i|
+            value = ((y_max * i) / (num_labels - 1)).round
+            value.to_s
+          end
+
+          beacon_pulse = (Time.now.to_i % 2 == 0) ? "●" : " "
+
+          chart = tui.chart(
+            datasets: datasets,
+            x_axis: tui.axis(
+              bounds: [0.0, 49.0],
+              labels: [],
+              style: tui.style(fg: :white)
+            ),
+            y_axis: tui.axis(
+              bounds: [0.0, y_max.to_f],
+              labels: y_labels,
+              style: tui.style(fg: :white)
+            ),
+            block: tui.block(
+              title: "Dashboard #{beacon_pulse}",
+              borders: [:all]
+            )
+          )
+
+          frame.render_widget(chart, area)
+        end
+
+        def render_redis_info_section(tui, frame, area)
+          redis_info = @data[:redis_info]
+
+          uptime_value = (redis_info[:uptime_days] == "N/A") ? "N/A" : "#{redis_info[:uptime_days]} days"
+
+          keys = ["Version", "Uptime", "Connected Clients", "Memory Usage", "Peak Memory"]
+          values = [
+            redis_info[:version].to_s,
+            uptime_value,
+            redis_info[:connected_clients].to_s,
+            redis_info[:used_memory].to_s,
+            redis_info[:peak_memory].to_s
+          ]
+
+          # Format keys and values with spacing
+          keys_line = keys.map { |k| t(k).ljust(18) }.join("  ")
+          values_line = values.map { |v| v.ljust(18) }.join("  ")
+
+          frame.render_widget(
+            tui.paragraph(
+              text: [keys_line, values_line],
+              block: tui.block(title: "Redis Information", borders: [:all])
+            ),
+            area
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,131 @@
+require_relative "base_tab"
+
+module Sidekiq
+  class TUI
+    module Tabs
+      class Metrics < BaseTab
+        include Filtering
+
+        COLORS = %i[light_blue light_cyan light_yellow light_red light_green white gray]
+
+        def features
+          %i[filterable]
+        end
+
+        def on_filter_change
+          @data[:metrics_refresh] = nil
+        end
+
+        def regexp
+          filtering? ? Regexp.new(Regexp.escape(current_filter), Regexp::IGNORECASE) : nil
+        end
+
+        def refresh_data
+          refresh_data_for_stats
+
+          # only need to refresh every 60 seconds
+          if !@data[:metrics_refresh] || @data[:metrics_refresh] < Time.now
+            q = Sidekiq::Metrics::Query.new
+            query_result = q.top_jobs(class_filter: regexp, minutes: 60)
+            @data[:metrics] = query_result
+            @data[:metrics_refresh] = Time.now + 60
+          end
+        end
+
+        def render(tui, frame, area)
+          chunks = tui.layout_split(
+            area,
+            direction: :vertical,
+            constraints: [
+              tui.constraint_length(4), # Stats
+              tui.constraint_fill(1) # Chart
+              # TOOD Table
+            ]
+          )
+
+          render_stats_section(tui, frame, chunks[0])
+          render_metrics_chart(tui, frame, chunks[1])
+        end
+
+        # Run to generate metrics data:
+        #   cd myapp && bundle install
+        #   bundle exec rake seed_jobs
+        #   bundle exec sidekiq
+        def render_metrics_chart(tui, frame, area)
+          y_max = 5
+          csize = COLORS.size
+          q = @data[:metrics]
+          job_results = q.job_results.sort_by { |(kls, jr)| jr.totals["s"] }.reverse.first(COLORS.size)
+          # visible_kls = job_results.first(5).map(&:first)
+          # chart_data = {
+          #   series: job_results.map { |(kls, jr)| [kls, jr.dig("series", "s")] }.to_h,
+          #   marks: query_result.marks.map { |m| [m.bucket, m.label] },
+          #   starts_at: query_result.starts_at.iso8601,
+          #   ends_at: query_result.ends_at.iso8601,
+          #   visibleKls: visible_kls,
+          #   yLabel: 'TotalExecutionTime',
+          #   units: 'seconds',
+          #   markLabel: '*',
+          # }
+
+          datasets = job_results.map.with_index do |(kls, data), idx|
+            # log kls, data, idx
+            hrdata = data.dig("series", "s")
+            tm = Time.now
+            tmi = tm.to_i
+            tm = Time.at(tmi - (tmi % 60)).utc
+            data = Array.new(60) { |idx| idx }.map do |bucket_idx|
+              jumpback = bucket_idx * 60
+              value = hrdata[(tm - jumpback).iso8601] || 0
+              y_max = value if value > y_max
+              # we have 60 data points, newest data should be
+              # at highest indexes so we have to rejigger the index
+              # here
+              [59 - bucket_idx, value]
+            end
+            # log data
+
+            # log(data)
+            tui.dataset(name: kls,
+              data: data,
+              style: tui.style(fg: COLORS[idx % csize]),
+              marker: :dot,
+              graph_type: :line)
+          end
+
+          num_labels = 5
+          y_labels = (0...num_labels).map do |i|
+            value = ((y_max * i) / (num_labels - 1)).round
+            value.to_s
+          end
+          xlabels = [
+            q.starts_at.iso8601[11..15],
+            q.ends_at.iso8601[11..15]
+          ]
+
+          # beacon_pulse = (Time.now.to_i % 2 == 0) ? "●" : " "
+
+          chart = tui.chart(
+            datasets: datasets,
+            x_axis: tui.axis(
+              bounds: [0.0, 60.0],
+              labels: xlabels,
+              style: tui.style(fg: :white)
+            ),
+            y_axis: tui.axis(
+              bounds: [0.0, y_max.to_f],
+              labels: y_labels,
+              style: tui.style(fg: :white)
+            ),
+            block: tui.block(
+              title: t(name),
+              borders: [:all]
+            )
+          )
+
+          frame.render_widget(chart, area)
+        end
+      end
+    end
+  end
+end

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