rails_pulse 0.4.2 → 0.5.0.pre.2

data/app/services/rails_pulse/summary_service/from_raw_rows.rb

@@ -0,0 +1,115 @@
+module RailsPulse
+  class SummaryService
+    # Summary rows for an hour, computed from raw requests, operations, job
+    # runs and exception occurrences.
+    #
+    # Each kind is read with one query, sorted by summarizable and then
+    # duration so every summarizable's durations arrive as one consecutive,
+    # already-sorted run; the overall request row and the per-route rows
+    # share a single read. Memory is bounded by one hour's rows, and the
+    # hour costs one query per kind however many routes, queries or jobs it
+    # saw. Percentiles are exact.
+    #
+    # Rows carry the summarizable and its metrics; SummaryService adds the
+    # period columns.
+    class FromRawRows
+      def initialize(time_range)
+        @time_range = time_range
+      end
+
+      # Always exactly one row, even for an empty hour (see SummaryService).
+      def request_rows
+        durations = request_data.map { |_, duration, _| duration }.compact.sort
+        statuses = request_data.map { |_, _, status| status }
+
+        [ row("RailsPulse::Request", 0).merge(Metrics.duration(durations), Metrics.status(statuses)) ]
+      end
+
+      def route_rows
+        request_data.slice_when { |previous, current| previous.first != current.first }.map do |rows|
+          durations = rows.map { |_, duration, _| duration }
+          statuses = rows.map { |_, _, status| status }
+
+          row("RailsPulse::Route", rows.first.first).merge(
+            Metrics.duration(durations),
+            Metrics.status(statuses),
+            count: rows.size
+          )
+        end
+      end
+
+      def query_rows
+        rows_by_summarizable(Operation.where(occurred_at: @time_range), :query_id).filter_map do |query_id, rows|
+          durations = rows.map(&:first).compact
+          next if durations.empty?
+
+          row("RailsPulse::Query", query_id).merge(Metrics.duration(durations))
+        end
+      end
+
+      def job_rows
+        scope = JobRun.where(occurred_at: @time_range).where(status: JobRun::FINAL_STATUSES)
+        runs_by_job = rows_by_summarizable(scope, :job_id, :status)
+        return [] if runs_by_job.empty?
+
+        # A run whose job row has gone (count-based cleanup) has nothing to
+        # summarize against.
+        known_job_ids = Job.where(id: runs_by_job.map(&:first)).pluck(:id).to_set
+
+        runs_by_job.filter_map do |job_id, runs|
+          next unless known_job_ids.include?(job_id)
+
+          durations = runs.map(&:first).compact.map(&:to_f)
+          next if durations.empty?
+
+          statuses = runs.map(&:second)
+          row("RailsPulse::Job", job_id).merge(
+            Metrics.duration(durations),
+            count: runs.size,
+            error_count: statuses.count { |s| s != "success" },
+            success_count: statuses.count { |s| s == "success" }
+          )
+        end
+      end
+
+      # Per-group counts plus an all-groups row (id 0), so the dashboard can
+      # chart total exception volume without loading one series per group.
+      def exception_rows
+        counts = ExceptionOccurrence.where(occurred_at: @time_range).group(:exception_group_id).count
+        return [] if counts.empty?
+
+        rows = counts.map { |group_id, occurrences| row("RailsPulse::ExceptionGroup", group_id).merge(count: occurrences) }
+        rows << row("RailsPulse::ExceptionGroup", 0).merge(count: counts.values.sum)
+      end
+
+      private
+
+      def row(summarizable_type, summarizable_id)
+        { summarizable_type: summarizable_type, summarizable_id: summarizable_id }
+      end
+
+      # One read serves the overall request row and every route's. route_id
+      # and duration are NOT NULL on requests, so ordering by (route_id,
+      # duration) hands each route its durations already sorted.
+      def request_data
+        @request_data ||= Request
+          .where(occurred_at: @time_range)
+          .order(:route_id, :duration)
+          .pluck(:route_id, :duration, :status)
+      end
+
+      # [[summarizable_id, [[duration, *extra_columns], ...]], ...], with
+      # each summarizable's rows in ascending duration order (NULL durations
+      # land at one end or the other depending on the database; callers
+      # compact them).
+      def rows_by_summarizable(scope, column, *extra_columns)
+        scope
+          .where.not(column => nil)
+          .order(column, :duration)
+          .pluck(column, :duration, *extra_columns)
+          .slice_when { |previous, current| previous.first != current.first }
+          .map { |rows| [ rows.first.first, rows.map { |row| row.drop(1) } ] }
+      end
+    end
+  end
+end

