solid_observer 0.3.0 → 0.5.0

data/app/controllers/solid_observer/cache_dashboard_controller.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "dashboard_controller"
+
+module SolidObserver
+  class CacheDashboardController < DashboardController
+    CACHE_STORAGE_COMPONENTS = %w[solid_cache cache_observer].freeze
+
+    def index
+      @component = "cache"
+      assign_cache_dashboard
+    end
+
+    private
+
+    def assign_cache_dashboard
+      unless SolidObserver.config.solid_cache_enabled?
+        @cache_dashboard_available = false
+        @storage_components = []
+        @recent_events = []
+        @activity_trends = SolidObserver::Services::CacheStats::ACTIVITY_TREND_EMPTY
+        @stability = SolidObserver::Services::CacheStats::STABILITY_EMPTY
+        return
+      end
+
+      range = SolidObserver::Services::CacheStats.parse_range(request_range_param)
+      window = SolidObserver::Services::CacheStats.range_duration(range)
+      stats = SolidObserver::Services::CacheStats.call(window: window)
+
+      @cache_dashboard_available = true
+      @range = range
+      @stats = stats
+      @activity_trends = stats[:activity_trends]
+      @stability = stats[:stability]
+      @storage_components = cache_storage_components
+      @recent_events = recent_events(window)
+    end
+
+    def cache_storage_components
+      SolidObserver::Services::StorageInfoSnapshot.call.select do |snapshot|
+        CACHE_STORAGE_COMPONENTS.include?(snapshot[:component])
+      end
+    end
+
+    def recent_events(window)
+      current_time = Time.current
+      SolidObserver::CacheEvent.where(recorded_at: (current_time - window)..current_time).recent(10)
+    rescue ActiveRecord::StatementInvalid
+      []
+    end
+  end
+end

data/app/controllers/solid_observer/cache_operations_controller.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module SolidObserver
+  class CacheOperationsController < ApplicationController
+    def index
+      @cache_controls_available = SolidObserver::Services::CacheOperations.available?
+    end
+
+    def prune
+      redirect_with_result(SolidObserver::Services::CacheOperations.prune)
+    end
+
+    def clear
+      redirect_with_result(SolidObserver::Services::CacheOperations.clear)
+    end
+
+    private
+
+    def redirect_with_result(result)
+      flash_key = result[:ok] ? :notice : :alert
+      redirect_to cache_operations_path, flash_key => result[:message]
+    end
+  end
+end

data/app/controllers/solid_observer/dashboard_controller.rb

@@ -1,16 +1,25 @@
 # frozen_string_literal: true
 
+require_relative "../../helpers/solid_observer/application_helper"
+
 module SolidObserver
   class DashboardController < ApplicationController
+    helper SolidObserver::ApplicationHelper
+
     skip_forgery_protection only: :live_poll
     skip_after_action :verify_same_origin_request, only: :live_poll
 
     def index
+      @component = selected_component
+
+      return unless @component == "queue" && SolidObserver.config.solid_queue_enabled?
+
       assign_range_and_stats
       load_persistence_data if persistence_mode?
     end
 
     def live_poll
