roundhouse_ui 0.9.1 → 0.11.0

data/app/helpers/roundhouse_ui/observability_helper.rb

@@ -1,25 +1,134 @@
 module RoundhouseUi
+  # Links out to whatever APM the host configured. Four entry points — job or
+  # error, by historical call-site name — and exactly one appearance. They were
+  # four hand-rolled copies once, and only some got updated: two still emitted a
+  # literal ↗ after the rest moved to SVG. Later the split survived as two
+  # different shapes, a text link and a bordered box, which is not "one
+  # appearance" however the helper described itself.
   module ObservabilityHelper
-    # Renders a deep-link to the configured observability tool for a job, or
-    # nothing when no adapter is configured (the default).
     def trace_link(klass:, jid:, queue: nil)
-      adapter = RoundhouseUi.observability
-      url = adapter.job_url(klass: klass, jid: jid, queue: queue)
-      return unless url
+      trace_affordance(job_trace_url(klass: klass, jid: jid, queue: queue), as: :mark)
+    end
 
-      link_to "↗ #{adapter.label}", url, target: "_blank", rel: "noopener", class: "rh-trace"
+    def trace_icon(klass:, jid:, queue: nil)
+      trace_affordance(job_trace_url(klass: klass, jid: jid, queue: queue), as: :control)
     end
 
-    # Deep-link for a grouped error row (no single JID) — a class-wide search.
-    # respond_to? keeps older/custom adapters that lack error_url working.
     def error_trace_link(klass:, error: nil)
+      trace_affordance(error_trace_url(klass: klass, error: error), as: :mark)
+    end
+
+    def error_trace_icon(klass:, error: nil)
+      trace_affordance(error_trace_url(klass: klass, error: error), as: :control, compact: true)
+    end
+
+    # Says once, above a table, where every row's trace glyph goes. Takes the rows
+    # it is describing, because a legend above an empty table explains a control
+    # that is not on the page — which is exactly what "Nothing scheduled" under
+    # "Traces open in Datadog" looked like.
+    #
+    # Returns nil unless the adapter has a mark of its own, too: a plain adapter
+    # already labels every row, so there would be nothing to hoist.
+    def trace_legend(rows)
+      return nil if rows.blank?
+
+      adapter = RoundhouseUi.observability
+      return nil unless wordmark?(adapter)
+      return nil if adapter.job_url(klass: "Probe", jid: "probe").blank?
+
+      content_tag(:div, class: "rh-trace-legend") do
+        safe_join([ content_tag(:span, "Traces open in"), trace_glyph(adapter) ], " ")
+      end
+    end
+
+    # An adapter's own mark, when it supplies one. Three shapes are accepted, in
+    # descending order of how much we trust them:
+    #
+    #   :name      → one of Roundhouse's shipped icons
+    #   "<svg …>"  → the adapter's markup, rendered as-is
+    #   nil        → the default trace glyph
+    #
+    # The markup case is not escaped, because escaping renders the tags as text
+    # and the feature does not work at all. That is the same trust level as the
+    # adapter object itself, which can already run arbitrary code. Anything that
+    # is neither markup nor a known name falls back rather than printing stray
+    # text into a table.
+    def trace_glyph(adapter)
+      supplied = adapter.respond_to?(:icon) ? adapter.icon : nil
+      return icon(:trace_out) if supplied.blank?
+      return icon(supplied) if supplied.is_a?(Symbol)
+
+      supplied.to_s.strip.start_with?("<") ? supplied.to_s.html_safe : icon(:trace_out)
+    end
+
+    private
+
+    def job_trace_url(klass:, jid:, queue: nil)
+      RoundhouseUi.observability.job_url(klass: klass, jid: jid, queue: queue)
+    end
+
+    def error_trace_url(klass:, error: nil)
+      adapter = RoundhouseUi.observability
+      return nil unless adapter.respond_to?(:error_url)
+
+      adapter.error_url(klass: klass, error: error)
+    end
+
+    # Two contexts, one principle: a dense list gets a control, a single item
+    # gets the vendor's mark.
+    #
+    # In a table the mark would repeat on every row — 366 copies of someone
+    # else's logo on one Retries page, and the only unboxed thing in a column of
+    # bordered buttons. So rows get a Roundhouse glyph shaped exactly like the
+    # buttons beside it, and the page says once, above the table, where that
+    # glyph goes. On a page showing one job there is nothing to tile, so the
+    # mark itself goes inline where it has room to read.
+    #
+    # This is not the old `labelled` split, which was two arbitrary shapes with
+    # no stated rule. The distinction here is repetition, and `trace_legend` is
+    # what makes the row glyph legible without restating the brand per row.
+    def trace_affordance(url, as:, compact: false)
+      return nil if url.blank?
+
       adapter = RoundhouseUi.observability