data/app/services/rails_pulse/summary_service/metrics.rb

@@ -0,0 +1,38 @@
+module RailsPulse
+  class SummaryService
+    # The duration and status columns of a summary row, computed from raw
+    # values.
+    module Metrics
+      module_function
+
+      # `durations` must be sorted. Empty input yields count 0 and nil
+      # percentiles, which is what an idle period should record.
+      def duration(durations)
+        avg = durations.any? ? durations.sum.to_f / durations.size : 0
+
+        {
+          count: durations.size,
+          avg_duration: avg,
+          min_duration: durations.first,
+          max_duration: durations.last,
+          total_duration: durations.sum,
+          p50_duration: Statistics.calculate_percentile(durations, 0.5),
+          p95_duration: Statistics.calculate_percentile(durations, 0.95),
+          p99_duration: Statistics.calculate_percentile(durations, 0.99),
+          stddev_duration: Statistics.calculate_stddev(durations, avg)
+        }
+      end
+
+      def status(statuses)
+        {
+          error_count: statuses.count { |s| s >= 500 },
+          success_count: statuses.count { |s| s < 500 },
+          status_2xx: statuses.count { |s| s.between?(200, 299) },
+          status_3xx: statuses.count { |s| s.between?(300, 399) },
+          status_4xx: statuses.count { |s| s.between?(400, 499) },
+          status_5xx: statuses.count { |s| s >= 500 }
+        }
+      end
+    end
+  end
+end

data/app/services/rails_pulse/summary_service.rb

@@ -1,6 +1,20 @@
 module RailsPulse
-  # Aggregates one period (hour, day, week or month) of requests, operations,
-  # job runs and exception occurrences into rails_pulse_summaries rows.
+  # Aggregates one period (hour, day, week or month) into
+  # rails_pulse_summaries rows.
+  #
+  # Hours are computed from raw rows by FromRawRows. Days are rolled up from
+  # their hours, and weeks and months from their days, by FromChildPeriods,
+  # so a long period never re-reads raw rows: its cost does not grow with
+  # its length, and it stays correct after raw retention has pruned them.
+  #
+  # Every period gets one overall request row (type RailsPulse::Request,
+  # summarizable_id 0), written even when the period is empty (count: 0) so
+  # its timestamp keeps advancing every period — and only once the period
+  # has ended. It is the heartbeat several
+  # health checks use to detect whether SummaryJob is still running
+  # (dashboard banner, rails_pulse:status, StoragePressure staleness, and
+  # CleanupService's summarized_cutoff), and the marker this service uses to
+  # tell whether a child period has been summarized.
   #
   # Rows are written with upsert_all against the summaries table's unique
   # index, one statement per summarizable kind, so re-running a period (the
@@ -10,6 +24,11 @@ module RailsPulse
   class SummaryService
     UNIQUE_INDEX = :idx_pulse_summaries_unique
 
+    # The period each longer period is rolled up from. Weeks and months build
+    # from days because weeks do not tile months.
+    CHILD_PERIOD_TYPES = { "day" => "hour", "week" => "day", "month" => "day" }.freeze
+    CHILD_PERIOD_STEPS = { "hour" => 1.hour, "day" => 1.day }.freeze
+
     attr_reader :period_type, :start_time, :end_time
 
     def initialize(period_type, start_time)
