sidekiq 6.5.10 → 8.1.7

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

@@ -0,0 +1,114 @@
+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 = stats_content_split(tui, area)
+
+          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
+
+          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: chart_y_axis(tui, y_max),
+            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,83 @@
+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 = stats_content_split(tui, area)
+
+          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: striped_rows(tui, @data[:queues])
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

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

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

@@ -0,0 +1,91 @@
+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
+          refresh_data_for_stats
+          refresh_data_for_set
+        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 = stats_content_split(tui, area)
+
+          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|
+              cells = @data[:table][:rows].map { |entry|
+                [
+                  selected?(entry) ? "✅" : "",
+                  entry.at,
+                  entry.queue,
+                  entry.display_class,
+                  entry.display_args
+                ]
+              }
+              h[:rows] = striped_rows(tui, cells)
+            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