solid_observer 0.1.1 → 0.3.0

data/app/controllers/solid_observer/jobs_controller.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module SolidObserver
+  class JobsController < ApplicationController
+    include Paginatable
+    include RequireSolidQueue
+
+    PER_PAGE = 25
+    CACHE_KEY_QUEUES = "solid_observer/jobs/available_queues"
+    CACHE_KEY_JOB_CLASSES = "solid_observer/jobs/available_job_classes"
+
+    def index
+      filter = Params::JobsFilter.from_params(params)
+      @status = filter.status
+      @queue_name = filter.queue_name
+      @job_class = filter.job_class
+      @page = filter.page
+      result = Queries::JobExecutionsQuery.new(filter).call
+      offset = paginate_scope(result, per_page: PER_PAGE)
+      @jobs = if result.is_a?(Array)
+        result.drop(offset).first(PER_PAGE)
+      else
+        result.limit(PER_PAGE).offset(offset).includes(:job).to_a
+      end
+      @available_queues = fetch_available_queues
+      @available_job_classes = fetch_available_job_classes
+    end
+
+    def show
+      @execution = find_execution_for_show
+      return redirect_to jobs_path, alert: "Job not found" unless @execution
+
+      assign_show_presenter
+    end
+
+    def retry
+      id = params[:id]
+      execution = Queries::ExecutionFinder.find_failed(id)
+      return redirect_to(jobs_path, alert: "Failed job not found") unless execution
+
+      execution.retry
+      redirect_to jobs_path(status: "failed"), notice: "Job #{id} queued for retry"
+    end
+
+    def discard
+      id = params[:id]
+      execution = Queries::ExecutionFinder.find_failed(id)
+      return redirect_to(jobs_path, alert: "Failed job not found") unless execution
+
+      execution.discard
+      redirect_to jobs_path(status: "failed"), notice: "Job #{id} discarded"
+    end
+
+    private
+
+    def find_execution_for_show
+      id = params[:id]
+      Queries::ExecutionFinder.find_by_status(id, params[:status]) ||
+        Queries::ExecutionFinder.find_any(id)
+    end
+
+    def assign_show_presenter
+      @presenter = ExecutionPresenter.new(@execution)
+      @job = @presenter.job
+      @status = @presenter.status
+    end
+
+    def fetch_available_queues
+      Rails.cache.fetch(CACHE_KEY_QUEUES, expires_in: SolidObserver.config.filter_cache_ttl) do
+        next [] unless defined?(SolidQueue::Queue)
+        SolidQueue::Queue.all.map(&:name)
+      end
+    rescue ActiveRecord::StatementInvalid, ActiveRecord::ConnectionNotEstablished
+      []
+    end
+
+    def fetch_available_job_classes
+      Rails.cache.fetch(CACHE_KEY_JOB_CLASSES, expires_in: SolidObserver.config.filter_cache_ttl) do
+        SolidQueue::Job.distinct.pluck(:class_name).compact.sort
+      end
+    rescue ActiveRecord::StatementInvalid, ActiveRecord::ConnectionNotEstablished
+      []
+    end
+  end
+end

data/app/controllers/solid_observer/storages_controller.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module SolidObserver
+  class StoragesController < ApplicationController
+    include RequirePersistenceMode
+
+    def show
+      @current_storage = SolidObserver::StorageInfo.order(recorded_at: :desc).first
+      @storage_history = SolidObserver::StorageInfo.recent(20)
+    end
+  end
+end