@@ -19,15 +38,35 @@ module RailsPulse
     end
 
     def perform
+      # A period is summarized only once it has ended. The overall request
+      # row doubles as the heartbeat that CleanupService's summarized_cutoff
+      # and summarize_missing_child_periods trust to mean "fully aggregated";
+      # written mid-period, it would let cleanup delete raw rows that were
+      # never counted and let a later rollup bake the partial numbers in as
+      # final.
+      if end_time >= Time.current
+        RailsPulse.logger.info "Skipping #{period_type} summary for #{start_time}: period has not ended"
+        return
+      end
+
       RailsPulse.logger.info "Starting #{period_type} summary for #{start_time}"
 
+      summarize_missing_child_periods if rollup?
+
+      # Rows are computed before the transaction opens. A busy period's
+      # aggregation can take seconds; doing it with the transaction already
+      # open leaves it idle from the database's perspective and vulnerable to
+      # a configured idle_in_transaction_session_timeout on installs that set
+      # one.
+      rows = summary_rows
+
       # The engine's own connection: on a separate-database install
       # ActiveRecord::Base would open the transaction on the host's primary.
       RailsPulse::ApplicationRecord.transaction do
-        upsert_summaries(request_summary_rows + route_summary_rows) # Overall and per-route
-        upsert_summaries(query_summary_rows)                        # Per-query
-        upsert_summaries(job_summary_rows)                          # Per-job
-        aggregate_exceptions                                        # Per-exception-group frequency
+        upsert_summaries(rows[:requests_and_routes])
+        upsert_summaries(rows[:queries])
+        upsert_summaries(rows[:jobs])
+        upsert_exception_summaries(rows[:exceptions])
       end
 
       RailsPulse.logger.info "Completed #{period_type} summary"
@@ -38,126 +77,42 @@ module RailsPulse
 
     private
 
-    # Every row in one call must have the same keys, which is why the
-    # summarizable kinds are upserted separately: request and route rows carry
-    # status columns, query rows do not, exception rows carry only a count.
-    def upsert_summaries(rows)
-      return if rows.empty?
-
-      # MySQL resolves the conflict through any unique key and rejects an
-      # explicit target.
-      unique_by = Summary.connection.supports_insert_conflict_target? ? UNIQUE_INDEX : nil
-      Summary.upsert_all(rows, unique_by: unique_by)
-    end
-
-    def summary_row(summarizable_type, summarizable_id)
-      {
-        summarizable_type: summarizable_type,
-        summarizable_id: summarizable_id,
-        period_type: period_type,
-        period_start: start_time,
-        period_end: end_time
-      }
+    def rollup?
+      CHILD_PERIOD_TYPES.key?(period_type)
     end
 
-    # `durations` must be sorted. Empty input yields count 0 and nil
-    # percentiles, which is what an idle period should record.
-    def duration_metrics(durations)
-      avg = durations.any? ? durations.sum.to_f / durations.size : 0
-
-      {
-        count: durations.size,
-        avg_duration: avg,
-        min_duration: durations.first,
-        max_duration: durations.last,
-        total_duration: durations.sum,
-        p50_duration: RailsPulse::Statistics.calculate_percentile(durations, 0.5),
-        p95_duration: RailsPulse::Statistics.calculate_percentile(durations, 0.95),
-        p99_duration: RailsPulse::Statistics.calculate_percentile(durations, 0.99),
-        stddev_duration: RailsPulse::Statistics.calculate_stddev(durations, avg)
-      }
+    def source
+      @source ||=
+        if rollup?
+          FromChildPeriods.new(child_period_type, child_period_starts)
+        else
+          FromRawRows.new(start_time...end_time)
+        end
     end
 
