solid_stack_web 0.3.0 → 0.5.0

data/app/javascript/solid_stack_web/application.js

@@ -1,6 +1,12 @@
 import "@hotwired/turbo"
 import { Application } from "@hotwired/stimulus"
+import RefreshController from "solid_stack_web/refresh_controller"
+import SearchController from "solid_stack_web/search_controller"
 import SelectionController from "solid_stack_web/selection_controller"
+import SparklineTooltipController from "solid_stack_web/sparkline_tooltip_controller"
 
 const application = Application.start()
-application.register("selection", SelectionController)
+application.register("refresh", RefreshController)
+application.register("search", SearchController)
+application.register("selection", SelectionController)
+application.register("sparkline-tooltip", SparklineTooltipController)

data/app/javascript/solid_stack_web/refresh_controller.js

@@ -0,0 +1,52 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static values = { interval: { type: Number, default: 5000 } }
+
+  initialize() {
+    this._onVisibilityChange = this._onVisibilityChange.bind(this)
+  }
+
+  connect() {
+    document.addEventListener("visibilitychange", this._onVisibilityChange)
+    this._schedule()
+  }
+
+  disconnect() {
+    clearTimeout(this._timer)
+    document.removeEventListener("visibilitychange", this._onVisibilityChange)
+  }
+
+  _schedule() {
+    this._timer = setTimeout(() => this._reload(), this.intervalValue)
+  }
+
+  async _reload() {
+    clearTimeout(this._timer)
+    const hasSelection = this.element.querySelector("input[type='checkbox']:checked")
+    if (!document.hidden && !hasSelection) {
+      try {
+        const response = await fetch(window.location.href, {
+          headers: { "Turbo-Frame": this.element.id, Accept: "text/html" }
+        })
+        if (response.ok) {
+          const html = await response.text()
+          const doc = new DOMParser().parseFromString(html, "text/html")
+          const frame = doc.querySelector(`turbo-frame#${this.element.id}`)
+          if (frame && this.element.isConnected) this.element.innerHTML = frame.innerHTML
+        }
+      } catch {
+        // network error — skip this tick
+      }
+    }
+    if (this.element.isConnected) this._schedule()
+  }
+
+  _onVisibilityChange() {
+    if (document.hidden) {
+      clearTimeout(this._timer)
+    } else if (!this.element.querySelector("input[type='checkbox']:checked")) {
+      this._reload()
+    }
+  }
+}

data/app/javascript/solid_stack_web/search_controller.js

@@ -0,0 +1,16 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  filter({ target }) {
+    clearTimeout(this._timer)
+    const len = target.value.length
+    if (len >= 4 || len === 0) {
+      this._timer = setTimeout(() => target.form.requestSubmit(), 300)
+    }
+  }
+
+  select({ target }) {
+    clearTimeout(this._timer)
+    target.form.requestSubmit()
+  }
+}

data/app/javascript/solid_stack_web/sparkline_tooltip_controller.js

@@ -0,0 +1,23 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static targets = ["bar", "tip"]
+
+  connect() {
+    this._tip = this.tipTarget
+  }
+
+  show({ currentTarget }) {
+    const label = currentTarget.dataset.tip
+    if (!label) return
+    const rect = currentTarget.getBoundingClientRect()
+    this._tip.textContent = label
+    this._tip.style.left = `${rect.left + rect.width / 2}px`
+    this._tip.style.top = `${rect.top - 6}px`
+    this._tip.hidden = false
+  }
+
+  hide() {
+    this._tip.hidden = true
+  }
+}

data/app/models/solid_stack_web/alert_webhook.rb

