roundhouse_ui 0.10.0 → 0.11.0

data/app/helpers/roundhouse_ui/observability_helper.rb

@@ -1,48 +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
-
-      link_to "↗ #{adapter.label}", url, target: "_blank", rel: "noopener", class: "rh-trace"
+      trace_affordance(job_trace_url(klass: klass, jid: jid, queue: queue), as: :mark)
     end
 
-    # Icon-only variant for table rows. The adapter's name is worth reading once
-    # in a header or a detail page, not once per row — there it is width spent
-    # repeating a word the operator already knows.
     def trace_icon(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: :control)
+    end
 
-      link_to "↗", url, target: "_blank", rel: "noopener", class: "rh-trace rh-trace-ico",
-        title: "Open in #{adapter.label}", "aria-label": "Open in #{adapter.label}"
+    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 unless adapter.respond_to?(:error_url)
+      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
 
-      url = adapter.error_url(klass: klass, error: error)
-      return unless url
+    # 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)
 
-      link_to "↗", url, target: "_blank", rel: "noopener", class: "rh-trace rh-trace-ico",
-        title: "Open in #{adapter.label}", "aria-label": "Open in #{adapter.label}"
+      supplied.to_s.strip.start_with?("<") ? supplied.to_s.html_safe : icon(:trace_out)
     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)
+    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 unless adapter.respond_to?(:error_url)
+      return nil unless adapter.respond_to?(:error_url)
 
-      url = adapter.error_url(klass: klass, error: error)
-      return unless 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 trace_control(url, adapter, compact: compact) if as == :control
+
+      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

@@ -78,18 +78,45 @@ module RoundhouseUi
     # 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.
-    def filter_description(query, tag, queue = @queue_filter)
+    # `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.
-    def any_filter?(query, tag, queue = @queue_filter)
-      query.present? || !tag.nil? || queue.present?
+    # 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