-    def status_metrics(statuses)
+    def summary_rows
       {
-        error_count: statuses.count { |s| s >= 500 },
-        success_count: statuses.count { |s| s < 500 },
-        status_2xx: statuses.count { |s| s.between?(200, 299) },
-        status_3xx: statuses.count { |s| s.between?(300, 399) },
-        status_4xx: statuses.count { |s| s.between?(400, 499) },
-        status_5xx: statuses.count { |s| s >= 500 }
+        requests_and_routes: with_period(source.request_rows + source.route_rows),
+        queries: with_period(source.query_rows),
+        jobs: with_period(source.job_rows),
+        exceptions: with_period(exception_rows)
       }
     end
 
-    # One row for ALL requests in the period, written even when the period is
-    # empty (count: 0) so its timestamp keeps advancing every period — it is
-    # the heartbeat several health checks use to detect whether SummaryJob is
-    # still running (dashboard banner, rails_pulse:status, StoragePressure
-    # staleness, and CleanupService's summarized_cutoff). summarizable_id 0
-    # marks the overall rollup.
-    def request_summary_rows
-      request_data = Request.where(occurred_at: start_time...end_time).pluck(:duration, :status)
-      durations = request_data.map(&:first).compact.sort
-      statuses = request_data.map(&:second)
-
-      [ summary_row("RailsPulse::Request", 0).merge(duration_metrics(durations), status_metrics(statuses)) ]
+    def with_period(rows)
+      rows.map { |row| row.merge(period_type: period_type, period_start: start_time, period_end: end_time) }
     end
 
-    def route_summary_rows
-      all_rows = Request
-        .where(occurred_at: start_time...end_time)
-        .where.not(route_id: nil)
-        .pluck(:route_id, :duration, :status)
-
-      all_rows.group_by(&:first).map do |route_id, rows|
-        durations = rows.map { |_, d, _| d }.compact.sort
-        statuses = rows.map { |_, _, s| s }
-
-        summary_row("RailsPulse::Route", route_id)
-          .merge(duration_metrics(durations), status_metrics(statuses), count: rows.size)
-      end
-    end
-
-    def query_summary_rows
-      all_rows = Operation
-        .where(occurred_at: start_time...end_time)
-        .where.not(query_id: nil)
-        .pluck(:query_id, :duration)
-
-      all_rows.group_by(&:first).filter_map do |query_id, rows|
-        durations = rows.map(&:last).compact.sort
-        next if durations.empty?
-
-        summary_row("RailsPulse::Query", query_id).merge(duration_metrics(durations))
-      end
-    end
+    # Every row in one call must have the same keys, which is why the
+    # summarizable kinds are upserted separately: request and route rows carry
+    # status columns, query rows do not, exception rows carry only a count.
+    def upsert_summaries(rows)
+      return if rows.empty?
 
-    def job_summary_rows
-      all_rows = JobRun
-        .where(occurred_at: start_time...end_time)
-        .where(status: JobRun::FINAL_STATUSES)
-        .where.not(job_id: nil)
-        .pluck(:job_id, :duration, :status)
-      return [] if all_rows.empty?
-
-      # A run whose job row has gone (count-based cleanup) has nothing to
-      # summarize against.
-      known_job_ids = Job.where(id: all_rows.map(&:first).uniq).pluck(:id).to_set
-
-      all_rows.group_by(&:first).filter_map do |job_id, runs|
-        next unless known_job_ids.include?(job_id)
-
-        durations = runs.map { |_, d, _| d }.compact.map(&:to_f).sort
-        next if durations.empty?
-
-        statuses = runs.map { |_, _, s| s }
-        summary_row("RailsPulse::Job", job_id).merge(
-          duration_metrics(durations),
-          count: runs.size,
-          error_count: statuses.count { |s| s != "success" },
-          success_count: statuses.count { |s| s == "success" }
-        )
-      end
+      # MySQL resolves the conflict through any unique key and rejects an
+      # explicit target.
+      unique_by = Summary.connection.supports_insert_conflict_target? ? UNIQUE_INDEX : nil
+      Summary.upsert_all(rows, unique_by: unique_by)
     end
 
     # Exception frequency, per group and overall.
@@ -167,28 +122,61 @@ module RailsPulse
     # something happened last week — the history is gone as soon as cleanup
     # runs. Only `count` is meaningful here; the duration columns stay null
     # because an exception has no duration.
