roundhouse_ui 0.10.0 → 0.11.0

data/app/controllers/roundhouse_ui/queues_controller.rb

@@ -1,18 +1,70 @@
 module RoundhouseUi
   class QueuesController < ApplicationController
-    before_action :require_writable!, only: %i[purge pause resume]
+    include JobSetBrowsing
+
+    # Taking a backup writes nothing an operator can lose; restoring one does, and
+    # that stays guarded. This was previously expressed by omission from an `only:`
+    # list, which is indistinguishable from having forgotten.
+    allow_in_read_only :snapshot
+    requires_capability :snapshots, only: %i[snapshot]
+
+    # A queue is not a job, so class= and error= have nothing to apply to here.
+    # queue= narrows the LIST to one queue by exact name; free text stays a substring
+    # on the name. One grammar, one bar, honest about what it honours on this page.
+    INDEX_FILTER_KEYS = %w[queue text].freeze
 
     def index
-      @query = params[:q].to_s.strip
-      @queues = backend.queues
+      # Re-parsed against this page's key subset, not the job-set one: @filter from
+      # the concern's before_action honours class/error/tag, none of which can narrow
+      # a list of queues, and a pill that filters nothing is the phantom filter the
+      # bar exists to prevent.
+      @filter = FilterQuery.from_params(params, keys: INDEX_FILTER_KEYS)
+      @query = @filter.text
+      # queue_summaries reads depth and latency for every queue in one batch.
+      # Mapping over backend.queues instead costs a round-trip per queue per
+      # column, which on an app with sixty queues is most of a page render.
+      @queues = backend.queue_summaries
+      @total_size = @queues.sum(&:size)
+      @queues = [] if @filter.invalid?
       @queues = @queues.select { |q| q.name.to_s.downcase.include?(@query.downcase) } if @query.present?
+      # queue= is exact, the same as everywhere else, so a queue pill clicked on a
+      # job row and one typed here mean the same thing.
+      @queues = @queues.select { |q| @filter.matches_facet?(:queue, q.name) } if @filter.queue
+      # Worst first, matching the dashboard and Sidekiq's own convention. Sorted
+      # by name the one backed-up queue sits wherever the alphabet puts it,
+      # behind however many rows of zeros.
+      @queues = @queues.sort_by { |q| [ -q.latency.to_f, -q.size.to_i, q.name.to_s ] }
       @paused = backend.paused_queues
+      # State filter. Counts come from the unfiltered set so the chips still say
+      # how many are on the other side of the filter — a chip that reads "0" once
+      # you have selected it is useless for getting back.
+      @state = params[:state].to_s
+      @state_counts = { "paused" => @queues.count { |q| @paused.include?(q.name) } }
+      @state_counts["active"] = @queues.size - @state_counts["paused"]
+      case @state
+      when "paused" then @queues = @queues.select { |q| @paused.include?(q.name) }
+      when "active" then @queues = @queues.reject { |q| @paused.include?(q.name) }
+      end
       # Native-pause backends (Solid Queue) enforce pauses without a fetcher, so
       # they never trigger the "not enforced" warning.
       @fetch_installed = backend.supports?(:native_pause) ||
                          (backend.respond_to?(:fetch_installed?) && backend.fetch_installed?)
     end
 
+    # The jobs waiting on one queue — what Sidekiq Web shows and we did not.
+    # Goes through the shared browse path, so it pages rather than loading a
+    # queue that could hold hundreds of thousands of jobs, and inherits search
+    # and the tag filter for free.
+    def show
+      @name = params[:name]
+      @page = [ params[:page].to_i, 1 ].max
+      summary = backend.queue_summaries.find { |q| q.name == @name }
+      @total = summary&.size.to_i
+      @latency = summary&.latency
+      @paused = backend.paused_queues.include?(@name)
+      @jobs, @has_next = browse(backend.queue_jobs(@name), @query, @page, PER_PAGE, tag: @tag)
+    end
+
     # Real, OSS-supported destructive action: empties the queue in Redis.
     def purge
       backend.queue(params[:name]).clear