+      expires_in 1.day, public: true
       send_file(
         SolidObserver::Engine.root.join("app/assets/javascripts/solid_observer/live_poll.js"),
         type: "application/javascript; charset=utf-8",
@@ -32,7 +41,13 @@ module SolidObserver
       @range = range
       @live = request_live_param == "on"
       @stats = QueueStats.snapshot(range: range)
-      @chart = QueueStats.chart_data(window: QueueStats.range_duration(@range))
+      @chart = if @stats[:available]
+        QueueStats.chart_data(window: QueueStats.range_duration(@range))
+      else
+        {performed: [], failed: [], ready: []}
+      end
+    rescue
+      @chart = {performed: [], failed: [], ready: []}
     end
 
     def load_persistence_data
@@ -75,5 +90,27 @@ module SolidObserver
     def append_chart_buffer
       ChartBuffer.append(SolidQueue::ReadyExecution.count) if QueueStats.solid_queue_available?
     end
+
+    def selected_component
+      requested = if request&.respond_to?(:path_parameters)
+        request.path_parameters&.[](:component).to_s
+      else
+        ""
+      end
+      requested = path_component if requested.empty?
+      return "cache" if requested == "cache" && SolidObserver.config.solid_cache_enabled?
+
+      "queue"
+    end
+
+    def path_component
+      return "" unless request&.respond_to?(:path)
+
+      path = request&.path.to_s
+      return "cache" if path.end_with?("/cache")
+      return "queue" if path.end_with?("/queue")
+
+      ""
+    end
   end
 end

data/app/controllers/solid_observer/storages_controller.rb

@@ -5,7 +5,7 @@ module SolidObserver
     include RequirePersistenceMode
 
     def show
-      @current_storage = SolidObserver::StorageInfo.order(recorded_at: :desc).first
+      @storage_components = SolidObserver::Services::StorageInfoSnapshot.call
       @storage_history = SolidObserver::StorageInfo.recent(20)
     end
   end

data/app/helpers/solid_observer/application_helper.rb

@@ -1,7 +1,11 @@
 # frozen_string_literal: true
 
+require_relative "dashboard_helper"
+
 module SolidObserver
   module ApplicationHelper
+    include SolidObserver::DashboardHelper
+
     STATUS_COLORS = {
       "completed" => "success",
       "ready" => "success",
@@ -23,6 +27,21 @@ module SolidObserver
       degraded: {label: "Degraded", tone: "warning"},
       critical: {label: "Critical", tone: "danger"}
     }.freeze
+    CACHE_OUTCOME_STATES = {
+      hit: {label: "Hit", tone: "success"},
+      miss: {label: "Miss", tone: "info"},
+      error: {label: "Error", tone: "danger"},
+      recorded: {label: "Recorded", tone: "recorded"}
+    }.freeze
+    CACHE_RANGE_LABELS = {
+      "15m" => "in last 15m",
+      "30m" => "in last 30m",
+      "1h" => "in last hour",
+      "7h" => "in last 7h",
+      "1d" => "in last day",
+      "7d" => "in last 7d",
+      "14d" => "in last 14d"
+    }.freeze
 
     def execution_status(execution)
       ExecutionPresenter.new(execution).status
@@ -41,7 +60,15 @@ module SolidObserver
     def status_badge(status)
       status_str = status.to_s
       color = STATUS_COLORS.fetch(status_str, "default")
-      content_tag(:span, status_str.humanize, class: "so-badge so-badge--#{color}")
+      dot = tag.svg(
+        tag.circle(r: 3, cx: 3, cy: 3),
+        class: "so-badge__dot",
+        viewBox: "0 0 6 6",
+        "aria-hidden": "true"
+      )
+      tag.span(class: "so-badge so-badge--pill so-badge--#{color}") do
+        safe_join([dot, status_str.humanize], " ")
+      end
     end
 
     def duration_with_semantic(value, event_type)
@@ -53,7 +80,15 @@ module SolidObserver
     def mode_badge
       config = SolidObserver.config
       color = config.persistence_mode? ? "info" : "warning"
-      content_tag(:span, config.storage_mode.to_s.capitalize, class: "so-badge so-badge--#{color}")
+      dot = tag.svg(
+        tag.circle(r: 3, cx: 3, cy: 3),
+        class: "so-badge__dot",
+        viewBox: "0 0 6 6",
+        "aria-hidden": "true"
+      )
+      tag.span(class: "so-badge so-badge--pill so-badge--#{color}") do
+        safe_join([dot, config.storage_mode.to_s.capitalize], " ")
+      end
     end
 
     def turbo_frame_tag(id, **options, &block)
@@ -73,14 +108,125 @@ module SolidObserver
     end
 
     def stability_badge(stats)
-      meta = STABILITY_STATES.fetch(stability_state(stats))
-      dot = tag.svg(tag.circle(r: 3, cx: 3, cy: 3),
-        class: "so-badge__dot", viewBox: "0 0 6 6", "aria-hidden": "true")
+      stability_badge_for(stability_state(stats))
+    end
+
+    def cache_stability_badge(state)
+      stability_badge_for(state.to_sym)
+    end
+
+    def cache_ratio_percent(value)
+      number_to_percentage(value.to_f * 100, precision: 1, strip_insignificant_zeros: true)
+    end
+
+    def cache_storage_summary(storage_components)
+      snapshots = Array(storage_components)
+      reason = cache_storage_unavailable_reason(snapshots)
+      return {value: "—", subtitle: "— #{reason}"} if reason
+
+      {
+        value: number_to_human_size(cache_storage_total_bytes(snapshots), precision: 1, significant: false, strip_insignificant_zeros: false),
+        subtitle: "SolidCache + cache observer"
+      }
+    end
+
+    def cache_event_outcome_badge(event)
+      meta = cache_event_outcome_meta(event)
+      dot = tag.svg(
+        tag.circle(r: 3, cx: 3, cy: 3),
+        class: "so-badge__dot",
+        viewBox: "0 0 6 6",
+        "aria-hidden": "true"
+      )
+
       tag.span(class: "so-badge so-badge--pill so-badge--#{meta[:tone]}") do
         safe_join([dot, meta[:label]], " ")
       end
     end
 
+    def cache_event_digest(key_digest, visible_chars: 10)
+      digest = key_digest.to_s
+      return "—" if digest.empty?
+      return digest if digest.length <= visible_chars
+
+      "#{digest.first(visible_chars)}…"
+    end
+
+    def cache_range_label(range_key)
+      CACHE_RANGE_LABELS.fetch(range_key.to_s, "in selected range")
+    end
+
+    def cable_range_label(range_key)
+      CACHE_RANGE_LABELS.fetch(range_key.to_s, "in selected range")
+    end
+
+    def cable_ratio_percent(value)
+      number_to_percentage(value.to_f * 100, precision: 1, strip_insignificant_zeros: true)
+    end
+
+    def cable_stability_badge(state)
+      stability_badge_for(state.to_sym)
+    end
+
+    def cable_stability_detail(stability)
+      state = (stability || {})[:state]&.to_sym
+      state = :stable unless STABILITY_STATES.key?(state)
+
+      case state
+      when :critical
+        critical_cable_stability_detail(stability)
+      when :degraded
+        degraded_cable_stability_detail(stability)
+      else
+        "No cable errors or subscription rejections in the selected range and backlog current snapshot is healthy"
+      end
+    end
+
+    def cable_event_digest(digest, visible_chars: 10)
+      digest = digest.to_s
+      return "—" if digest.empty?
+      return digest if digest.length <= visible_chars
+
+      "#{digest.first(visible_chars)}…"
+    end
+
+    # :reek:FeatureEnvy
+    def cable_backlog_summary(stats)
+      if stats[:backlog_available]
+        {
+          value: number_with_delimiter(stats[:backlog_count].to_i),
+          subtitle: "current Solid Cable snapshot"
+        }
+      else
+        {value: "—", subtitle: "current Solid Cable snapshot unavailable"}
+      end
+    end
+
+    def cable_storage_summary(storage_components)
+      snapshots = Array(storage_components)
+      reason = cable_storage_unavailable_reason(snapshots)
+      return {value: "—", subtitle: "— #{reason}"} if reason
+
+      {
+        value: number_to_human_size(cable_storage_total_bytes(snapshots), precision: 1, significant: false, strip_insignificant_zeros: false),
+        subtitle: "Cable telemetry + Solid Cable messages"
+      }
+    end
+
+    def cache_stability_detail(stability)
+      state = (stability || {})[:state]&.to_sym
+      state = :stable unless STABILITY_STATES.key?(state)
+
+      case state
+      when :critical
+        critical_cache_stability_detail(stability)
+      when :degraded
+        degraded_cache_stability_detail(stability)
+      else
+        "No sampled cache errors or slow events in the selected range"
+      end
+    end
+
     def stability_detail(stats)
       failures_24h = stats[:failed_last_24h].to_i
       return "No failures in the last 24h" if failures_24h.zero?
@@ -91,5 +237,122 @@ module SolidObserver
     def latest_failure_phrase(timestamp)
       timestamp ? "#{time_ago_in_words(timestamp)} ago" : "unknown"
     end
+
+    def queue_component_enabled?
+      SolidObserver.config.solid_queue_enabled?
+    end
+
+    def cache_component_enabled?
+      SolidObserver.config.solid_cache_enabled?
+    end
+
+    def cable_component_enabled?
+      SolidObserver.config.solid_cable_enabled?
+    end
+
+    def dashboard_section_active?(component)
+      current_component = @component.presence || "queue"
+      controller_name == "dashboard" && current_component == component.to_s
+    end
+
+    private
+
+    def stability_badge_for(state)
+      meta = STABILITY_STATES.fetch(state)
+      dot = tag.svg(tag.circle(r: 3, cx: 3, cy: 3),
+        class: "so-badge__dot", viewBox: "0 0 6 6", "aria-hidden": "true")
+      tag.span(class: "so-badge so-badge--pill so-badge--#{meta[:tone]}") do
+        safe_join([dot, meta[:label]], " ")
+      end
+    end
+
+    def critical_cache_stability_detail(stability)
+      detail = pluralize(stability[:error_count].to_i, "sampled cache error")
+      slow_count = stability[:slow_count].to_i
+      detail = "#{detail} and #{pluralize(slow_count, "slow event")}" if slow_count.positive?
+      "#{detail} in the selected range#{cache_stability_latest_suffix(stability[:latest_recorded_at])}"
+    end
+
+    def degraded_cache_stability_detail(stability)
+      detail = pluralize(stability[:slow_count].to_i, "slow sampled cache event")
+      "#{detail} in the selected range#{cache_stability_latest_suffix(stability[:latest_recorded_at])}"
+    end
+
+    def cache_stability_latest_suffix(timestamp)
+      timestamp ? ", latest #{time_ago_in_words(timestamp)} ago" : ""
+    end
+
+    def cache_storage_total_bytes(snapshots)
+      snapshots.sum { |snapshot| snapshot[:db_size_bytes].to_i }
+    end
+
+    def cache_storage_unavailable_reason(snapshots)
+      return "Storage snapshot unavailable" unless snapshots.size == 2
+
+      snapshots.find { |snapshot| !snapshot[:available] }&.[](:unavailable_reason)
+    end
+
+    # :reek:FeatureEnvy
+    # :reek:TooManyStatements
+    def critical_cable_stability_detail(stability)
+      parts = []
+      error_count = stability[:error_count].to_i
+      parts << pluralize(error_count, "cable error") if error_count.positive?
+
+      rejection_count = stability[:rejection_count].to_i
+      rejection_rate = stability[:rejection_rate].to_f
+      if rejection_rate > 0.0
+        parts << "#{cable_ratio_percent(rejection_rate)} rejection rate"
+      elsif rejection_count.positive?
+        parts << pluralize(rejection_count, "subscription rejection")
+      end
+
+      backlog_ratio = stability[:backlog_ratio].to_f
+      if backlog_ratio >= 0.5
+        parts << "backlog at #{number_to_percentage(backlog_ratio * 100, precision: 0)} in current snapshot"
+      end
+
+      return "Cable stability critical" if parts.empty?
+
+      "#{parts.join("; ")} in the selected range"
+    end
+
+    # :reek:FeatureEnvy
+    # :reek:TooManyStatements
+    def degraded_cable_stability_detail(stability)
+      return "Backlog current snapshot unavailable" unless stability[:backlog_available]
+
+      backlog_ratio = stability[:backlog_ratio].to_f
+      if backlog_ratio >= SolidObserver.config.cable_backlog_threshold.to_f
+        return "Backlog at #{number_to_percentage(backlog_ratio * 100, precision: 0)} in current snapshot"
+      end
+
+      rejection_count = stability[:rejection_count].to_i
+      if rejection_count.positive?
+        return "#{pluralize(rejection_count, "subscription rejection")} in the selected range"
+      end
+
+      "Cable stability degraded"
+    end
+
+    def cable_storage_total_bytes(snapshots)
+      snapshots.sum { |snapshot| snapshot[:db_size_bytes].to_i }
+    end
+
+    def cable_storage_unavailable_reason(snapshots)
+      return "Storage snapshot unavailable" unless snapshots.size == 2
+
+      snapshots.find { |snapshot| !snapshot[:available] }&.[](:unavailable_reason)
+    end
+
+    def cache_event_outcome_meta(event)
+      hit = event.hit
+
+      return CACHE_OUTCOME_STATES.fetch(:error) if event.error_class.present?
+      return CACHE_OUTCOME_STATES.fetch(:hit) if hit == true
+      return CACHE_OUTCOME_STATES.fetch(:miss) if hit == false
+
+      CACHE_OUTCOME_STATES.fetch(:recorded)
+    end
   end
 end

data/app/helpers/solid_observer/dashboard_helper.rb

@@ -9,17 +9,36 @@ module SolidObserver
     def spark_points(series, width: SVG_W, height: SVG_H)
       return "" if series.blank?
 
-      t_min = series.first[:t]
-      t_max = series.last[:t]
-      v_max = [series.max_by { |point| point[:v] }[:v], 1].max
-      time_span = t_max - t_min
-
-      series.map { |point|
-        val = point[:v]
-        point_x = time_span.zero? ? width / 2.0 : ((point[:t] - t_min).to_f / time_span) * (width - 2) + 1
-        point_y = height - 1 - (val.to_f / v_max) * (height - 2)
-        format("%.1f,%.1f", point_x, point_y)
-      }.join(" ")
+      context = build_spark_context(series, width, height)
+      series.map { |point| format_spark_point(point: point, context: context) }.join(" ")
+    end
+
+    def build_spark_context(series, width, height)
+      first_point = series.first
+      last_point = series.last
+      min_time = first_point[:t]
+
+      {
+        min_time: min_time,
+        time_span: last_point[:t] - min_time,
+        max_value: [series.max_by { |point| point[:v] }[:v], 1].max,
+        width: width,
+        height: height,
+        inner_width: width - 2,
+        inner_height: height - 2
+      }
+    end
+
+    def format_spark_point(point:, context:)
+      time_span = context[:time_span]
+      coordinate_x = if time_span.zero?
+        context[:width] / 2.0
+      else
+        ((point[:t] - context[:min_time]).to_f / time_span) * context[:inner_width] + 1
+      end
+
+      coordinate_y = context[:height] - 1 - (point[:v].to_f / context[:max_value]) * context[:inner_height]
+      format("%.1f,%.1f", coordinate_x, coordinate_y)
     end
 
     RANGE_LABELS = {

data/app/models/solid_observer/cable_event.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SolidObserver
+  class CableEvent < BaseEvent
+    self.table_name = "solid_observer_cable_events"
+
+    validates :event_type, presence: true
+    validates :recorded_at, presence: true
+
+    scope :errored, -> { where.not(error_class: nil) }
+    scope :recent, ->(limit = 10) { order(recorded_at: :desc).limit(limit) }
+  end
+end

data/app/models/solid_observer/cable_metric.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module SolidObserver
+  class CableMetric < BaseRecord
+    self.table_name = "solid_observer_cable_metrics"
+
+    validates :period_start, presence: true
+    validates :broadcasts_count, :transmissions_count, :confirmations_count,
+      :rejections_count, :perform_actions_count, :errors_count,
+      numericality: {only_integer: true, greater_than_or_equal_to: 0}
+  end
+end

data/app/models/solid_observer/cache_event.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SolidObserver
+  class CacheEvent < BaseEvent
+    self.table_name = "solid_observer_cache_events"
+
+    validates :event_type, presence: true
+    validates :key_digest, presence: true
+    validates :recorded_at, presence: true
+
+    scope :errored, -> { where.not(error_class: nil) }
+    scope :slow, ->(threshold = SolidObserver.config.cache_slow_threshold) { where("duration >= ?", threshold) }
+    scope :recent, ->(limit = 10) { order(recorded_at: :desc).limit(limit) }
+  end
+end

data/app/models/solid_observer/cache_metric.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SolidObserver
+  class CacheMetric < BaseRecord
+    self.table_name = "solid_observer_cache_metrics"
+
+    validates :event_type, presence: true, length: {maximum: 64}
+    validates :period_start, presence: true
+    validates :operations_count, :hits_count, :misses_count, :errors_count,
+      numericality: {only_integer: true, greater_than_or_equal_to: 0}
+    validates :duration_total, numericality: {greater_than_or_equal_to: 0}
+  end
+end

data/app/models/solid_observer/storage_info.rb

@@ -6,16 +6,19 @@ module SolidObserver
 
     MB_TO_BYTES = 1_048_576
     GB_TO_BYTES = 1_073_741_824
+    COMPONENTS = %w[queue_observer cache_observer solid_cache cable_observer solid_cable].freeze
 
     validates :db_size_bytes, presence: true, numericality: {only_integer: true, greater_than_or_equal_to: 0}
     validates :event_count, presence: true, numericality: {only_integer: true, greater_than_or_equal_to: 0}
     validates :recorded_at, presence: true
+    validates :component, presence: true, inclusion: {in: COMPONENTS}
 
     scope :recent, ->(limit = 10) { order(recorded_at: :desc).limit(limit) }
     scope :since, ->(time) { where("recorded_at >= ?", time) }
 
-    def self.record_snapshot(db_size:, event_count:)
+    def self.record_snapshot(db_size:, event_count:, component: "queue_observer")
       create!(
+        component: component,
         db_size_bytes: db_size || 0,
         event_count: event_count,
         recorded_at: Time.current