-    def aggregate_exceptions
-      return unless RailsPulse.configuration.track_exceptions
-      return unless ExceptionOccurrence.table_exists?
-
-      counts = ExceptionOccurrence
-        .where(occurred_at: start_time...end_time)
-        .group(:exception_group_id)
-        .count
-
-      return if counts.empty?
-
-      rows = counts.map { |group_id, occurrences| summary_row("RailsPulse::ExceptionGroup", group_id).merge(count: occurrences) }
-      # A rollup across every group, so the dashboard can chart total exception
-      # volume without loading one series per group.
-      rows << summary_row("RailsPulse::ExceptionGroup", 0).merge(count: counts.values.sum)
+    #
+    # Exceptions are the newest summarizable and the only optional one, so
+    # both the query here and the upsert in upsert_exception_summaries are
+    # individually rescued: a failure in either must not lose the route,
+    # query and job summaries computed or written alongside it.
+    def exception_rows
+      return [] unless RailsPulse.configuration.track_exceptions
+      return [] unless ExceptionOccurrence.table_exists?
+
+      source.exception_rows
+    rescue ActiveRecord::ActiveRecordError => e
+      RailsPulse.logger.error "Exception summary skipped: #{e.message}"
+      []
+    end
 
+    def upsert_exception_summaries(rows)
       upsert_summaries(rows)
     rescue ActiveRecord::ActiveRecordError => e
-      # Exceptions are the newest summarizable and the only optional one. A
-      # failure here must not lose the route, query and job summaries that were
-      # written in the same transaction.
       RailsPulse.logger.error "Exception summary skipped: #{e.message}"
     end
+
+    def child_period_type
+      CHILD_PERIOD_TYPES.fetch(period_type)
+    end
+
+    # Every child boundary inside this period. perform refuses periods that
+    # have not ended, so a rollup's children have all ended too.
+    def child_period_starts
+      @child_period_starts ||= begin
+        step = CHILD_PERIOD_STEPS.fetch(child_period_type)
+        starts = []
+        current = start_time
+        while current <= end_time
+          starts << current
+          current += step
+        end
+        starts
+      end
+    end
+
+    # A child period without its heartbeat row was never summarized
+    # (SummaryJob was not running, or a backfill asked only for the longer
+    # period), so it is summarized now, recursively, before being rolled up.
+    def summarize_missing_child_periods
+      summarized = Summary
+        .where(summarizable_type: "RailsPulse::Request", summarizable_id: 0, period_type: child_period_type)
+        .where(period_start: start_time..end_time)
+        .pluck(:period_start)
+        .to_set(&:to_i)
+
+      child_period_starts.each do |child_start|
+        next if summarized.include?(child_start.to_i)
+
+        SummaryService.new(child_period_type, child_start).perform
+      end
+    end
   end
 end

data/app/services/rails_pulse/tag_filter_service.rb

@@ -17,12 +17,12 @@ module RailsPulse
     def self.scope(model_class, disabled_tags, show_non_tagged)
       relation = model_class.all
 
-      # Exclude items with disabled tags. Explicit ESCAPE: SQLite has no
-      # default escape character, so without it an underscore in a tag is
-      # never matched literally there and the exclusion matches nothing.
+      # Exclude items with disabled tags.
       disabled_tags.each do |tag|
-        sanitized_tag = ActiveRecord::Base.sanitize_sql_like(tag.to_s, RailsPulse::Taggable::LIKE_ESCAPE)
-        relation = relation.where.not("tags LIKE ? ESCAPE '!'", "%#{sanitized_tag}%")
+        relation = relation.where.not(
+          "tags LIKE ? #{RailsPulse::LikePattern::CLAUSE}",
+          RailsPulse::LikePattern.containing(tag)
+        )
       end
 
       # Exclude non-tagged items if show_non_tagged is false

data/app/views/layouts/rails_pulse/_time_range_selector.html.erb