@@ -37,9 +89,6 @@ module RoundhouseUi
 
     private
 
-    def require_writable!
-      return unless RoundhouseUi.read_only
-      redirect_to queues_path, alert: "Roundhouse is in read-only mode — queue actions are disabled."
-    end
+    def read_only_redirect_path = queues_path
   end
 end

data/app/controllers/roundhouse_ui/recurring_controller.rb

@@ -0,0 +1,12 @@
+module RoundhouseUi
+  # Periodic work, whichever scheduler defines it. Read-only: the schedule
+  # belongs in the code that declares it, and a UI that silently changes a
+  # production schedule is a different risk conversation. See #62.
+  class RecurringController < ApplicationController
+    def index
+      @tasks = Recurring.tasks
+      @sources = @tasks.map(&:source).uniq
+      @overdue = @tasks.count { |t| t.status == :overdue }
+    end
+  end
+end

data/app/controllers/roundhouse_ui/retries_controller.rb

@@ -2,14 +2,11 @@ module RoundhouseUi
   class RetriesController < ApplicationController
     include JobSetBrowsing
 
-    before_action :require_writable!, only: %i[requeue destroy bulk_all]
+    guard_in_read_only :preview
 
     def index
-      @query = params[:q].to_s.strip
       @page  = [ params[:page].to_i, 1 ].max
       @total = backend.retry_set.size
-      @tag = tag_filter
-      @queue_filter = queue_filter
       @jobs, @has_next = browse(backend.retry_set, @query, @page, PER_PAGE, tag: @tag)
     end
 
@@ -29,19 +26,43 @@ module RoundhouseUi
     # Smart bulk: retry/delete EVERY job matching the current filter, capped for
     # safety. Offered only when a filter is active.
     def bulk_all
-      @queue_filter = queue_filter
-      count, capped = bulk_apply(backend.retry_set, params[:q].to_s.strip, params[:op], BULK_CAP, tag: tag_filter)
+      found = bulk_apply(backend.retry_set, @query, params[:op], BULK_CAP, tag: @tag)
+
+      # An unfiltered bulk_all selected every entry and reported it as a match.
+      # The comment above claimed this was "only offered when a filter is active" —
+      # and it was only OFFERED that way; the route had no gate. bulk_matches now
+      # refuses at the chokepoint, and this says so out loud rather than reporting
+      # "Deleted 0 matching job(s)", which would read like an empty set.
+      if found.unfiltered
+        return redirect_to retries_path, alert: found.reason
+      end
+
       verb = params[:op] == "delete" ? "Deleted" : "Re-enqueued"
-      note = "#{verb} #{count} matching job(s)."
-      note += " Stopped at the #{JobSetBrowsing::BULK_CAP} cap — run again for more." if capped
+      note = "#{verb} #{found.entries.size} matching job(s)."
+      note += " Stopped at the #{JobSetBrowsing::BULK_CAP} cap — run again for more." if found.capped
       redirect_to retries_path, notice: note
     end
 
+    # A dry run: the count tells you how many match, this tells you which (#37).
+    def preview
+      @op = params[:op] == "delete" ? "delete" : "retry"
+      @matched = bulk_matches(backend.retry_set, @query, JobSetBrowsing::BULK_CAP, tag: @tag)
+      @confirm_path = bulk_all_retries_path
+      @back_path = retries_path
+      # "retry", not "retries". bulk_preview renders job_path(set: @set) per row, and
+      # routes constrain set to /dead|retry|scheduled/ — so this 500'd the dry run
+      # before every bulk delete on this page, but ONLY when at least one job
+      # matched, because the template touches job_path inside the row loop. An empty
+      # preview rendered fine, which is why nothing noticed. Copied from
+      # dead_controller with the noun substituted; see also the concern this pair
+      # should share.
+      @set = "retry"
+      @noun = "retry"
+      render "roundhouse_ui/shared/bulk_preview"
+    end
+
     private
 
