solid_queue_lite 0.1.0

data/lib/solid_queue_lite/telemetry.rb

@@ -0,0 +1,201 @@
+module SolidQueueLite
+  module Telemetry
+    SNAPSHOT_QUEUE_NAME = "*"
+    SAMPLE_WINDOW = 5.minutes
+    RETENTION_PERIOD = 7.days
+    RANGE_OPTIONS = {
+      "1h" => 1.hour,
+      "6h" => 6.hours,
+      "24h" => 24.hours
+    }.freeze
+
+    module_function
+
+    def sample!(timestamp: Time.current)
+      snapshot_time = normalize_timestamp(timestamp)
+      stat = SolidQueueLite::Stat.create!(snapshot_attributes(snapshot_time))
+      prune!(cutoff: snapshot_time - RETENTION_PERIOD)
+      stat
+    end
+
+    def backfill!(timestamp: Time.current)
+      snapshot_time = normalize_timestamp(timestamp)
+      latest = SolidQueueLite::Stat.where(queue_name: SNAPSHOT_QUEUE_NAME).order(timestamp: :desc).first
+
+      if latest && latest.timestamp >= snapshot_time - SAMPLE_WINDOW
+        latest.update!(snapshot_attributes(latest.timestamp))
+        latest
+      else
+        sample!(timestamp: snapshot_time)
+      end
+    end
+
+    def dashboard_data(range_key: "24h")
+      selected_range = RANGE_OPTIONS.key?(range_key) ? range_key : "24h"
+      window_start = Time.current - RANGE_OPTIONS.fetch(selected_range)
+      stats = SolidQueueLite::Stat.where(queue_name: SNAPSHOT_QUEUE_NAME, timestamp: window_start..).order(:timestamp)
+
+      {
+        selected_range: selected_range,
+        stats: stats,
+        latest_stat: stats.last,
+        current_ready_count: exact_count(ready_relation),
+        current_scheduled_count: exact_count(scheduled_relation),
+        current_failed_count: exact_count(current_failed_relation),
+        worker_count: ::SolidQueue::Process.where(kind: "Worker").count,
+        dispatcher_count: ::SolidQueue::Process.where(kind: "Dispatcher").count,
+        stale_process_count: ::SolidQueue::Process.prunable.where(kind: [ "Worker", "Dispatcher" ]).count,
+        recurring_tasks: recurring_task_rows,
+        chart_payload: {
+          labels: stats.map { |stat| stat.timestamp.strftime("%H:%M") },
+          ready_counts: stats.map(&:ready_count),
+          scheduled_counts: stats.map { |stat| stat.respond_to?(:scheduled_count) ? stat.scheduled_count : 0 },
+          success_counts: stats.map { |stat| stat.respond_to?(:success_count) ? stat.success_count : 0 },
+          failed_counts: stats.map(&:failed_count),
+          avg_latencies: stats.map { |stat| stat.avg_latency&.round(2) || 0.0 }
+        }
+      }
+    end
+
+    def snapshot_attributes(timestamp)
+      window_start = timestamp - SAMPLE_WINDOW
+
+      {
+        timestamp: timestamp,
+        queue_name: SNAPSHOT_QUEUE_NAME,
+        ready_count: exact_count(ready_relation),
+        scheduled_count: exact_count(scheduled_relation),
+        failed_count: recent_failed_relation(window_start).count,
+        success_count: successful_job_relation(window_start).count,
+        avg_latency: average_latency(recent_claimed_relation(window_start))
+      }
+    end
+
+    def ready_relation
+      SolidQueueLite.apply_tenant_scope(::SolidQueue::ReadyExecution.all)
+    end
+
+    def scheduled_relation
+      SolidQueueLite.apply_tenant_scope(::SolidQueue::ScheduledExecution.all)
+    end
+
+    def recent_failed_relation(window_start)
+      SolidQueueLite.apply_tenant_scope(::SolidQueue::FailedExecution.where(created_at: window_start..))
+    end
+
+    def current_failed_relation
+      SolidQueueLite.apply_tenant_scope(::SolidQueue::FailedExecution.all)
+    end
+
+    def successful_job_relation(window_start)
+      SolidQueueLite.apply_tenant_scope(
+        ::SolidQueue::Job.left_outer_joins(:failed_execution)
+          .where(finished_at: window_start..)
+          .where(solid_queue_failed_executions: { id: nil })
+      )
+    end
+
+    def recent_claimed_relation(window_start)
+      SolidQueueLite.apply_tenant_scope(
+        ::SolidQueue::ClaimedExecution.joins(:job).where(
+          ::SolidQueue::ClaimedExecution.table_name => { created_at: window_start.. }
+        )
+      )
+    end
+
+    def average_latency(relation)
+      adapter_name = relation.connection.adapter_name.downcase
+
+      expression = case adapter_name
+      when /postgres/
+        Arel.sql("EXTRACT(EPOCH FROM solid_queue_claimed_executions.created_at - solid_queue_jobs.created_at)")
+      when /mysql/, /trilogy/
+        Arel.sql("TIMESTAMPDIFF(MICROSECOND, solid_queue_jobs.created_at, solid_queue_claimed_executions.created_at) / 1000000.0")
+      when /sqlite/
+        Arel.sql("(julianday(solid_queue_claimed_executions.created_at) - julianday(solid_queue_jobs.created_at)) * 86400.0")
+      else
+        raise NotImplementedError, "Unsupported adapter for telemetry sampling: #{relation.connection.adapter_name}"
+      end
+
+      relation.average(expression)&.to_f
+    end
+
+    def exact_count(relation)
+      relation.except(:select, :order).count
+    end
+
+    def recurring_task_rows
+      recurring_tasks.map do |task|
+        latest_execution = recurring_task_executions_for(task).max_by(&:run_at)
+        latest_job = latest_execution&.job
+
+        {
+          key: task.key,
+          description: task.try(:description).presence || task.key.to_s.humanize,
+          queue_name: task.try(:queue_name).presence || "solid_queue_recurring",
+          schedule: task.schedule,
+          class_name: task.try(:class_name).presence || "SolidQueue::RecurringJob",
+          last_run_at: latest_execution&.run_at,
+          next_run_at: safe_next_run_at(task),
+          last_status: recurring_status_for(latest_job)
+        }
+      end.sort_by { |task| task[:key].to_s }
+    rescue StandardError
+      []
+    end
+
+    def recurring_tasks
+      persisted_tasks = if defined?(::SolidQueue::RecurringTask)
+        ::SolidQueue::RecurringTask.static.includes(recurring_executions: :job).to_a
+      else
+        []
+      end
+
+      configured_tasks = begin
+        ::SolidQueue::Configuration.new.send(:recurring_tasks)
+      rescue StandardError
+        []
+      end
+
+      (persisted_tasks + configured_tasks).uniq { |task| task.key }
+    end
+
+    def recurring_task_executions_for(task)
+      if task.respond_to?(:recurring_executions)
+        Array(task.recurring_executions)
+      else
+        []
+      end
+    end
+
+    def safe_next_run_at(task)
+      task.next_time if task.respond_to?(:next_time)
+    rescue StandardError
+      nil
+    end
+
+    def recurring_status_for(job)
+      return "Not yet run" unless job
+
+      case job.status.to_s
+      when "failed"
+        "Failed"
+      when "claimed"
+        "Running"
+      when "ready", "scheduled"
+        "Queued"
+      else
+        job.finished_at.present? ? "Succeeded" : job.status.to_s.humanize
+      end
+    end
+
+    def normalize_timestamp(timestamp)
+      value = timestamp.respond_to?(:in_time_zone) ? timestamp.in_time_zone : Time.zone.parse(timestamp.to_s)
+      value || Time.current
+    end
+
+    def prune!(cutoff: RETENTION_PERIOD.ago)
+      SolidQueueLite::Stat.where(SolidQueueLite::Stat.arel_table[:timestamp].lt(cutoff)).delete_all
+    end
+  end
+end