@@ -136,7 +136,10 @@ end %>
         <div class="flex items-start justify-between">
           <div>
             <h2 class="text-lg font-semibold mbe-4">Custom Date Range</h2>
-            <p class="text-sm text-subtle">Select a custom date and time range for filtering data.</p>
+            <p class="text-sm text-subtle">
+              Select a custom date and time range for filtering data. All times are in
+              <%= RailsPulse::TimeRange.aggregation_zone_label %>.
+            </p>
           </div>
           <%= link_to '#', "aria-label": "Close", data: { action: "click->rails-pulse--time-range#cancelCustom" }, class: "text-subtle hover:text-default" do %>
             <%= rails_pulse_icon "x", width: "20" %>

data/app/views/rails_pulse/components/_operation_details_popover.html.erb

@@ -26,7 +26,7 @@
         <div>
           <h4 class="text-xs font-medium text-subtle uppercase">Occurred At</h4>
           <div class="text-sm">
-            <%= operation.occurred_at.getlocal.strftime("%H:%M:%S.%L") %>
+            <%= operation.occurred_at.strftime("%H:%M:%S.%L") %>
           </div>
         </div>
       <% end %>

data/app/views/rails_pulse/components/_table_head.html.erb

@@ -6,8 +6,8 @@
           <%= column[:label] %>
         <% else %>
           <% sort_params = {} %>