-    def require_writable!
-      return unless RoundhouseUi.read_only
-      redirect_to retries_path, alert: "Roundhouse is in read-only mode — retry and delete are disabled."
-    end
+    def read_only_redirect_path = retries_path
   end
 end

data/app/controllers/roundhouse_ui/scheduled_controller.rb

@@ -2,14 +2,12 @@ module RoundhouseUi
   class ScheduledController < ApplicationController
     include JobSetBrowsing
 
-    before_action :require_writable!, only: %i[enqueue destroy]
+    # add_to_queue is unimplemented outside Sidekiq.
+    requires_capability :enqueue_now, only: %i[enqueue]
 
     def index
-      @query = params[:q].to_s.strip
       @page  = [ params[:page].to_i, 1 ].max
       @total = backend.scheduled_set.size
-      @tag = tag_filter
-      @queue_filter = queue_filter
       @jobs, @has_next = browse(backend.scheduled_set, @query, @page, PER_PAGE, tag: @tag)
     end
 
@@ -28,9 +26,6 @@ module RoundhouseUi
 
     private
 
-    def require_writable!
-      return unless RoundhouseUi.read_only
-      redirect_to scheduled_path, alert: "Roundhouse is in read-only mode — enqueue and delete are disabled."
-    end
+    def read_only_redirect_path = scheduled_path
   end
 end

data/app/controllers/roundhouse_ui/settings_controller.rb

@@ -0,0 +1,15 @@
+module RoundhouseUi
+  # Per-viewer preferences. Everything here is stored in the browser and applied
+  # client-side — nothing is written server-side, so one operator's choices never
+  # change what anyone else sees, and there is no state to migrate or clean up.
+  #
+  # The server's only job is to say what is on offer: which palettes exist, and
+  # what the host defaults are when a viewer has expressed no preference.
+  class SettingsController < ApplicationController
+    def show
+      @palettes = Theme.selectable
+      @host_poll = RoundhouseUi.poll_interval
+      @host_theme = RoundhouseUi.theme.present?
+    end
+  end
+end

data/app/controllers/roundhouse_ui/snapshots_controller.rb

@@ -1,7 +1,9 @@
 module RoundhouseUi
   class SnapshotsController < ApplicationController
-    before_action :require_writable!, only: %i[restore destroy]
-
+    # Snapshots read Sidekiq's queues through Redis. On a backend without either they
+    # captured zero jobs and said "Snapshot saved" — beside a Purge telling you to
+    # snapshot first.
+    requires_capability :snapshots, only: %i[index show restore destroy create]
     def index
       @snapshots = RoundhouseUi::Snapshots.all
     end
@@ -18,9 +20,6 @@ module RoundhouseUi
 
     private
 
-    def require_writable!
-      return unless RoundhouseUi.read_only
-      redirect_to snapshots_path, alert: "Roundhouse is in read-only mode — restore and delete are disabled."
-    end
+    def read_only_redirect_path = snapshots_path
   end
 end

data/app/controllers/roundhouse_ui/workers_controller.rb

@@ -2,8 +2,6 @@ module RoundhouseUi
   # The running Sidekiq process fleet, straight from Sidekiq::ProcessSet.
   # "Quiet" stops a process from pulling new work; "Stop" begins shutdown.
   class WorkersController < ApplicationController
-    before_action :require_writable!, only: %i[quiet stop]
-
     def index
       @processes = backend.process_set.to_a
       @fetch_active = RoundhouseUi::Pause.fetch_installed?
@@ -21,13 +19,10 @@ module RoundhouseUi
 
     private
 
+    def read_only_redirect_path = workers_path
+
     def find_process(identity)
       backend.process_set.find { |process| process.identity == identity }
     end
-
-    def require_writable!
-      return unless RoundhouseUi.read_only
-      redirect_to workers_path, alert: "Roundhouse is in read-only mode — quiet and stop are disabled."
-    end
   end
 end