data/lib/solid_queue_lite/version.rb

@@ -0,0 +1,3 @@
+module SolidQueueLite
+  VERSION = "0.1.0"
+end

data/lib/solid_queue_lite.rb

@@ -0,0 +1,46 @@
+require "rails"
+require "rails/engine"
+require "solid_queue"
+require "solid_queue_lite/install"
+require "solid_queue_lite/version"
+
+module SolidQueueLite
+  class Configuration
+    attr_reader :tenant_scope
+    attr_accessor :telemetry_backfill_on_boot
+
+    def initialize
+      self.tenant_scope = ->(relation) { relation }
+      self.telemetry_backfill_on_boot = true
+    end
+
+    def tenant_scope=(callable)
+      unless callable.respond_to?(:call)
+        raise ArgumentError, "tenant_scope must respond to #call"
+      end
+
+      @tenant_scope = callable
+    end
+  end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+    alias config configuration
+
+    def configure
+      yield(configuration)
+    end
+
+    def apply_tenant_scope(relation)
+      configuration.tenant_scope.call(relation)
+    end
+  end
+end
+
+require "solid_queue_lite/approximate_counter"
+require "solid_queue_lite/jobs"
+require "solid_queue_lite/processes"
+require "solid_queue_lite/telemetry"
+require "solid_queue_lite/engine"