-          <% sort_params[:zoom_start_time] = @zoom_start if @zoom_start.present? %>
-          <% sort_params[:zoom_end_time] = @zoom_end if @zoom_end.present? %>
+          <% sort_params[:zoom_start_time] = @time_range&.zoom_start if @time_range&.zoom_start.present? %>
+          <% sort_params[:zoom_end_time] = @time_range&.zoom_end if @time_range&.zoom_end.present? %>
           <% sort_params[:selected_column_time] = params[:selected_column_time] if params[:selected_column_time].present? %>
           <%= sort_link @ransack_query, column[:field], column[:label],
             sort_params.merge(

data/app/views/rails_pulse/dashboard/_chart_panel.html.erb

@@ -1,7 +1,12 @@
 <div class="grid-item" style="<%= flex_style if defined?(flex_style) %>">
   <div class="card b-full flex flex-col">
     <div class="flex mbe-2">
-      <h2 class="grow font-semibold leading-none uppercase text-xs"><%= title %></h2>
+      <h2 class="grow font-semibold leading-none uppercase text-xs">
+        <%= title %>
+        <% if chart_data %>
+          · <%= render "rails_pulse/shared/aggregation_zone_badge" %>
+        <% end %>
+      </h2>
       <div class="panel-icon-bar flex gap items-center">
         <% if chart_data %>
           <%= series_toggles %>

data/app/views/rails_pulse/dashboard/_deployments_panel.html.erb

@@ -34,7 +34,7 @@
     <div>
       <p class="font-semibold uppercase text-xs text-subtle mbe-1">In this range</p>
       <p class="text-lg font-bold"><%= number_with_delimiter(@deployment_count) %></p>
-      <p class="text-xs text-subtle"><%= humanize_time_range(@selected_time_range) %></p>
+      <p class="text-xs text-subtle"><%= humanize_time_range(@time_range.selected_time_range) %></p>
     </div>
   </div>
 
@@ -55,7 +55,7 @@
       <% end %>
     <% else %>
       <p class="text-sm text-subtle">
-        No deployments recorded in the <%= humanize_time_range(@selected_time_range) %>.
+        No deployments recorded in the <%= humanize_time_range(@time_range.selected_time_range) %>.
         Post to the deployments endpoint from your deploy pipeline, or run
         <code>rails_pulse:record_deployment</code>, and they will appear here and as markers on the charts.
       </p>

data/app/views/rails_pulse/dashboard/_health_badge.html.erb

@@ -1,23 +1,32 @@
 <%# Exceptions do not have a "slow" state — a group that fired at all is
     firing — so the two non-critical labels are overridable. %>
-<% healthy_label = local_assigns.fetch(:healthy_label, "healthy") %>
-<% slow_label    = local_assigns.fetch(:slow_label, "slow") %>
-<% dot_color = health[:critical] > 0 ? "var(--color-negative)" : (health[:slow] > 0 ? "#eab308" : "var(--color-positive)") %>
-<% border_color = health[:critical] > 0 ? "color-mix(in srgb, var(--color-negative) 40%, transparent)" : (health[:slow] > 0 ? "color-mix(in srgb, #eab308 40%, transparent)" : "color-mix(in srgb, var(--color-positive) 40%, transparent)") %>
-<% badge = capture do %>
-  <span class="badge flex items-center gap-half p-2" style="border-color: <%= border_color %>;">
-    <span class="shrink-0 rounded-full" style="width: 10px; height: 10px; background: <%= dot_color %>;"></span>
-    <span class="text-xs font-semibold"><%= name %></span>
-    <% if health[:critical] > 0 %>
-      <span class="text-xs text-subtle"><%= health[:healthy] %> <%= healthy_label %> · <%= health[:slow] %> <%= slow_label %> ·</span>
-      <span class="text-xs font-semibold text-negative"><%= health[:critical] %> <%= critical_label %></span>
-    <% else %>
-      <span class="text-xs text-subtle"><%= health[:healthy] %> <%= healthy_label %> · <%= health[:slow] %> <%= slow_label %> · 0 <%= critical_label %></span>
-    <% end %>
-  </span>
-<% end %>
-<% if local_assigns[:link_url].present? %>
-  <%= link_to link_url, class: "health-badge-link" do %><%= badge %><% end %>
-<% else %>
-  <%= badge %>
+<% hide_when_healthy = local_assigns.fetch(:hide_when_healthy, false) %>
+<% is_healthy = health[:critical].zero? && health[:slow].zero? %>
+<% unless hide_when_healthy && is_healthy %>
+  <% healthy_label = local_assigns.fetch(:healthy_label, "healthy") %>
+  <% slow_label    = local_assigns.fetch(:slow_label, "slow") %>
+  <% dot_color = health[:critical] > 0 ? "var(--color-negative)" : (health[:slow] > 0 ? "#eab308" : "var(--color-positive)") %>
+  <% border_color = health[:critical] > 0 ? "color-mix(in srgb, var(--color-negative) 40%, transparent)" : (health[:slow] > 0 ? "color-mix(in srgb, #eab308 40%, transparent)" : "color-mix(in srgb, var(--color-positive) 40%, transparent)") %>
+  <% subtle_parts = [] %>
+  <% subtle_parts << "#{health[:healthy]} #{healthy_label}" if health[:healthy] > 0 %>
+  <% subtle_parts << "#{health[:slow]} #{slow_label}" if health[:slow] > 0 %>
+  <% subtle_parts << "0 #{healthy_label}" if subtle_parts.empty? && health[:critical].zero? %>
+  <% critical_part = "#{health[:critical]} #{critical_label}" if health[:critical] > 0 %>
+  <% badge = capture do %>
+    <span class="badge flex items-center gap-half p-2" style="border-color: <%= border_color %>;">
+      <span class="shrink-0 rounded-full" style="width: 10px; height: 10px; background: <%= dot_color %>;"></span>
+      <span class="text-xs font-semibold"><%= name %></span>
+      <% if subtle_parts.any? %>
+        <span class="text-xs text-subtle"><%= subtle_parts.join(" · ") %><%= " ·" if critical_part %></span>
+      <% end %>
+      <% if critical_part %>
+        <span class="text-xs font-semibold text-negative"><%= critical_part %></span>
+      <% end %>
+    </span>
+  <% end %>
+  <% if local_assigns[:link_url].present? %>
+    <%= link_to link_url, class: "health-badge-link" do %><%= badge %><% end %>
+  <% else %>
+    <%= badge %>
+  <% end %>
 <% end %>