data/app/helpers/roundhouse_ui/application_helper.rb

@@ -1,5 +1,13 @@
 module RoundhouseUi
   module ApplicationHelper
+    # The class name a row should show: the real job class, not the ActiveJob
+    # adapter's wrapper. Resolved here rather than in each template so every
+    # surface prints the string the Errors page groups on and the APM link
+    # searches for.
+    def job_display_class(entry)
+      RoundhouseUi.unwrapped_class(entry.klass, entry.item)
+    end
+
     # A job row's identity cell. Class on the first line where the eye lands,
     # jid on a second, dimmer line — one long line of class + hex + link is
     # unreadable once the row also carries squad, queue and error.
@@ -10,6 +18,85 @@ module RoundhouseUi
       ])
     end
 
+    # A URL that keeps every active filter, naming only what changes. Pass a key
+    # as nil to clear just that one.
+    #
+    # Never enumerate filter params by hand in a view. That is what let the pager
+    # drop the class filter on page two, and the confirm form drop it between the
+    # dry run and the deletion.
+    # Editing needs BOTH the host's opt-in and a backend that can push. Six views
+    # read the config flag directly; only this reads the capability too.
+    def job_editing?
+      RoundhouseUi.allow_job_editing && RoundhouseUi.backend.supports?(:enqueue)
+    end
+
+    # Override keys that name a facet, and the FilterQuery field each one sets.
+    # Anything not listed here is transport (page, op) and passes straight through.
+    FACET_OVERRIDES = { class: :klass, error: :error, queue: :queue, tag: :tag }.freeze
+
+    def filter_params(overrides = {})
+      return overrides.compact unless respond_to?(:active_filters)
+
+      # A facet override edits the QUERY, it does not add a parameter. The filter
+      # now travels as one `?q=` string, so `filter_url(class: nil)` had to stop
+      # meaning "send class=nil alongside q" — which would have left the class
+      # sitting inside q, untouched, while the link claimed to clear it. Every ×
+      # in the console is one of these calls.
+      query = @filter || FilterQuery.none
+      transport = {}
+      overrides.each do |key, value|
+        # `q:` replaces the whole query — the one override that is not a facet edit.
+        # Left in transport it would have emitted a second q beside the real one.
+        next query = FilterQuery.parse(value) if key == :q
+
+        field = FACET_OVERRIDES[key]
+        field ? query = query.merge(field => value) : transport[key] = value
+      end
+
+      { q: query.to_s.presence }.compact.merge(transport.compact)
+    end
+
+    def filter_url(overrides = {})
+      url_for(filter_params(overrides).merge(only_path: true))
+    end
+
+    # Where "find more like this" goes, per set.
+    LIKE_PATHS = { "dead" => :dead_set_path, "retry" => :retries_path,
+                   "scheduled" => :scheduled_path }.freeze
+
+    # "Find more like this": the same class, and where the set records one, the
+    # same error — the pair the Errors page already treats as one issue, so a row
+    # here and a row there mean the same thing.
+    #
+    # Emitted as exact class=/error= facets in ?q= — the same string you could type.
+    # No %, because this button reveals "delete all matching".
+    def find_like_link(set, job)
+      helper = LIKE_PATHS[set.to_s]
+      klass = job_display_class(job)
+      return nil if helper.nil? || klass.blank?
+
+      error = job.item["error_class"].presence
+      label = error ? "Find more #{klass} failing with #{error}" : "Find more #{klass}"
+      # Built through from_params, not build: build does not validate, so a class
+      # name carrying a quote would produce a link whose own q= the next request
+      # refuses — a control that visibly does nothing. No representable filter,
+      # no button.
+      # Braced: from_params takes a keyword now, so a bare `class:` would be read as
+      # one and leave the positional hash empty.
+      filter = FilterQuery.from_params({ class: klass, error: error })
+      return nil if filter.invalid?
+
+      query = { q: filter.to_s }
+
+      # No size modifier: it takes the page scale, like every other control in the
+      # Actions column it sits in. Asking for --sm here was picking a scale step by
+      # hand next to 30px siblings — the scale stopped arbitrary pixels, it could
+      # not stop me choosing the wrong one of the two it offers.
+      link_to icon(:filter), send(helper, **query),
+              class: "rh-btn rh-btn--icon", title: label,
+              aria: { label: label }
+    end
+
     # Relative time answers "is this soon?", the clock time answers "does that
     # land inside the maintenance window?". Operators need both, so show both
     # rather than making them hover or do the arithmetic.
