solid_queue_monitor 1.3.0 → 2.1.0

data/app/presenters/solid_queue_monitor/workers_presenter.rb

@@ -1,325 +0,0 @@
-# frozen_string_literal: true
-
-module SolidQueueMonitor
-  class WorkersPresenter < BasePresenter
-    HEARTBEAT_STALE_THRESHOLD = 5.minutes
-    HEARTBEAT_DEAD_THRESHOLD = 10.minutes
-
-    def initialize(processes, current_page: 1, total_pages: 1, filters: {}, sort: {})
-      @processes = processes.to_a # Load records once to avoid multiple queries
-      @current_page = current_page
-      @total_pages = total_pages
-      @filters = filters
-      @sort = sort
-      preload_claimed_data
-      calculate_summary_stats
-    end
-
-    def render
-      section_wrapper('Workers', generate_content)
-    end
-
-    private
-
-    def generate_content
-      generate_summary + generate_filter_form + generate_table_or_empty + generate_pagination(@current_page, @total_pages)
-    end
-
-    def generate_filter_form
-      <<-HTML
-        <div class="filter-form-container">
-          <form method="get" action="#{workers_path}" class="filter-form">
-            <div class="filter-group">
-              <label for="kind">Kind:</label>
-              <select name="kind" id="kind">
-                <option value="">All</option>
-                #{kind_options}
-              </select>
-            </div>
-
-            <div class="filter-group">
-              <label for="hostname">Hostname:</label>
-              <input type="text" name="hostname" id="hostname" value="#{@filters[:hostname]}" placeholder="Filter by hostname">
-            </div>
-
-            <div class="filter-group">
-              <label for="status">Status:</label>
-              <select name="status" id="status">
-                <option value="">All</option>
-                <option value="healthy" #{@filters[:status] == 'healthy' ? 'selected' : ''}>Healthy</option>
-                <option value="stale" #{@filters[:status] == 'stale' ? 'selected' : ''}>Stale</option>
-                <option value="dead" #{@filters[:status] == 'dead' ? 'selected' : ''}>Dead</option>
-              </select>
-            </div>
-
-            <div class="filter-actions">
-              <button type="submit" class="filter-button">Apply Filters</button>
-              <a href="#{workers_path}" class="reset-button">Reset</a>
-            </div>
-          </form>
-        </div>
-      HTML
-    end
-
-    def kind_options
-      kinds = %w[Worker Dispatcher Scheduler]
-      kinds.map do |kind|
-        selected = @filters[:kind] == kind ? 'selected' : ''
-        "<option value=\"#{kind}\" #{selected}>#{kind}</option>"
-      end.join
-    end
-
-    def calculate_summary_stats
-      all_processes = all_processes_for_summary
-      @total_count = all_processes.count
-      @healthy_count = all_processes.count { |p| worker_status(p) == :healthy }
-      @stale_count = all_processes.count { |p| worker_status(p) == :stale }
-      @dead_count = all_processes.count { |p| worker_status(p) == :dead }
-    end
-
-    def generate_summary
-      <<-HTML
-        <div class="workers-summary">
-          <div class="summary-card">
-            <span class="summary-label">Total Processes</span>
-            <span class="summary-value">#{@total_count}</span>
-          </div>
-          <div class="summary-card summary-healthy">
-            <span class="summary-label">Healthy</span>
-            <span class="summary-value">#{@healthy_count}</span>
-          </div>
-          <div class="summary-card summary-stale">
-            <span class="summary-label">Stale</span>
-            <span class="summary-value">#{@stale_count}</span>
-          </div>
-          <div class="summary-card summary-dead">
-            <span class="summary-label">Dead</span>
-            <span class="summary-value">#{@dead_count}</span>
-            #{prune_all_link}
-          </div>
-        </div>
-      HTML
-    end
-
-    def prune_all_link
-      return '' if @dead_count.zero?
-
-      suffix = @dead_count > 1 ? 'es' : ''
-      message = "Remove all #{@dead_count} dead process#{suffix}? " \
-                'This will clean up processes that have stopped sending heartbeats.'
-
-      <<-HTML
-        <a href="#" class="summary-action"
-           data-confirm-submit="prune-all-form"
-           data-confirm="#{CGI.escapeHTML(message)}">
-          Prune all
-        </a>
-        <form id="prune-all-form" action="#{prune_workers_path}" method="post" class="is-hidden"></form>
-      HTML
-    end
-
-    def all_processes_for_summary
-      @all_processes_for_summary ||= SolidQueue::Process.all.to_a
-    end
-
-    def generate_table_or_empty
-      if @processes.empty?
-        generate_empty_state
-      else
-        generate_table
-      end
-    end
-
-    def generate_empty_state
-      <<-HTML
-        <div class="empty-state">
-          <p>No worker processes found.</p>
-          <p class="empty-state-hint">Workers will appear here when Solid Queue processes are running.</p>
-        </div>
-      HTML
-    end
-
-    def generate_table
-      <<-HTML
-        <div class="table-container">
-          <table>
-            <thead>
-              <tr>
-                <th>Kind</th>
-                #{sortable_header('hostname', 'Hostname')}
-                <th>PID</th>
-                <th>Queues</th>
-                #{sortable_header('last_heartbeat_at', 'Last Heartbeat')}
-                <th>Status</th>
-                <th>Jobs Processing</th>
-                <th>Actions</th>
-              </tr>
-            </thead>
-            <tbody>
-              #{@processes.map { |process| generate_row(process) }.join}
-            </tbody>
-          </table>
-        </div>
-      HTML
-    end
-
-    def generate_row(process)
-      status = worker_status(process)
-      row_class = case status
-                  when :dead then 'worker-dead'
-                  when :stale then 'worker-stale'
-                  else ''
-                  end
-
-      <<-HTML
-        <tr class="#{row_class}">
-          <td>#{kind_badge(process.kind)}</td>
-          <td>#{hostname(process)}</td>
-          <td><code>#{process.pid}</code></td>
-          <td>#{queues_display(process)}</td>
-          <td>#{format_heartbeat(process.last_heartbeat_at)}</td>
-          <td>#{status_badge(status)}</td>
-          <td>#{jobs_processing(process)}</td>
-          <td class="actions-cell">#{action_button(process, status)}</td>
-        </tr>
-      HTML
-    end
-
-    def action_button(process, status)
-      return '<span class="action-placeholder">-</span>' unless status == :dead
-
-      <<-HTML
-        <form action="#{remove_worker_path(id: process.id)}" method="post" class="inline-form"
-              data-confirm="Remove this dead process from the registry?">
-          <button type="submit" class="action-button discard-button" title="Remove dead process">
-            Remove
-          </button>
-        </form>
-      HTML
-    end
-
-    def kind_badge(kind)
-      badge_class = case kind
-                    when 'Worker' then 'kind-worker'
-                    when 'Dispatcher' then 'kind-dispatcher'
-                    when 'Scheduler' then 'kind-scheduler'
-                    else 'kind-other'
-                    end
-      "<span class=\"kind-badge #{badge_class}\">#{kind}</span>"
-    end
-
-    def hostname(process)
-      process.hostname || parse_metadata(process)['hostname'] || '-'
-    end
-
-    def queues_display(process)
-      metadata = parse_metadata(process)
-      queues = metadata['queues']
-
-      return '-' if queues.nil?
-
-      # Handle string queues (e.g., "*" for all queues)
-      if queues.is_a?(String)
-        return "<code class=\"queue-tag\">#{queues == '*' ? 'All Queues' : queues}</code>"
-      end
-
-      return '-' if queues.empty?
-
-      if queues.length <= 3
-        queues.map { |q| "<code class=\"queue-tag\">#{q}</code>" }.join(' ')
-      else
-        visible = queues.first(2).map { |q| "<code class=\"queue-tag\">#{q}</code>" }.join(' ')
-        "#{visible} <span class=\"queue-more\">+#{queues.length - 2} more</span>"
-      end
-    end
-
-    def format_heartbeat(heartbeat_at)
-      return '-' unless heartbeat_at
-
-      time_ago = time_ago_in_words(heartbeat_at)
-      "<span title=\"#{heartbeat_at.strftime('%Y-%m-%d %H:%M:%S')}\">#{time_ago} ago</span>"
-    end
-
-    def worker_status(process)
-      return :dead unless process.last_heartbeat_at
-
-      time_since_heartbeat = Time.current - process.last_heartbeat_at
-
-      if time_since_heartbeat > HEARTBEAT_DEAD_THRESHOLD
-        :dead
-      elsif time_since_heartbeat > HEARTBEAT_STALE_THRESHOLD
-        :stale
-      else
-        :healthy
-      end
-    end
-
-    def status_badge(status)
-      badges = {
-        healthy: '<span class="status-badge status-healthy">Healthy</span>',
-        stale: '<span class="status-badge status-stale">Stale</span>',
-        dead: '<span class="status-badge status-dead">Dead</span>'
-      }
-      badges[status]
-    end
-
-    def jobs_processing(process)
-      count = @claimed_counts[process.id] || 0
-
-      if count.zero?
-        '<span class="jobs-idle">Idle</span>'
-      else
-        jobs = @claimed_jobs[process.id] || []
-        job_names = jobs.map(&:class_name).uniq.first(3)
-
-        tooltip = jobs.first(10).map { |j| "#{j.class_name} (ID: #{j.id})" }.join('&#10;')
-
-        <<-HTML
-          <span class="jobs-processing" title="#{tooltip}">
-            #{count} job#{count > 1 ? 's' : ''}
-            <span class="job-names">(#{job_names.join(', ')}#{jobs.length > 3 ? '...' : ''})</span>
-          </span>
-        HTML
-      end
-    end
-
-    def preload_claimed_data
-      return if @processes.empty?
-
-      process_ids = @processes.map(&:id)
-
-      # Preload claimed execution counts
-      @claimed_counts = SolidQueue::ClaimedExecution
-                        .where(process_id: process_ids)
-                        .group(:process_id)
-                        .count
-
-      # Preload claimed jobs for processes that have any
-      claimed_executions = SolidQueue::ClaimedExecution
-                           .includes(:job)
-                           .where(process_id: process_ids)
-
-      @claimed_jobs = claimed_executions.each_with_object({}) do |execution, hash|
-        hash[execution.process_id] ||= []
-        hash[execution.process_id] << execution.job
-      end
-    end
-
-    def parse_metadata(process)
-      @parsed_metadata ||= {}
-      @parsed_metadata[process.id] ||= parse_process_metadata(process)
-    end
-
-    def parse_process_metadata(process)
-      return {} unless process.metadata
-
-      if process.metadata.is_a?(String)
-        JSON.parse(process.metadata)
-      else
-        process.metadata
-      end
-    rescue JSON::ParserError
-      {}
-    end
-  end
-end

data/app/services/solid_queue_monitor/chart_presenter.rb

@@ -1,239 +0,0 @@
-# frozen_string_literal: true
-
-module SolidQueueMonitor
-  class ChartPresenter
-    CHART_WIDTH = 1200
-    CHART_HEIGHT = 280
-    PADDING = { top: 40, right: 30, bottom: 60, left: 60 }.freeze
-    COLORS = {
-      created: '#3b82f6',   # Blue
-      completed: '#10b981', # Green
-      failed: '#ef4444'     # Red
-    }.freeze
-
-    def initialize(chart_data)
-      @data = chart_data
-      @plot_width = CHART_WIDTH - PADDING[:left] - PADDING[:right]
-      @plot_height = CHART_HEIGHT - PADDING[:top] - PADDING[:bottom]
-    end
-
-    def render
-      <<-HTML
-        <div class="chart-section" id="chart-section">
-          <div class="chart-header">
-            <div class="chart-header-left">
-              <button class="chart-toggle-btn" id="chart-toggle-btn" title="Toggle chart">
-                <svg class="chart-toggle-icon" id="chart-toggle-icon" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
-                  <polyline points="6 9 12 15 18 9"></polyline>
-                </svg>
-              </button>
-              <h3>Job Activity</h3>
-              #{render_summary}
-            </div>
-            #{render_time_select}
-          </div>
-          <div class="chart-collapsible" id="chart-collapsible">
-            <div class="chart-container">
-              #{render_svg}
-            </div>
-            #{render_legend}
-          </div>
-        </div>
-        #{render_tooltip}
-      HTML
-    end
-
-    private
-
-    def render_summary
-      totals = @data[:totals] || { created: 0, completed: 0, failed: 0 }
-      <<-HTML
-        <span class="chart-summary">
-          <span class="summary-item summary-created">#{totals[:created]} created</span>
-          <span class="summary-separator">·</span>
-          <span class="summary-item summary-completed">#{totals[:completed]} completed</span>
-          <span class="summary-separator">·</span>
-          <span class="summary-item summary-failed">#{totals[:failed]} failed</span>
-        </span>
-      HTML
-    end
-
-    def render_time_select
-      options = @data[:available_ranges].map do |key, label|
-        selected = key == @data[:time_range] ? 'selected' : ''
-        "<option value=\"#{key}\" #{selected}>#{label}</option>"
-      end.join
-
-      <<-HTML
-        <div class="chart-time-select-wrapper">
-          <select class="chart-time-select" id="chart-time-select">
-            #{options}
-          </select>
-        </div>
-      HTML
-    end
-
-    def render_svg
-      return render_empty_state if all_series_empty?
-
-      max_value = calculate_max_value
-      max_value = 10 if max_value.zero?
-
-      <<-SVG
-        <svg viewBox="0 0 #{CHART_WIDTH} #{CHART_HEIGHT}" class="job-activity-chart" preserveAspectRatio="xMidYMid meet">
-          #{render_grid_lines(max_value)}
-          #{render_axes}
-          #{render_x_labels}
-          #{render_y_labels(max_value)}
-          #{render_series_line(:failed, max_value)}
-          #{render_series_line(:completed, max_value)}
-          #{render_series_line(:created, max_value)}
-          #{render_series_points(:failed, max_value)}
-          #{render_series_points(:completed, max_value)}
-          #{render_series_points(:created, max_value)}
-        </svg>
-      SVG
-    end
-
-    def all_series_empty?
-      %i[created completed failed].all? { |series| series_empty?(series) }
-    end
-
-    def series_empty?(series)
-      @data[series].nil? || @data[series].all?(&:zero?)
-    end
-
-    def render_empty_state
-      <<-HTML
-        <div class="chart-empty">
-          <span>No job activity in this time range</span>
-        </div>
-      HTML
-    end
-
-    def render_series_line(series, max_value)
-      return '' if series_empty?(series)
-
-      render_line(series, max_value)
-    end
-
-    def render_series_points(series, max_value)
-      return '' if series_empty?(series)
-
-      render_data_points(series, max_value)
-    end
-
-    def calculate_max_value
-      all_values = @data[:created] + @data[:completed] + @data[:failed]
-      max = all_values.max || 0
-      # Round up to nice number
-      return 10 if max <= 10
-
-      magnitude = 10**Math.log10(max).floor
-      ((max.to_f / magnitude).ceil * magnitude)
-    end
-
-    def render_grid_lines(_max_value)
-      lines = []
-      5.times do |i|
-        y = PADDING[:top] + (@plot_height * i / 4.0)
-        lines << "<line x1=\"#{PADDING[:left]}\" y1=\"#{y}\" x2=\"#{CHART_WIDTH - PADDING[:right]}\" y2=\"#{y}\" class=\"grid-line\"/>"
-      end
-      lines.join("\n")
-    end
-
-    def render_axes
-      <<-SVG
-        <line x1="#{PADDING[:left]}" y1="#{PADDING[:top]}" x2="#{PADDING[:left]}" y2="#{CHART_HEIGHT - PADDING[:bottom]}" class="axis-line"/>
-        <line x1="#{PADDING[:left]}" y1="#{CHART_HEIGHT - PADDING[:bottom]}" x2="#{CHART_WIDTH - PADDING[:right]}" y2="#{CHART_HEIGHT - PADDING[:bottom]}" class="axis-line"/>
-      SVG
-    end
-
-    def render_x_labels
-      labels = @data[:labels]
-      return '' if labels.empty?
-
-      # Show fewer labels if too many
-      step = labels.size > 12 ? (labels.size / 6.0).ceil : 1
-
-      label_elements = labels.each_with_index.map do |label, i|
-        next unless (i % step).zero? || i == labels.size - 1
-
-        x = PADDING[:left] + (@plot_width * i / (labels.size - 1).to_f)
-        "<text x=\"#{x}\" y=\"#{CHART_HEIGHT - PADDING[:bottom] + 20}\" class=\"axis-label x-label\">#{label}</text>"
-      end.compact
-
-      label_elements.join("\n")
-    end
-
-    def render_y_labels(max_value)
-      labels = []
-      5.times do |i|
-        value = (max_value * (4 - i) / 4.0).round
-        y = PADDING[:top] + (@plot_height * i / 4.0)
-        labels << "<text x=\"#{PADDING[:left] - 10}\" y=\"#{y + 4}\" class=\"axis-label y-label\">#{value}</text>"
-      end
-      labels.join("\n")
-    end
-
-    def render_line(series, max_value)
-      points = calculate_points(series, max_value)
-      return '' if points.empty?
-
-      points_str = points.map { |p| "#{p[:x]},#{p[:y]}" }.join(' ')
-
-      "<polyline points=\"#{points_str}\" class=\"chart-line chart-line-#{series}\" fill=\"none\" stroke=\"#{COLORS[series]}\" stroke-width=\"2\"/>"
-    end
-
-    def render_data_points(series, max_value)
-      points = calculate_points(series, max_value)
-      values = @data[series]
-
-      points.each_with_index.map do |point, i|
-        <<-SVG
-          <circle cx="#{point[:x]}" cy="#{point[:y]}" r="4" class="data-point data-point-#{series}" fill="#{COLORS[series]}"
-            data-series="#{series}" data-label="#{@data[:labels][i]}" data-value="#{values[i]}"/>
-        SVG
-      end.join("\n")
-    end
-
-    def calculate_points(series, max_value)
-      values = @data[series]
-      return [] if values.blank?
-
-      values.each_with_index.map do |value, i|
-        x = PADDING[:left] + (@plot_width * i / (values.size - 1).to_f)
-        y = CHART_HEIGHT - PADDING[:bottom] - (@plot_height * value / max_value.to_f)
-        { x: x.round(2), y: y.round(2) }
-      end
-    end
-
-    def render_legend
-      <<-HTML
-        <div class="chart-legend">
-          <span class="legend-item">
-            <span class="legend-color legend-color-created"></span>
-            Created
-          </span>
-          <span class="legend-item">
-            <span class="legend-color legend-color-completed"></span>
-            Completed
-          </span>
-          <span class="legend-item">
-            <span class="legend-color legend-color-failed"></span>
-            Failed
-          </span>
-        </div>
-      HTML
-    end
-
-    def render_tooltip
-      <<-HTML
-        <div id="chart-tooltip" class="chart-tooltip">
-          <div class="tooltip-label"></div>
-          <div class="tooltip-value"></div>
-        </div>
-      HTML
-    end
-  end
-end