@@ -0,0 +1,67 @@
+require "net/http"
+require "json"
+
+module SolidStackWeb
+  class AlertWebhook
+    COOLDOWN_CACHE_KEY = "solid_stack_web/alert_webhook/cooldown"
+
+    def self.check(queue_stats)
+      new(queue_stats).check
+    end
+
+    def initialize(queue_stats)
+      @queue_stats = queue_stats
+    end
+
+    def check
+      return unless SolidStackWeb.alert_webhook_url
+      return if on_cooldown?
+
+      alerts = build_alerts
+      return if alerts.empty?
+
+      deliver(alerts)
+      set_cooldown
+    end
+
+    private
+
+    def build_alerts
+      alerts = []
+
+      if (threshold = SolidStackWeb.alert_failure_threshold)
+        count = @queue_stats[:failed]
+        alerts << { type: "failed_jobs", count: count, threshold: threshold } if count >= threshold
+      end
+
+      SolidStackWeb.alert_queue_thresholds.each do |queue_name, threshold|
+        count = ::SolidQueue::ReadyExecution.where(queue_name: queue_name.to_s).count
+        alerts << { type: "queue_depth", queue: queue_name.to_s, count: count, threshold: threshold } if count >= threshold
+      end
+
+      alerts
+    end
+
+    def deliver(alerts)
+      payload = { alerts: alerts, generated_at: Time.current.iso8601 }
+      uri = URI(SolidStackWeb.alert_webhook_url)
+      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https",
+                      open_timeout: 5, read_timeout: 5) do |http|
+        request = Net::HTTP::Post.new(uri, "Content-Type" => "application/json")
+        request.body = payload.to_json
+        http.request(request)
+      end
+    rescue StandardError
+      # webhook delivery failures must not affect the response
+    end
+
+    def on_cooldown?
+      Rails.cache.read(COOLDOWN_CACHE_KEY).present?
+    end
+
+    def set_cooldown
+      Rails.cache.write(COOLDOWN_CACHE_KEY, Time.current.iso8601,
+                        expires_in: SolidStackWeb.alert_webhook_cooldown)
+    end
+  end
+end

data/app/models/solid_stack_web/cable_stats.rb

@@ -0,0 +1,10 @@
+module SolidStackWeb
+  class CableStats
+    def to_h
+      {
+        messages: ::SolidCable::Message.count,
+        channels: ::SolidCable::Message.distinct.count(:channel)
+      }
+    end
+  end
+end

data/app/models/solid_stack_web/cache_size_stats.rb

@@ -0,0 +1,33 @@
+module SolidStackWeb
+  class CacheSizeStats
+    BUCKETS = [
+      { label: "< 1 KB",       min: 0,       max: 1_024 },
+      { label: "1 – 10 KB",    min: 1_024,   max: 10_240 },
+      { label: "10 – 100 KB",  min: 10_240,  max: 102_400 },
+      { label: "100 KB – 1 MB", min: 102_400, max: 1_048_576 },
+      { label: "> 1 MB",       min: 1_048_576, max: nil }
+    ].freeze
+
+    TOP_N = 10
+
+    def top_entries
+      @top_entries ||= ::SolidCache::Entry
+                         .select(:id, :key, :byte_size)
+                         .order(byte_size: :desc)
+                         .limit(TOP_N)
+    end
+
+    def buckets
+      @buckets ||= BUCKETS.map do |b|
+        scope = ::SolidCache::Entry.all
+        scope = scope.where("byte_size >= ?", b[:min]) if b[:min] > 0
+        scope = scope.where("byte_size < ?",  b[:max]) if b[:max]
+        { label: b[:label], count: scope.count }
+      end
+    end
+
+    def total
+      @total ||= ::SolidCache::Entry.count
+    end
+  end
+end

data/app/models/solid_stack_web/cache_stats.rb

@@ -0,0 +1,11 @@
+module SolidStackWeb
+  class CacheStats
+    def to_h
+      {
+        entries:      ::SolidCache::Entry.count,
+        byte_size:    ::SolidCache::Entry.sum(:byte_size),
+        oldest_entry: ::SolidCache::Entry.minimum(:created_at)
+      }
+    end
+  end
+end

data/app/models/solid_stack_web/cache_timeline.rb

@@ -0,0 +1,40 @@
+module SolidStackWeb
+  class CacheTimeline
+    HOURS = 24
+
+    def entry_buckets
+      @entry_buckets ||= build_buckets { |rows, from, to| rows.count { |t, _| t >= from && t < to } }
+    end
+
+    def byte_buckets
+      @byte_buckets ||= build_buckets { |rows, from, to| rows.sum { |t, b| t >= from && t < to ? b : 0 } }
+    end
+
+    def entry_max
+      entry_buckets.max || 0
+    end
+
+    def byte_max
+      byte_buckets.max || 0
+    end
+
+    private
+
+    def rows
+      @rows ||= begin
+        origin = Time.current - HOURS.hours
+        ::SolidCache::Entry.where(created_at: origin..Time.current).pluck(:created_at, :byte_size)
+      end
+    end
+
+    def build_buckets(&block)
+      now    = Time.current
+      origin = now - HOURS.hours
+      HOURS.times.map do |i|
+        from = origin + i.hours
+        to   = origin + (i + 1).hours
+        block.call(rows, from, to)
+      end
+    end
+  end
+end

data/app/models/solid_stack_web/queue_depth_sparkline.rb