@@ -23,17 +110,175 @@ module RoundhouseUi
       ], " · ")
     end
 
+    # The placeholder, BUILT from the facets the page honours rather than written out
+    # per page. Five pages had five hand-written strings — "search class, jid, error,
+    # or arg value…", "filter by job class, error, or squad…", "filter queues by
+    # name…" — none of which mentioned that `class=` was a thing you could type. A
+    # hand-written hint next to a grammar is a hint that goes stale the day the
+    # grammar changes, and it went stale the day the grammar shipped.
+    def filter_placeholder(keys = FilterQuery::KEYS, noun: "text")
+      facets = keys.reject { |k| k == "text" }
+      facets -= [ "tag" ] unless RoundhouseUi.job_tags
+      return "search #{noun}…" if facets.empty?
+
+      "#{facets.map { |k| "#{k}=" }.join(" ")} or just type to search #{noun}"
+    end
+
+    # What the bar can complete. Keys always; tag values from the host's DECLARED
+    # vocabulary and queue names from the set the page already knows about — both
+    # free, no extra scan.
+    #
+    # `class=` and `error=` values are deliberately absent: enumerating them means
+    # reading every entry in the set on every render, and the whole reason browse
+    # reads only one page is that a 50k dead set must stay cheap to open. Type them;
+    # the funnel on each row fills them in for you.
+    def filter_vocabulary
+      vocab = {}
+      declared = RoundhouseUi::Tags.filters
+      if declared.present?
+        pairs = declared.flat_map { |key, values| Array(values).map { |v| "#{key}:#{v}" } }
+        vocab["tag"] = pairs if pairs.any?
+      end
+      names = Array(@queues).map { |q| q.respond_to?(:name) ? q.name.to_s : q.to_s }.reject(&:empty?)
+      names = [ @name.to_s ] if names.empty? && @name.present?
+      vocab["queue"] = names.uniq.sort if names.any?
+      vocab
+    end
+
+    # Is the page showing a SUBSET of the set? A different question from
+    # any_filter?, which asks whether a filter may authorise a bulk action — and
+    # answers no for a refused query, deliberately and correctly.
+    #
+    # Reusing the authorisation predicate for display made a refusal render as
+    # "nothing is filtered". Every typo now refuses, where once only a 500-character
+    # query did, so `clas=Foo` in the box produced the heading "Dead set · 24 jobs"
+    # and the cell "Dead set is empty 🎉" — above twenty-four dead jobs, with a
+    # tick of congratulation. Found by looking at the running page; no test asked.
+    # Asks the FILTER, never the bulk gate. Routing display through any_filter?
+    # produced the same bug twice: a refused query rendered as "nothing filtered"
+    # (heading "Dead set · 24 jobs" over "Dead set is empty 🎉"), and then a degraded
+    # one did too — `tag=garbage queue=ai` drops the tag, applies the queue, and
+    # still claimed the whole set. any_filter? answers "may this authorise a bulk
+    # action" and correctly says no in both cases; it is not a display predicate and
+    # is no longer used as one.
+    def filtered_view?(query, tag)
+      return true if @filter&.invalid? # selects nothing, which is a subset
+      return @filter.any? if @filter   # whatever SURVIVED parsing, dropped facets and all
+
+      any_filter?(query, tag)
+    end
+
+    # What an empty table says. Three cases, not two: the search was refused, the
+    # surviving filter matched nothing, or the set really is empty. Only the third
+    # gets the 🎉 — it used to get it in all three.
+    def empty_state(query, tag, all_clear:, noun: "jobs")
+      return "Nothing matched — the search above was not understood." if @filter&.invalid?
+      return "No #{noun} #{filter_description(query, tag)}." if filtered_view?(query, tag)
+
+      all_clear
+    end
+
     # Set heading that tells the truth under a filter. It used to always print
     # the whole-set size, so "Dead set · 19 jobs" sat above four filtered rows.
     def set_heading(label, showing:, total:, query: nil, tag: nil)