data/app/helpers/solid_observer/application_helper.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module SolidObserver
+  module ApplicationHelper
+    STATUS_COLORS = {
+      "completed" => "success",
+      "ready" => "success",
+      "failed" => "danger",
+      "retry_stopped" => "danger",
+      "scheduled" => "warning",
+      "claimed" => "warning",
+      "enqueued" => "info",
+      "discarded" => "info"
+    }.freeze
+    DURATION_SEMANTICS = {
+      "job_enqueued" => "Time spent in the ActiveJob enqueue call (Rails internal; typically sub-millisecond to single-digit ms)",
+      "job_completed" => "Time spent performing the job",
+      "job_failed" => "Time spent performing the job before the exception was raised",
+      "job_discarded" => "Time before discard decision was made"
+    }.freeze
+    STABILITY_STATES = {
+      stable: {label: "Stable", tone: "success"},
+      degraded: {label: "Degraded", tone: "warning"},
+      critical: {label: "Critical", tone: "danger"}
+    }.freeze
+
+    def execution_status(execution)
+      ExecutionPresenter.new(execution).status
+    end
+
+    def format_duration(seconds)
+      return "0ms" if seconds.to_f.zero?
+
+      if seconds < 1
+        "#{(seconds * 1000).round}ms"
+      else
+        "#{"%.1f" % seconds}s"
+      end
+    end
+
+    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}")
+    end
+
+    def duration_with_semantic(value, event_type)
+      return content_tag(:span, "—", class: "so-text-muted") unless value
+
+      content_tag(:abbr, format_duration(value), title: DURATION_SEMANTICS.fetch(event_type.to_s))
+    end
+
+    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}")
+    end
+
+    def turbo_frame_tag(id, **options, &block)
+      return super if defined?(super)
+
+      content = options.delete(:content)
+      body = block_given? ? capture(&block) : content
+
+      content_tag(:"turbo-frame", body, **options.merge(id: id).compact)
+    end
+
+    def stability_state(stats)
+      return :critical if stats[:failed_last_hour].to_i.positive?
+      return :degraded if stats[:failed_last_24h].to_i.positive?
+
+      :stable
+    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")
+      tag.span(class: "so-badge so-badge--pill so-badge--#{meta[:tone]}") do
+        safe_join([dot, meta[:label]], " ")
+      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?
+
+      "#{pluralize(failures_24h, "failure")} in the last 24h, latest #{latest_failure_phrase(stats[:latest_failure_at])}"
+    end
+
+    def latest_failure_phrase(timestamp)
+      timestamp ? "#{time_ago_in_words(timestamp)} ago" : "unknown"
+    end
+  end
+end

data/app/helpers/solid_observer/dashboard_helper.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# Mirrors live_poll.js Sparkline.render — keep in sync.
+module SolidObserver
+  module DashboardHelper
+    SVG_W = 120
+    SVG_H = 32
+
+    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(" ")
+    end
+
+    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 range_label(range_key)
+      RANGE_LABELS.fetch(range_key, "in selected range")
+    end
+  end
+end

data/app/models/solid_observer/queue_event.rb

@@ -10,6 +10,7 @@ module SolidObserver
       job_failed
       job_discarded
     ].freeze
+    DISTINCT_FILTER_LIMIT = 500
 
     validates :event_type, presence: true, inclusion: {in: EVENT_TYPES}
     validates :recorded_at, presence: true
@@ -19,5 +20,138 @@ module SolidObserver
     scope :by_event_type, ->(event_type) { where(event_type: event_type) }
     scope :since, ->(time) { where("recorded_at >= ?", time) }
     scope :before, ->(time) { where("recorded_at < ?", time) }