@@ -0,0 +1,30 @@
+module SolidStackWeb
+  class QueueDepthSparkline
+    HOURS = 12
+
+    def initialize(queue_name)
+      @queue_name = queue_name
+    end
+
+    def buckets
+      @buckets ||= begin
+        now    = Time.current
+        origin = now - HOURS.hours
+
+        jobs = ::SolidQueue::Job
+                 .where(queue_name: @queue_name)
+                 .where("created_at <= ? AND (finished_at IS NULL OR finished_at >= ?)", now, origin)
+                 .pluck(:created_at, :finished_at)
+
+        HOURS.times.map do |i|
+          snapshot = origin + (i + 1).hours
+          jobs.count { |created_at, finished_at| created_at <= snapshot && (finished_at.nil? || finished_at > snapshot) }
+        end
+      end
+    end
+
+    def max
+      buckets.max || 0
+    end
+  end
+end

data/app/models/solid_stack_web/queue_stats.rb

@@ -0,0 +1,34 @@
+module SolidStackWeb
+  class QueueStats
+    def to_h
+      finished_24h = finished_since(24.hours.ago)
+      stats = {
+        ready:             ::SolidQueue::ReadyExecution.count,
+        scheduled:         ::SolidQueue::ScheduledExecution.count,
+        claimed:           ::SolidQueue::ClaimedExecution.count,
+        blocked:           ::SolidQueue::BlockedExecution.count,
+        failed:            ::SolidQueue::FailedExecution.count,
+        done_1h:           finished_since(1.hour.ago).count,
+        done_24h:          finished_24h.count,
+        processes_healthy: ::SolidQueue::Process.where("last_heartbeat_at > ?", 5.minutes.ago).count,
+        processes_stale:   ::SolidQueue::Process.where("last_heartbeat_at <= ? OR last_heartbeat_at IS NULL", 5.minutes.ago).count
+      }
+      add_slow_jobs(stats, finished_24h)
+      stats
+    end
+
+    private
+
+    def finished_since(time)
+      ::SolidQueue::Job.where.not(finished_at: nil).where("finished_at >= ?", time)
+    end
+
+    def add_slow_jobs(stats, finished_24h)
+      threshold = SolidStackWeb.slow_job_threshold
+      return unless threshold
+
+      stats[:slow_jobs] = finished_24h.select(:created_at, :finished_at)
+                                      .count { |j| (j.finished_at - j.created_at) > threshold }
+    end
+  end
+end

data/app/models/solid_stack_web/throughput_sparkline.rb

@@ -0,0 +1,23 @@
+module SolidStackWeb
+  class ThroughputSparkline
+    HOURS = 12
+
+    def buckets
+      @buckets ||= begin
+        now    = Time.current
+        origin = now - HOURS.hours
+        times  = ::SolidQueue::Job.where(finished_at: origin..now).pluck(:finished_at)
+
+        HOURS.times.map do |i|
+          from = origin + i.hours
+          to   = origin + (i + 1).hours
+          times.count { |t| t >= from && t < to }
+        end
+      end
+    end
+
+    def max
+      buckets.max || 0
+    end
+  end
+end

data/app/views/layouts/solid_stack_web/application.html.erb

@@ -24,6 +24,17 @@
     </div>
   </header>
 
+  <% if current_section == :cache %>
+    <nav class="sqw-subnav">
+      <div class="sqw-subnav__inner">
+        <%= link_to "Overview", cache_path,
+              class: "sqw-subnav__link#{" sqw-subnav__link--active" if controller_name == "cache"}" %>
+        <%= link_to "Entries", cache_entries_path,
+              class: "sqw-subnav__link#{" sqw-subnav__link--active" if controller_name == "cache_entries"}" %>
+      </div>
+    </nav>
+  <% end %>
+
   <% if current_section == :queue %>
     <nav class="sqw-subnav">
       <div class="sqw-subnav__inner">
@@ -35,6 +46,8 @@
               class: "sqw-subnav__link#{" sqw-subnav__link--active" if controller_name == "queues"}" %>
         <%= link_to "Recurring", recurring_tasks_path,
               class: "sqw-subnav__link#{" sqw-subnav__link--active" if controller_name == "recurring_tasks"}" %>
+        <%= link_to "Stats", stats_path,
+              class: "sqw-subnav__link#{" sqw-subnav__link--active" if controller_name == "stats"}" %>
         <%= link_to "History", history_path,
               class: "sqw-subnav__link#{" sqw-subnav__link--active" if controller_name == "history"}" %>
         <%= link_to "Processes", processes_path,

data/app/views/solid_stack_web/cache/index.html.erb

@@ -3,12 +3,94 @@
 </div>
 
 <div class="sqw-stats-grid">