-      filtered = any_filter?(query, tag)
+      filtered = filtered_view?(query, tag)
       count = filtered ? "#{number_with_delimiter showing} of #{number_with_delimiter total}" : number_with_delimiter(total)
-      content_tag(:h2, class: "rh-h2") do
-        safe_join([
-          "#{label} · #{count} jobs",
-          (filtered ? content_tag(:span, filter_description(query, tag), class: "hint") : nil)
-        ].compact, " ")
+      # No prose restatement. The pills in the bar say which filters are on, in the
+      # same words you would type to reproduce them; the heading's job is the count.
+      # Saying it a second time in prose ("tagged squad: platform and failing with
+      # KeyError") was one of the four places one filter was rendered, and the one
+      # that could not be clicked to change it. filter_description still earns its
+      # place on the bulk confirm, where the sentence IS the thing being approved.
+      content_tag(:h2, "#{label} · #{count} jobs", class: "rh-h2")
+    end
+
+    # A one-line, redacted preview of a job's arguments. Sidekiq Web shows args
+    # in its queue listing and we did not, which made a queue of one class
+    # indistinguishable row to row — the whole question being "which of these is
+    # the one I care about".
+    #
+    # Truncated on purpose: the job page is where the full payload belongs, and a
+    # queue listing left open on a second monitor is the wrong place for a long
+    # arguments dump. Redaction still applies, but it is key-based, so a bare
+    # positional secret is not masked — same caveat as everywhere else args show.
+    def job_args_preview(entry, length: 70)
+      args = entry.args
+      return content_tag(:span, "—", class: "rh-sub") if args.blank?
+
+      full = RoundhouseUi::Redaction.apply(args).map { |a| a.is_a?(String) ? a : a.inspect }.join(", ")
+      content_tag(:span, truncate(full, length: length), class: "rh-sub rh-mono", title: full)
+    end
+
+    # Compact duration. Raw seconds stop being readable somewhere around a minute
+    # and are actively useless by four figures — "10058.0s" is nearly three hours
+    # and nobody reads it as that. Two units is all anyone acts on. See #31.
+    # Both delegate to RoundhouseUi so views and lib/ cannot drift apart again.
+    def duration(seconds) = RoundhouseUi.duration(seconds)
+    def duration_ms(ms) = RoundhouseUi.duration_ms(ms)
+
+    # Retry attempt as a ladder rather than a number. "retry 21" and "retry 3"
+    # are the same shape of text; twenty-one filled rungs going red is not. The
+    # count stays beside it, because a ladder answers "how bad" and not "how many".
+    def attempt_ladder(count, max = 25)
+      filled = count.to_i.clamp(0, max)
+      rungs = Array.new(max) do |i|
+        state = if i >= filled then nil
+        elsif filled > (max * 0.6) then "is-hot"
+        else "is-on"
+        end
+        content_tag(:i, "", class: state)
+      end
+      safe_join([
+        content_tag(:span, safe_join(rungs), class: "rh-ladder",
+                    title: "attempt #{filled} of #{max}", aria: { hidden: true }),
+        content_tag(:span, "#{filled}/#{max}", class: "rh-sub rh-ladder-n")
+      ])
+    end
+
+    # How far through the wait a scheduled or retrying job is, as a ring. A job
+    # about to fire should not look like one parked for six hours.
+    #
+    # `since` is when the wait started; without it the ring cannot know the
+    # fraction and renders empty rather than guessing.
+    def countdown(at, since: nil, label: nil)
+      return content_tag(:span, "—", class: "rh-sub") if at.nil?
+
+      remaining = at.to_f - Time.now.to_f
+      turn = if since && (total = at.to_f - since.to_f) > 0
+        (1.0 - (remaining / total)).clamp(0.0, 1.0)
+      else
+        remaining <= 0 ? 1.0 : 0.0
       end