data/lib/tasks/solid_queue_lite_tasks.rake

@@ -0,0 +1,14 @@
+namespace :solid_queue_lite do
+  desc "Install Solid Queue Lite into the host Rails application"
+  task install: :environment do
+    SolidQueueLite::Install.new.run!(migrate: ENV["MIGRATE"] == "1")
+  end
+
+  namespace :telemetry do
+    desc "Backfill a current telemetry snapshot for Solid Queue Lite"
+    task backfill: :environment do
+      stat = SolidQueueLite::Telemetry.backfill!
+      puts "Backfilled telemetry snapshot at #{stat.timestamp}"
+    end
+  end
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: solid_queue_lite
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Nanda Suhendra
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.1.0
+- !ruby/object:Gem::Dependency
+  name: solid_queue
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Sidekiq-style operational visibility and telemetry without the asset
+  pipeline baggage or database locking.
+email:
+- nandhasuhendra@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/assets/stylesheets/soliq_queue_lite/application.css
+- app/controllers/concerns/solid_queue_lite/approximate_countable.rb
+- app/controllers/solid_queue_lite/application_controller.rb
+- app/controllers/solid_queue_lite/dashboards_controller.rb
+- app/controllers/solid_queue_lite/jobs_controller.rb
+- app/controllers/solid_queue_lite/processes_controller.rb
+- app/controllers/solid_queue_lite/queues_controller.rb
+- app/helpers/solid_queue_lite/application_helper.rb
+- app/jobs/solid_queue_lite/application_job.rb
+- app/jobs/solid_queue_lite/telemetry_sampler_job.rb
+- app/models/solid_queue_lite/application_record.rb
+- app/models/solid_queue_lite/stat.rb
+- app/views/layouts/solid_queue_lite/application.html.erb
+- app/views/solid_queue_lite/dashboards/show.html.erb
+- config/routes.rb
+- db/migrate/20260406000000_create_solid_queue_lite_stats.rb
+- lib/solid_queue_lite.rb
+- lib/solid_queue_lite/approximate_counter.rb
+- lib/solid_queue_lite/engine.rb
+- lib/solid_queue_lite/install.rb
+- lib/solid_queue_lite/jobs.rb
+- lib/solid_queue_lite/processes.rb
+- lib/solid_queue_lite/telemetry.rb
+- lib/solid_queue_lite/version.rb
+- lib/tasks/solid_queue_lite_tasks.rake
+homepage: https://github.com/nandhasuhendra/solid_queue_lite
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/nandhasuhendra/solid_queue_lite
+  source_code_uri: https://github.com/nandhasuhendra/solid_queue_lite/tree/main
+  changelog_uri: https://github.com/nandhasuhendra/solid_queue_lite/blob/main/CHANGELOG.md
+  documentation_uri: https://github.com/nandhasuhendra/solid_queue_lite#readme
+  bug_tracker_uri: https://github.com/nandhasuhendra/solid_queue_lite/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: A lightweight, zero-build dashboard for Solid Queue.
+test_files: []