-  <div class="sqw-stat sqw-stat--cache">
+  <%= link_to cache_entries_path, class: "sqw-stat sqw-stat--cache" do %>
     <span class="sqw-stat__label">Total Entries</span>
     <span class="sqw-stat__value"><%= @total_entries %></span>
-  </div>
+  <% end %>
   <div class="sqw-stat sqw-stat--cache">
     <span class="sqw-stat__label">Total Size</span>
     <span class="sqw-stat__value"><%= number_to_human_size(@total_byte_size) %></span>
   </div>
 </div>
+
+<% if @total_entries > 0 %>
+  <div class="sqw-size-grid">
+    <section class="sqw-size-section">
+      <h2 class="sqw-section-title">Size Distribution</h2>
+      <table class="sqw-table">
+        <thead>
+          <tr>
+            <th>Range</th>
+            <th>Entries</th>
+            <th></th>
+          </tr>
+        </thead>
+        <tbody>
+          <% @size_stats.buckets.each do |bucket| %>
+            <% pct = @size_stats.total > 0 ? (bucket[:count].to_f / @size_stats.total * 100).round(1) : 0 %>
+            <tr>
+              <td class="sqw-muted"><%=bucket[:label] %></td>
+              <td><%= bucket[:count] %></td>
+              <td>
+                <div class="sqw-dist-bar-cell">
+                  <div class="sqw-dist-bar" style="width: <%= pct %>%"></div>
+                  <span class="sqw-dist-pct sqw-muted"><%= pct %>%</span>
+                </div>
+              </td>
+            </tr>
+          <% end %>
+        </tbody>
+      </table>
+    </section>
+
+    <section class="sqw-size-section">
+      <h2 class="sqw-section-title">Largest Entries</h2>
+      <table class="sqw-table">
+        <thead>
+          <tr>
+            <th>Key</th>
+            <th>Size</th>
+          </tr>
+        </thead>
+        <tbody>
+          <% @size_stats.top_entries.each do |entry| %>
+            <tr>
+              <td class="sqw-monospace sqw-truncate" title="<%= entry.key %>">
+                <%= link_to entry.key, cache_entry_path(entry), class: "sqw-link" %>
+              </td>
+              <td><%= number_to_human_size(entry.byte_size) %></td>
+            </tr>
+          <% end %>
+        </tbody>
+      </table>
+    </section>
+  </div>
+<% end %>
+
+<div class="sqw-timeline-grid" data-controller="sparkline-tooltip">
+  <div class="sqw-sparkline-wrap sqw-timeline-chart">
+    <span class="sqw-sparkline-label">Entries written — last 24 hours</span>
+    <div class="sqw-sparkline-positioner">
+      <%= cache_entries_timeline_svg(@timeline) %>
+      <div class="sqw-sparkline-tip" data-sparkline-tooltip-target="tip" hidden></div>
+    </div>
+    <div class="sqw-sparkline-axis">
+      <span>24h ago</span>
+      <span>12h ago</span>
+      <span>now</span>
+    </div>
+  </div>
+
+  <div class="sqw-sparkline-wrap sqw-timeline-chart">
+    <span class="sqw-sparkline-label">Bytes written — last 24 hours</span>
+    <div class="sqw-sparkline-positioner">
+      <%= cache_bytes_timeline_svg(@timeline) %>
+      <div class="sqw-sparkline-tip" data-sparkline-tooltip-target="tip" hidden></div>
+    </div>
+    <div class="sqw-sparkline-axis">
+      <span>24h ago</span>
+      <span>12h ago</span>
+      <span>now</span>
+    </div>
+  </div>
+</div>

data/app/views/solid_stack_web/cache_entries/index.html.erb