+    scope :recent, ->(limit = 10) { order(recorded_at: :desc).limit(limit) }
+    scope :recent_failures, ->(limit = 5) { by_event_type("job_failed").order(recorded_at: :desc).limit(limit) }
+    scope :distinct_job_classes, -> {
+      where("recorded_at >= ?", SolidObserver.config.event_retention.ago)
+        .where.not(job_class: nil)
+        .distinct
+        .limit(DISTINCT_FILTER_LIMIT)
+        .pluck(:job_class)
+        .sort
+    }
+    scope :distinct_queue_names, -> {
+      where("recorded_at >= ?", SolidObserver.config.event_retention.ago)
+        .where.not(queue_name: nil)
+        .distinct
+        .limit(DISTINCT_FILTER_LIMIT)
+        .pluck(:queue_name)
+        .sort
+    }
+
+    def self.performed_count_last(duration)
+      by_event_type("job_completed").since(duration.ago).count
+    end
+
+    def self.failed_count_last(duration)
+      by_event_type("job_failed").since(duration.ago).count
+    end
+
+    def self.enqueue_rate_per_minute(window: 5.minutes)
+      count = by_event_type("job_enqueued").since(window.ago).count
+      return 0.0 if count.zero?
+
+      (count.to_f / (window.to_f / 60.0)).round(1)
+    end
+
+    def self.enqueued_count_last(duration)
+      by_event_type("job_enqueued").since(duration.ago).count
+    end
+
+    def self.avg_duration_last(duration)
+      by_event_type("job_completed").since(duration.ago).average(:duration).to_f
+    end
+
+    def self.count_by_queue_and_event_type(window:, event_type:)
+      since(window.ago)
+        .where(event_type: event_type)
+        .where.not(queue_name: nil)
+        .group(:queue_name)
+        .count
+    end
+
+    def self.count_by_time_bucket(event_type:, window:, bucket_seconds:)
+      context = build_bucket_context(window: window, bucket_seconds: bucket_seconds)
+      return [] unless context
+
+      counts_by_bucket = fetch_counts_by_bucket(event_type: event_type, context: context)
+      fill_missing_buckets(context: context, counts_by_bucket: counts_by_bucket)
+    end
+
+    class << self
+      private
+
+      def build_bucket_context(window:, bucket_seconds:)
+        bucket_size = bucket_seconds.to_i
+        return nil if bucket_size <= 0 || window.to_i <= 0
+
+        end_time = Time.current
+        start_time = end_time - window
+
+        {
+          bucket_size: bucket_size,
+          start_time: start_time,
+          end_time: end_time,
+          start_bucket: align_bucket(start_time.to_i, bucket_size),
+          end_bucket: align_bucket(end_time.to_i, bucket_size)
+        }
+      end
+
+      def fetch_counts_by_bucket(event_type:, context:)
+        rows = fetch_grouped_rows(event_type: event_type, context: context)
+        rows.to_h { |row| [row["bucket_time"].to_i, row["bucket_count"].to_i] }
+      end
+
+      def fetch_grouped_rows(event_type:, context:)
+        pool = BaseEvent.connection_pool
+        query_context = context.merge(
+          event_type: event_type,
+          adapter: pool.db_config.adapter.to_s.downcase
+        )
+
+        pool.with_connection do |connection|
+          connection.select_all(grouped_counts_sql(connection: connection, query_context: query_context)).to_a
+        end
+      end
+
+      def grouped_counts_sql(connection:, query_context:)
+        <<~SQL.squish
+          SELECT #{bucket_time_sql(adapter: query_context[:adapter], bucket_size: query_context[:bucket_size])} AS bucket_time, COUNT(*) AS bucket_count
+          FROM #{table_name}
+          WHERE event_type = #{connection.quote(query_context[:event_type])}
+            AND recorded_at >= #{connection.quote(query_context[:start_time])}
+            AND recorded_at <= #{connection.quote(query_context[:end_time])}
+          GROUP BY bucket_time
+          ORDER BY bucket_time ASC
+        SQL
+      end
+
+      def bucket_time_sql(adapter:, bucket_size:)
+        case adapter
+        when "sqlite3", "sqlite"
+          "(CAST(strftime('%s', recorded_at) AS INTEGER) / #{bucket_size}) * #{bucket_size}"
+        when "postgresql"
+          if bucket_size == 60
+            "EXTRACT(EPOCH FROM date_trunc('minute', recorded_at))::bigint"
+          else
+            "(EXTRACT(EPOCH FROM recorded_at)::bigint / #{bucket_size}) * #{bucket_size}"
+          end
+        when "mysql2", "trilogy", "mysql"
+          "(UNIX_TIMESTAMP(recorded_at) DIV #{bucket_size}) * #{bucket_size}"
+        else
+          raise ArgumentError, "Unsupported adapter for bucket aggregation: #{adapter.inspect}"
+        end
+      end
+
+      def fill_missing_buckets(context:, counts_by_bucket:)
+        context[:start_bucket].step(context[:end_bucket], context[:bucket_size]).map do |timestamp|
+          {t: timestamp, v: counts_by_bucket.fetch(timestamp, 0)}
+        end
+      end
+
+      def align_bucket(value, bucket_size)
+        (value / bucket_size) * bucket_size
+      end
+    end
   end
 end

data/app/models/solid_observer/queue_metric.rb

@@ -3,7 +3,7 @@
 module SolidObserver
   # QueueMetric provides time-series metrics storage for queue statistics.
   #
-  # NOTE: Metrics functionality is planned for v0.2.0. This class currently
+  # NOTE: Metrics functionality is planned for a future release. This class currently
   # serves as a placeholder and inherits base functionality from BaseMetric.
   # The database connection will be configured by the Engine when metrics
   # are fully implemented.

data/app/presenters/solid_observer/execution_presenter.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module SolidObserver
+  class ExecutionPresenter
+    STATUS_MAP = {
+      "SolidQueue::ReadyExecution" => "ready",
+      "SolidQueue::ScheduledExecution" => "scheduled",
+      "SolidQueue::ClaimedExecution" => "claimed",
+      "SolidQueue::FailedExecution" => "failed"
+    }.freeze
+
+    def initialize(execution)
+      @execution = execution
+    end
+
+    def status
+      STATUS_MAP.fetch(@execution.class.name, "unknown")
+    end
+
+    def job
+      @execution.job
+    end
+
+    def queue_name
+      responded, value = value_from(@execution, :queue_name)
+      return value if responded
+
+      value_from(job, :queue_name).last
+    end
+
+    def priority
+      responded, value = value_from(@execution, :priority)
+      return value if responded
+
+      value_from(job, :priority).last
+    end
+
+    def to_model
+      @execution
+    end
+
+    private
+
+    def value_from(target, method_name)
+      return [false, nil] unless target&.respond_to?(method_name)
+
+      [true, target.method(method_name).call]
+    end
+  end
+end