-      return unless adapter.respond_to?(:error_url)
+      return trace_control(url, adapter, compact: compact) if as == :control
 
-      url = adapter.error_url(klass: klass, error: error)
-      return unless url
+      link_to trace_body(adapter), url, **trace_attrs(adapter),
+        class: "rh-trace#{' rh-trace-mark' if wordmark?(adapter)}"
+    end
+
+    # Shaped like whatever it sits beside. In an Actions column that is .rh-btn,
+    # so it lands level with Run now and Delete. Inline in a text cell it is
+    # .rh-runbook's smaller pill, because a 28px-tall button next to an 11.5px
+    # "runbook" link puts three different heights in one table cell.
+    #
+    # Never carries the vendor mark either way: boxing a logo is against most
+    # brand guidelines, Datadog's included.
+    def trace_control(url, adapter, compact: false)
+      # One class. Borrowing .rh-btn's or .rh-runbook's box was the previous fix
+      # for a 2px drift, and it still left two definitions to keep in step — the
+      # compact variant came out 2px taller than the runbook pill it sat beside.
+      # The control scale (#65) gives every control the same box from the same
+      # tokens, so there is nothing to borrow and nothing to synchronise.
+      base = compact ? "rh-trace-btn rh-btn--sm" : "rh-trace-btn"
+      link_to icon(:trace_out), url, **trace_attrs(adapter), class: base
+    end
+
+    def trace_body(adapter)
+      glyph = trace_glyph(adapter)
+      return glyph if wordmark?(adapter)
+
+      safe_join([ glyph, content_tag(:span, adapter.label) ])
+    end
+
+    def trace_attrs(adapter)
+      { target: "_blank", rel: "noopener noreferrer",
+        title: "Open in #{adapter.label}",
+        aria: { label: "Open in #{adapter.label}" } }
+    end
 
-      link_to "↗ #{adapter.label}", url, target: "_blank", rel: "noopener", class: "rh-trace"
+    def wordmark?(adapter)
+      adapter.respond_to?(:wordmark?) && adapter.wordmark?
     end
   end
 end

data/app/helpers/roundhouse_ui/tags_helper.rb