+      safe_join([
+        content_tag(:span, "", class: "rh-ring", style: "--rh-turn:#{turn.round(3)}turn",
+                    aria: { hidden: true }),
+        content_tag(:span, label || job_time(at, overdue: "now"), class: "rh-sub")
+      ])
+    end
+
+    # An icon by name. Inline SVG by default; a class name when the host has its
+    # own icon font. Only our own SVG constants are marked html_safe — a
+    # host-supplied class name goes through content_tag and is escaped.
+    def icon(name, extra_class: nil)
+      markup = RoundhouseUi::Icons.markup(name)
+      return "".html_safe unless markup
+
+      if markup.start_with?("<svg")
+        content_tag(:span, markup.html_safe, class: [ "rh-ico", extra_class ].compact.join(" "))
+      else
+        content_tag(:i, "", class: [ markup, "rh-ico", extra_class ].compact.join(" "), aria: { hidden: true })
+      end
+    end
+
+    # The runbook for a job, as a link, or nil when the host declared none (#39).
+    # Cached per class per request like tags — the same page can ask for the same
+    # class dozens of times.
+    def runbook_link(klass, item = nil, label: "Runbook")
+      url = RoundhouseUi::Runbooks.for(klass, item, cache: (@rh_runbook_cache ||= {}))
+      return nil unless url
+
+      link_to label, url, class: "rh-runbook", target: "_blank", rel: "noopener noreferrer",
+        title: "Open the runbook for #{RoundhouseUi.unwrapped_class(klass, item)}"
     end
 
     # Queues carry meaning at a glance (critical vs low), so render them as a
@@ -43,10 +288,8 @@ module RoundhouseUi
     def queue_pill(name, link: false)
       return content_tag(:span, name, class: "rh-pill rh-mono") unless link
 
-      active = @queue_filter == name.to_s
-      link_to name, url_for(only_path: true, page: nil, q: @query.presence,
-                            tag: params[:tag].presence,
-                            queue: (active ? nil : name)),
+      active = (@filter&.queue) == name.to_s
+      link_to name, filter_url(page: nil, queue: (active ? nil : name)),
         class: "rh-pill rh-mono rh-pill-link#{' is-on' if active}",
         title: active ? "Clear queue filter" : "Show only #{name}"
     end

data/app/helpers/roundhouse_ui/nav_helper.rb

@@ -2,13 +2,13 @@ module RoundhouseUi
   module NavHelper
     # A sidebar nav item with active state and an optional live-updating badge
     # (filled client-side from /stats via the poll in the layout).
-    def nav_link(label, path, icon:, badge: nil, badge_class: nil)
+    def nav_link(label, path, icon:, badge: nil, badge_class: nil, badge_title: nil)
       here = request.path == path || (path != root_path && request.path.start_with?(path))
       link_to path, class: "rh-nav#{' is-active' if here}" do
         safe_join([
-          content_tag(:span, icon, class: "rh-ico"),
+          icon(icon),
           content_tag(:span, label, class: "rh-lbl"),
-          badge ? content_tag(:span, "", class: "rh-badge #{badge_class}", data: { nav: badge }) : "".html_safe
+          badge ? content_tag(:span, "", class: "rh-badge #{badge_class}", title: badge_title, data: { nav: badge }) : "".html_safe
         ])
       end
     end