@@ -0,0 +1,66 @@
+<div class="sqw-page-header sqw-page-header--split">
+  <h1 class="sqw-page-title">Cache Entries</h1>
+  <div class="sqw-header-actions">
+    <%= button_to "Flush All",
+          cache_flush_path,
+          method: :delete,
+          class: "sqw-btn sqw-btn--danger sqw-btn--sm",
+          data: { turbo_confirm: "Delete all cache entries? This cannot be undone." } %>
+  </div>
+</div>
+
+<form class="sqw-filters" action="<%= cache_entries_path %>" method="get" data-controller="search">
+  <%= hidden_field_tag :column,    @sort["column"] %>
+  <%= hidden_field_tag :direction, @sort["direction"] %>
+  <input class="sqw-search-input" type="search" name="q" value="<%= @search %>"
+         placeholder="Filter by key…" autocomplete="off" aria-label="Filter by key"
+         data-action="input->search#filter">
+  <% if @search.present? %>
+    <%= link_to "Clear", cache_entries_path(column: @sort["column"], direction: @sort["direction"]),
+          class: "sqw-btn sqw-btn--muted sqw-btn--sm" %>
+  <% end %>
+</form>
+
+<% if @entries.any? %>
+  <table class="sqw-table">
+    <thead>
+      <tr>
+        <% [["key", "Key"], ["byte_size", "Size"], ["created_at", "Created"]].each do |col, label| %>
+          <th>
+            <% next_dir = (@sort["column"] == col && @sort["direction"] == "desc") ? "asc" : "desc" %>
+            <%= link_to cache_entries_path(q: @search, column: col, direction: next_dir) do %>
+              <%= label %>
+              <% if @sort["column"] == col %>
+                <span class="sqw-sort-indicator"><%= @sort["direction"] == "desc" ? "↓" : "↑" %></span>
+              <% end %>
+            <% end %>
+          </th>
+        <% end %>
+        <th></th>
+      </tr>
+    </thead>
+    <tbody>
+      <% @entries.each do |entry| %>
+        <tr id="cache_entry_<%= entry.id %>">
+          <td class="sqw-monospace sqw-truncate" title="<%= entry.key %>">
+            <%= link_to entry.key, cache_entry_path(entry), class: "sqw-link" %>
+          </td>
+          <td><%= number_to_human_size(entry.byte_size) %></td>
+          <td class="sqw-muted"><%= entry.created_at.strftime("%b %d %H:%M") %></td>
+          <td class="sqw-actions">
+            <%= button_to "Delete",
+                  cache_entry_path(entry, q: @search, column: @sort["column"], direction: @sort["direction"]),
+                  method: :delete,
+                  class: "sqw-btn sqw-btn--danger sqw-btn--sm",
+                  data: { turbo_confirm: "Delete this cache entry?" } %>
+          </td>
+        </tr>
+      <% end %>
+    </tbody>
+  </table>
+  <%== pagy_nav(@pagy) if @pagy.pages > 1 %>
+<% else %>
+  <div class="sqw-empty">
+    <p><%= @search.present? ? "No entries matching &ldquo;#{@search}&rdquo;.".html_safe : "No cache entries." %></p>
+  </div>
+<% end %>

data/app/views/solid_stack_web/cache_entries/show.html.erb

@@ -0,0 +1,48 @@
+<div class="sqw-page-header sqw-page-header--split">
+  <h1 class="sqw-page-title sqw-truncate" title="<%= @entry.key %>"><%= @entry.key %></h1>
+  <div class="sqw-header-actions">
+    <%= button_to "Delete",
+          cache_entry_path(@entry),
+          method: :delete,
+          class: "sqw-btn sqw-btn--danger sqw-btn--sm",
+          data: { turbo_confirm: "Delete this cache entry?" } %>
+    <%= link_to "← Entries", cache_entries_path, class: "sqw-btn sqw-btn--muted sqw-btn--sm" %>
+  </div>
+</div>
+
+<dl class="sqw-detail">
+  <div class="sqw-detail__row">
+    <dt>Key</dt>
+    <dd class="sqw-monospace"><%= @entry.key %></dd>
+  </div>
+  <div class="sqw-detail__row">
+    <dt>Size</dt>
+    <dd><%= number_to_human_size(@entry.byte_size) %></dd>
+  </div>
+  <div class="sqw-detail__row">
+    <dt>Created</dt>
+    <dd class="sqw-muted"><%= @entry.created_at.strftime("%b %d, %Y %H:%M:%S %Z") %></dd>
+  </div>
+</dl>
+
+<section class="sqw-value-preview">
+  <div class="sqw-value-preview__header">
+    <h2 class="sqw-section-title">Value</h2>
+    <% if SolidStackWeb.allow_value_preview %>
+      <% formatted = format_cache_value(@entry.value) %>
+      <span class="sqw-badge sqw-badge--queue"><%= formatted[:label] %></span>
+    <% end %>
+  </div>
+  <% if SolidStackWeb.allow_value_preview %>
+    <% content = formatted[:content] %>
+    <% truncated = content.length > 4096 %>
+    <pre class="sqw-value-pre"><%= truncated ? content[0, 4096] : content %></pre>
+    <% if truncated %>
+      <p class="sqw-muted sqw-value-truncated">Showing first 4 KB of <%= number_to_human_size(@entry.byte_size) %> total.</p>
+    <% end %>
+  <% else %>
+    <div class="sqw-empty">
+      <p>Value preview is disabled. Set <code>config.allow_value_preview = true</code> in your initializer to enable.</p>
+    </div>
+  <% end %>
+</section>