@@ -0,0 +1,128 @@
+module RoundhouseUi
+  # Renders host-defined job tags (see ADR 0002). Resolution is memoized for the
+  # life of the request: a page can render hundreds of rows, and ErrorGroups
+  # scans up to DEFAULT_SCAN_LIMIT entries, so the host's resolver must not be
+  # called once per row when it only varies by class.
+  module TagsHelper
+    # The per-request memo handed to Tags.for, shared with JobSetBrowsing so a
+    # class (or job) resolved while scanning is not resolved again when its
+    # badge renders. Tags.for chooses the key: class name normally, jid in
+    # per-job mode.
+    def tag_cache
+      @rh_tag_cache ||= {}
+    end
+
+    # Tags for one job entry, as a { "key" => "value" } Hash.
+    def tags_for(entry)
+      return Tags::EMPTY unless RoundhouseUi.job_tags
+
+      Tags.for(klass: entry.klass, item: entry.item, cache: tag_cache)
+    end
+
+    # Tags for a class name alone — used by grouped Errors, where every entry in
+    # a group shares a class, so a class-derived tag is constant for the group.
+    # Passes no payload, so a per-job resolver correctly declines rather than
+    # attributing one job's tags to the whole group.
+    def tags_for_class(klass)
+      return Tags::EMPTY unless RoundhouseUi.job_tags
+
+      Tags.for(klass: klass, item: {}, cache: tag_cache)
+    end
+
+    # Pills for a resolved tag Hash. Renders nothing when there are no tags, so
+    # every call site can be unconditional.
+    def tag_badges(tags)
+      return if tags.blank?
+
+      safe_join(tags.map { |key, value| tag_badge(key, value) }, " ")
+    end
+
+    # Tags get their own table column rather than an inline badge: class names
+    # vary wildly in length, so inline badges land at ragged x-positions and
+    # can't be scanned down. Only worth a column when a host configured tags.
+    def tag_column?
+      RoundhouseUi.job_tags.present?
+    end
+
+    # Header for that column. With the usual single dimension this is the tag's
+    # own name ("squad"); with several there's no one right label.
+    def tag_column_label
+      keys = Tags.filters&.keys
+      keys&.one? ? keys.first.titleize : "Tags"
+    end
+
+    # Cell contents. Stacks when a host defines more than one dimension.
+    def tag_cell(tags)
+      return content_tag(:span, "—", class: "rh-sub") if tags.blank?
+
+      tag_badges(tags)
+    end
+
+    # Values offered as filter chips where no counts are available. Prefers the
+    # host's declared vocabulary, so the chips stay put as you filter; falls back
+    # to whatever the visible rows happen to carry, which at least beats nothing
+    # but shifts as you page.
+    def tag_vocabulary
+      declared = Tags.filters
+      return declared if declared.present?
+
+      seen = Hash.new { |h, k| h[k] = [] }
+      Array(@jobs).each do |job|
+        tags_for(job).each { |key, value| seen[key] << value unless seen[key].include?(value) }
+      end
+      seen.transform_values(&:sort)
+    end
+
+    # Human description of the active filter set, so a bulk confirm names every
+    # constraint that will be applied — not just the text query.
+    # Every active constraint must appear here. A confirm that names only the
+    # text query while a queue or tag also narrows the set understates what is
+    # about to be destroyed.
+    # `filter` is the controller's parse, reached through the helper. One source for
+    # the prose, the predicate and the pill — a description built from a second
+    # reading of the filter is a description that can disagree with what was applied.
+    def rh_filter
+      controller.respond_to?(:filter, true) ? controller.send(:filter) : RoundhouseUi::FilterQuery.none
+    end
+
+    def filter_description(query, tag, queue = rh_filter.queue)
+      parts = []
+      parts << "matching “#{query}”" if query.present?
+      parts << "tagged #{tag[0]}: #{tag[1]}" if tag
+      parts << "in queue #{queue}" if queue.present?
+      parts << like_description if rh_filter.klass.present? || rh_filter.error.present?
+      parts.join(" and ")
+    end
+
+    # "find more like this", said back to you. The wording has to be exact about
+    # what it selected, because the bulk Delete sitting next to it acts on
+    # precisely this set and nothing wider.
+    def like_description
+      # Either half stands on its own. "every Timeout::Error, whatever the class"
+      # is a question worth asking, so clearing the class must not take the error
+      # with it — which is what it used to do.
+      return "failing with #{rh_filter.error}" if rh_filter.klass.blank?
+      return "like #{rh_filter.klass}" if rh_filter.error.blank?
+
+      "like #{rh_filter.klass} failing with #{rh_filter.error}"
+    end
+
+    # Any filter active? Bulk-on-match is filter-gated, so this decides whether
+    # the bulk bar renders at all — and which empty-state copy is honest.
+    # Delegates to the concern's predicate where it is available, so the button the
+    # view offers and the scope the route enforces cannot drift apart. They did:
+    # this returned true only for the view, while bulk_all had no gate at all.
+    def any_filter?(query, tag, queue = rh_filter.queue)
+      return controller.send(:bulk_filter_present?, query, tag) if controller.respond_to?(:bulk_filter_present?, true)
+
+      query.present? || !tag.nil? || queue.present? ||
+        rh_filter.klass.present? || rh_filter.error.present?
+    end
+
+    # Value only — the key is near-constant down a column, so repeating it is
+    # noise. It stays in the tooltip for hosts with more than one dimension.
+    def tag_badge(key, value)
+      content_tag(:span, value, class: "rh-pill rh-pill-tag", title: "#{key}: #{value}")
+    end
+  end
+end