solid_queue_monitor 1.3.0 → 2.1.0

data/app/controllers/solid_queue_monitor/base_controller.rb

@@ -6,35 +6,6 @@ module SolidQueueMonitor
       PaginationService.new(relation, current_page, per_page).paginate
     end
 
-    def render_page(title, content, search_query: nil)
-      # Get flash message from instance variable (set by set_flash_message) or session
-      message = @flash_message
-      message_type = @flash_type
-
-      # Try to get from session as fallback, but don't fail if session unavailable
-      begin
-        message ||= session[:flash_message]
-        message_type ||= session[:flash_type]
-
-        # Clear the flash message from session after using it
-        session.delete(:flash_message) if message
-        session.delete(:flash_type) if message_type
-      rescue StandardError
-        # Session not available (e.g., no session middleware in tests)
-      end
-
-      html = SolidQueueMonitor::HtmlGenerator.new(
-        title: title,
-        content: content,
-        message: message,
-        message_type: message_type,
-        search_query: search_query,
-        nonce: content_security_policy_nonce
-      ).generate
-
-      render html: html.html_safe
-    end
-
     def current_page
       (params[:page] || 1).to_i
     end

data/app/controllers/solid_queue_monitor/failed_jobs_controller.rb

@@ -8,13 +8,9 @@ module SolidQueueMonitor
       base_query = SolidQueue::FailedExecution.includes(:job)
       sorted_query = apply_execution_sorting(filter_failed_jobs(base_query), SORTABLE_COLUMNS, 'created_at', :desc)
       @failed_jobs = paginate(sorted_query)
-
-      render_page('Failed Jobs', SolidQueueMonitor::FailedJobsPresenter.new(@failed_jobs[:records],
-                                                                            current_page: @failed_jobs[:current_page],
-                                                                            total_pages: @failed_jobs[:total_pages],
-                                                                            filters: filter_params,
-                                                                            sort: sort_params,
-                                                                            nonce: content_security_policy_nonce).render)
+      @filters = filter_params
+      @sort = sort_params
+      @action_path = failed_jobs_path
     end
 
     def retry

data/app/controllers/solid_queue_monitor/in_progress_jobs_controller.rb

@@ -8,12 +8,9 @@ module SolidQueueMonitor
       base_query = SolidQueue::ClaimedExecution.includes(:job)
       sorted_query = apply_execution_sorting(filter_in_progress_jobs(base_query), SORTABLE_COLUMNS, 'created_at', :desc)
       @in_progress_jobs = paginate(sorted_query)
-
-      render_page('In Progress Jobs', SolidQueueMonitor::InProgressJobsPresenter.new(@in_progress_jobs[:records],
-                                                                                     current_page: @in_progress_jobs[:current_page],
-                                                                                     total_pages: @in_progress_jobs[:total_pages],
-                                                                                     filters: filter_params,
-                                                                                     sort: sort_params).render)
+      @filters = filter_params
+      @sort = sort_params
+      @action_path = in_progress_jobs_path
     end
 
     private

data/app/controllers/solid_queue_monitor/jobs_controller.rb

@@ -11,13 +11,9 @@ module SolidQueueMonitor
         return
       end
 
-      job_data = load_job_data(@job)
-
-      render_page("Job ##{@job.id}", SolidQueueMonitor::JobDetailsPresenter.new(
-        @job,
-        **job_data,
-        nonce: content_security_policy_nonce
-      ).render)
+      load_job_data(@job).each do |name, value|
+        instance_variable_set("@#{name}", value)
+      end
     end
 
     private

data/app/controllers/solid_queue_monitor/overview_controller.rb

@@ -7,14 +7,15 @@ module SolidQueueMonitor
     def index
       @stats = SolidQueueMonitor::StatsCalculator.calculate
       @chart_data = SolidQueueMonitor.show_chart ? SolidQueueMonitor::ChartDataService.new(time_range: time_range_param).calculate : nil
+      @time_range = time_range_param
 
       recent_jobs_query = SolidQueue::Job.limit(100)
       sorted_query = apply_sorting(filter_jobs(recent_jobs_query), SORTABLE_COLUMNS, 'created_at', :desc)
       @recent_jobs = paginate(sorted_query)
+      @filters = filter_params
+      @sort = sort_params
 
       preload_job_statuses(@recent_jobs[:records])
-
-      render_page('Overview', generate_overview_content)
     end
 
     def chart_data
@@ -27,15 +28,5 @@ module SolidQueueMonitor
     def time_range_param
       params[:time_range] || ChartDataService::DEFAULT_TIME_RANGE
     end
-
-    def generate_overview_content
-      html = SolidQueueMonitor::StatsPresenter.new(@stats).render
-      html += SolidQueueMonitor::ChartPresenter.new(@chart_data).render if @chart_data
-      html + SolidQueueMonitor::JobsPresenter.new(@recent_jobs[:records],
-                                                  current_page: @recent_jobs[:current_page],
-                                                  total_pages: @recent_jobs[:total_pages],
-                                                  filters: filter_params,
-                                                  sort: sort_params).render
-    end
   end
 end

data/app/controllers/solid_queue_monitor/queues_controller.rb

@@ -11,12 +11,7 @@ module SolidQueueMonitor
       @queues = apply_queue_sorting(base_query)
       @paused_queues = QueuePauseService.paused_queues
       @queue_stats = aggregate_queue_stats
-
-      render_page('Queues', SolidQueueMonitor::QueuesPresenter.new(
-        @queues, @paused_queues,
-        queue_stats: @queue_stats,
-        sort: sort_params
-      ).render)
+      @sort = sort_params
     end
 
     def show
@@ -30,18 +25,9 @@ module SolidQueueMonitor
       preload_job_statuses(@jobs[:records])
 
       @counts = calculate_queue_counts(@queue_name)
-
-      render_page("Queue: #{@queue_name}",
-                  SolidQueueMonitor::QueueDetailsPresenter.new(
-                    queue_name: @queue_name,
-                    paused: @paused,
-                    jobs: @jobs[:records],
-                    counts: @counts,
-                    current_page: @jobs[:current_page],
-                    total_pages: @jobs[:total_pages],
-                    filters: queue_filter_params,
-                    sort: sort_params
-                  ).render)
+      @filters = queue_filter_params
+      @sort = sort_params
+      @action_path = queue_details_path(queue_name: @queue_name)
     end
 
     def pause

data/app/controllers/solid_queue_monitor/ready_jobs_controller.rb

@@ -8,12 +8,9 @@ module SolidQueueMonitor
       base_query = SolidQueue::ReadyExecution.includes(:job)
       sorted_query = apply_execution_sorting(filter_ready_jobs(base_query), SORTABLE_COLUMNS, 'created_at', :desc)
       @ready_jobs = paginate(sorted_query)
-
-      render_page('Ready Jobs', SolidQueueMonitor::ReadyJobsPresenter.new(@ready_jobs[:records],
-                                                                          current_page: @ready_jobs[:current_page],
-                                                                          total_pages: @ready_jobs[:total_pages],
-                                                                          filters: filter_params,
-                                                                          sort: sort_params).render)
+      @filters = filter_params
+      @sort = sort_params
+      @action_path = ready_jobs_path
     end
   end
 end

data/app/controllers/solid_queue_monitor/recurring_jobs_controller.rb

@@ -8,12 +8,9 @@ module SolidQueueMonitor
       base_query = filter_recurring_jobs(SolidQueue::RecurringTask.all)
       sorted_query = apply_sorting(base_query, SORTABLE_COLUMNS, 'key', :asc)
       @recurring_jobs = paginate(sorted_query)
-
-      render_page('Recurring Jobs', SolidQueueMonitor::RecurringJobsPresenter.new(@recurring_jobs[:records],
-                                                                                  current_page: @recurring_jobs[:current_page],
-                                                                                  total_pages: @recurring_jobs[:total_pages],
-                                                                                  filters: filter_params,
-                                                                                  sort: sort_params).render)
+      @filters = filter_params
+      @sort = sort_params
+      @action_path = recurring_jobs_path
     end
   end
 end

data/app/controllers/solid_queue_monitor/scheduled_jobs_controller.rb

@@ -8,13 +8,9 @@ module SolidQueueMonitor
       base_query = SolidQueue::ScheduledExecution.includes(:job)
       sorted_query = apply_execution_sorting(filter_scheduled_jobs(base_query), SORTABLE_COLUMNS, 'scheduled_at', :asc)
       @scheduled_jobs = paginate(sorted_query)
-
-      render_page('Scheduled Jobs', SolidQueueMonitor::ScheduledJobsPresenter.new(@scheduled_jobs[:records],
-                                                                                  current_page: @scheduled_jobs[:current_page],
-                                                                                  total_pages: @scheduled_jobs[:total_pages],
-                                                                                  filters: filter_params,
-                                                                                  sort: sort_params,
-                                                                                  nonce: content_security_policy_nonce).render)
+      @filters = filter_params
+      @sort = sort_params
+      @action_path = scheduled_jobs_path
     end
 
     def create

data/app/controllers/solid_queue_monitor/search_controller.rb

@@ -3,10 +3,9 @@
 module SolidQueueMonitor
   class SearchController < BaseController
     def index
-      query = params[:q]
-      results = SearchService.new(query).search
-
-      render_page('Search', SearchResultsPresenter.new(query, results).render, search_query: query)
+      @query = params[:q]
+      @results = SearchService.new(@query).search
+      @total_count = @results.values.sum(&:size)
     end
   end
 end

data/app/controllers/solid_queue_monitor/workers_controller.rb

@@ -8,14 +8,11 @@ module SolidQueueMonitor
       base_query = SolidQueue::Process.all
       sorted_query = apply_sorting(filter_workers(base_query), SORTABLE_COLUMNS, 'last_heartbeat_at', :desc)
       @processes = paginate(sorted_query)
-
-      render_page('Workers', SolidQueueMonitor::WorkersPresenter.new(
-        @processes[:records],
-        current_page: @processes[:current_page],
-        total_pages: @processes[:total_pages],
-        filters: worker_filter_params,
-        sort: sort_params
-      ).render)
+      @process_records = @processes[:records].to_a
+      @filters = worker_filter_params
+      @sort = sort_params
+      @summary = worker_summary
+      preload_claimed_data
     end
 
     def remove
@@ -73,5 +70,24 @@ module SolidQueueMonitor
         status: params[:status]
       }
     end
+
+    def worker_summary
+      all_processes = SolidQueue::Process.all.to_a
+      {
+        total: all_processes.count,
+        healthy: all_processes.count { |process| view_context.worker_status(process) == :healthy },
+        stale: all_processes.count { |process| view_context.worker_status(process) == :stale },
+        dead: all_processes.count { |process| view_context.worker_status(process) == :dead }
+      }
+    end
+
+    def preload_claimed_data
+      process_ids = @process_records.map(&:id)
+      @claimed_counts = SolidQueue::ClaimedExecution.where(process_id: process_ids).group(:process_id).count
+      @claimed_jobs = SolidQueue::ClaimedExecution.includes(:job).where(process_id: process_ids).each_with_object({}) do |execution, hash|
+        hash[execution.process_id] ||= []
+        hash[execution.process_id] << execution.job
+      end
+    end
   end
 end

data/app/helpers/solid_queue_monitor/application_helper.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module SolidQueueMonitor
+  module ApplicationHelper
+    def asset_url_for(file_name)
+      base = File.basename(file_name, '.*')
+      ext = File.extname(file_name)
+      hash = SolidQueueMonitor::AssetCache.fingerprint_for(file_name)
+      fingerprinted_file = "#{base}-#{hash}#{ext}"
+
+      if respond_to?(:solid_queue_monitor)
+        solid_queue_monitor.asset_path(file: fingerprinted_file)
+      else
+        SolidQueueMonitor::Engine.routes.url_helpers.asset_path(file: fingerprinted_file)
+      end
+    end
+
+    def format_datetime(datetime)
+      return '-' unless datetime
+
+      datetime.strftime('%Y-%m-%d %H:%M:%S')
+    end
+
+    def message_class(type)
+      type.to_s == 'success' ? 'message-success' : 'message-error'
+    end
+
+    def queue_link(queue_name, css_class: nil)
+      return '-' if queue_name.blank?
+
+      link_to(queue_name,
+              queue_details_url_for(queue_name),
+              class: class_names('queue-link', css_class))
+    end
+
+    private
+
+    def queue_details_url_for(queue_name)
+      if respond_to?(:queue_details_path)
+        queue_details_path(queue_name: queue_name)
+      else
+        SolidQueueMonitor::Engine.routes.url_helpers.queue_details_path(queue_name: queue_name)
+      end
+    end
+  end
+end

data/app/helpers/solid_queue_monitor/chart_helper.rb

@@ -0,0 +1,293 @@
+# frozen_string_literal: true
+
+module SolidQueueMonitor
+  # rubocop:disable Metrics/ModuleLength
+  module ChartHelper
+    CHART_WIDTH = 1200
+    CHART_HEIGHT = 280
+    PADDING = { top: 40, right: 30, bottom: 60, left: 60 }.freeze
+    COLORS = {
+      created: '#3b82f6',
+      completed: '#10b981',
+      failed: '#ef4444'
+    }.freeze
+    SERIES = %i[failed completed created].freeze
+
+    def render_chart(data:, time_range: nil)
+      context = chart_context(data, time_range)
+
+      safe_join(
+        [
+          chart_section(context),
+          chart_tooltip
+        ]
+      )
+    end
+
+    def chart_time_range_options
+      SolidQueueMonitor::ChartDataService::TIME_RANGES.map do |key, config|
+        [config[:label], key]
+      end
+    end
+
+    private
+
+    def chart_context(data, time_range)
+      {
+        data: data.merge(time_range: time_range || data[:time_range]),
+        plot_width: CHART_WIDTH - PADDING[:left] - PADDING[:right],
+        plot_height: CHART_HEIGHT - PADDING[:top] - PADDING[:bottom]
+      }
+    end
+
+    def chart_section(context)
+      tag.div(id: 'chart-section', class: 'chart-section') do
+        safe_join(
+          [
+            chart_header(context),
+            tag.div(id: 'chart-collapsible', class: 'chart-collapsible') do
+              safe_join(
+                [
+                  tag.div(chart_body(context), class: 'chart-container'),
+                  chart_legend
+                ]
+              )
+            end
+          ]
+        )
+      end
+    end
+
+    def chart_header(context)
+      tag.div(class: 'chart-header') do
+        safe_join(
+          [
+            tag.div(class: 'chart-header-left') do
+              safe_join(
+                [
+                  chart_toggle_button,
+                  tag.h3('Job Activity'),
+                  chart_summary(context)
+                ]
+              )
+            end,
+            chart_time_select(context)
+          ]
+        )
+      end
+    end
+
+    def chart_toggle_button
+      tag.button(class: 'chart-toggle-btn', id: 'chart-toggle-btn', title: 'Toggle chart') do
+        tag.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) do
+          tag.polyline(points: '6 9 12 15 18 9')
+        end
+      end
+    end
+
+    def chart_summary(context)
+      totals = context[:data][:totals] || { created: 0, completed: 0, failed: 0 }
+
+      tag.span(class: 'chart-summary') do
+        safe_join(
+          [
+            tag.span("#{totals[:created]} created", class: 'summary-item summary-created'),
+            tag.span('.', class: 'summary-separator'),
+            tag.span("#{totals[:completed]} completed", class: 'summary-item summary-completed'),
+            tag.span('.', class: 'summary-separator'),
+            tag.span("#{totals[:failed]} failed", class: 'summary-item summary-failed')
+          ],
+          ' '
+        )
+      end
+    end
+
+    def chart_time_select(context)
+      options = context[:data][:available_ranges].map do |key, label|
+        tag.option(label, value: key, selected: key == context[:data][:time_range])
+      end
+
+      tag.div(class: 'chart-time-select-wrapper') do
+        tag.select(safe_join(options), class: 'chart-time-select', id: 'chart-time-select')
+      end
+    end
+
+    def chart_body(context)
+      return chart_empty_state if all_series_empty?(context)
+
+      max_value = [calculate_max_value(context), 10].max
+
+      tag.svg(viewBox: "0 0 #{CHART_WIDTH} #{CHART_HEIGHT}",
+              class: 'job-activity-chart',
+              preserveAspectRatio: 'xMidYMid meet') do
+        safe_join(
+          [
+            chart_grid_lines(context),
+            chart_axes,
+            chart_x_labels(context),
+            chart_y_labels(context, max_value),
+            *SERIES.map { |series| series_line(context, series, max_value) },
+            *SERIES.map { |series| series_points(context, series, max_value) }
+          ].compact
+        )
+      end
+    end
+
+    def chart_empty_state
+      tag.div(class: 'chart-empty') do
+        tag.span('No job activity in this time range')
+      end
+    end
+
+    def chart_grid_lines(context)
+      safe_join(
+        5.times.map do |index|
+          y = PADDING[:top] + (context[:plot_height] * index / 4.0)
+          tag.line(x1: PADDING[:left],
+                   y1: y,
+                   x2: CHART_WIDTH - PADDING[:right],
+                   y2: y,
+                   class: 'grid-line')
+        end
+      )
+    end
+
+    def chart_axes
+      safe_join(
+        [
+          tag.line(x1: PADDING[:left],
+                   y1: PADDING[:top],
+                   x2: PADDING[:left],
+                   y2: CHART_HEIGHT - PADDING[:bottom],
+                   class: 'axis-line'),
+          tag.line(x1: PADDING[:left],
+                   y1: CHART_HEIGHT - PADDING[:bottom],
+                   x2: CHART_WIDTH - PADDING[:right],
+                   y2: CHART_HEIGHT - PADDING[:bottom],
+                   class: 'axis-line')
+        ]
+      )
+    end
+
+    def chart_x_labels(context)
+      labels = context[:data][:labels]
+      return ''.html_safe if labels.blank?
+
+      step = labels.size > 12 ? (labels.size / 6.0).ceil : 1
+      safe_join(labels.each_with_index.filter_map do |label, index|
+        next unless (index % step).zero? || index == labels.size - 1
+
+        tag.text(label,
+                 x: x_for_index(context, index, labels.size),
+                 y: CHART_HEIGHT - PADDING[:bottom] + 20,
+                 class: 'axis-label x-label')
+      end)
+    end
+
+    def chart_y_labels(context, max_value)
+      safe_join(
+        5.times.map do |index|
+          value = (max_value * (4 - index) / 4.0).round
+          y = PADDING[:top] + (context[:plot_height] * index / 4.0)
+          tag.text(value, x: PADDING[:left] - 10, y: y + 4, class: 'axis-label y-label')
+        end
+      )
+    end
+
+    def series_line(context, series, max_value)
+      return if series_empty?(context, series)
+
+      points = calculate_points(context, series, max_value)
+      return if points.empty?
+
+      tag.polyline(points: points.map { |point| "#{point[:x]},#{point[:y]}" }.join(' '),
+                   class: "chart-line chart-line-#{series}",
+                   fill: 'none',
+                   stroke: COLORS[series],
+                   stroke_width: 2)
+    end
+
+    def series_points(context, series, max_value)
+      return if series_empty?(context, series)
+
+      values = context[:data][series]
+      safe_join(calculate_points(context, series, max_value).each_with_index.map do |point, index|
+        tag.circle(cx: point[:x],
+                   cy: point[:y],
+                   r: 4,
+                   class: "data-point data-point-#{series}",
+                   fill: COLORS[series],
+                   data: { series: series, label: context[:data][:labels][index], value: values[index] })
+      end)
+    end
+
+    def chart_legend
+      tag.div(class: 'chart-legend') do
+        safe_join(%i[created completed failed].map do |series|
+          tag.span(class: 'legend-item') do
+            safe_join(
+              [
+                tag.span('', class: "legend-color legend-color-#{series}"),
+                series.to_s.capitalize
+              ],
+              "\n"
+            )
+          end
+        end)
+      end
+    end
+
+    def chart_tooltip
+      tag.div(id: 'chart-tooltip', class: 'chart-tooltip') do
+        safe_join(
+          [
+            tag.div('', class: 'tooltip-label'),
+            tag.div('', class: 'tooltip-value')
+          ]
+        )
+      end
+    end
+
+    def all_series_empty?(context)
+      %i[created completed failed].all? { |series| series_empty?(context, series) }
+    end
+
+    def series_empty?(context, series)
+      context[:data][series].nil? || context[:data][series].all?(&:zero?)
+    end
+
+    def calculate_max_value(context)
+      max = (context[:data][:created] + context[:data][:completed] + context[:data][:failed]).max || 0
+      return 10 if max <= 10
+
+      magnitude = 10**Math.log10(max).floor
+      ((max.to_f / magnitude).ceil * magnitude)
+    end
+
+    def calculate_points(context, series, max_value)
+      values = context[:data][series]
+      return [] if values.blank?
+
+      values.each_with_index.map do |value, index|
+        {
+          x: x_for_index(context, index, values.size).round(2),
+          y: (CHART_HEIGHT - PADDING[:bottom] - (context[:plot_height] * value / max_value.to_f)).round(2)
+        }
+      end
+    end
+
+    def x_for_index(context, index, count)
+      return PADDING[:left] if count <= 1
+
+      PADDING[:left] + (context[:plot_width] * index / (count - 1).to_f)
+    end
+  end
+  # rubocop:enable Metrics/ModuleLength
+end

data/app/helpers/solid_queue_monitor/job_details_helper.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module SolidQueueMonitor
+  module JobDetailsHelper
+    def detail_job_status(job:, failed_execution:, claimed_execution:, scheduled_execution:)
+      return :failed if failed_execution
+      return :in_progress if claimed_execution
+      return :scheduled if scheduled_execution || job.scheduled_at&.future?
+      return :completed if job.finished_at
+
+      :pending
+    end
+
+    def detail_status_label(status = detail_job_status)
+      {
+        failed: 'Failed',
+        in_progress: 'In Progress',
+        scheduled: 'Scheduled',
+        completed: 'Completed',
+        pending: 'Pending'
+      }[status]
+    end
+
+    def detail_status_class(status = detail_job_status)
+      "status-#{status.to_s.tr('_', '-')}"
+    end
+
+    def detail_duration(seconds)
+      return '-' unless seconds
+      return "#{(seconds * 1000).round}ms" if seconds < 1
+      return "#{seconds.round(1)}s" if seconds < 60
+      return "#{(seconds / 60).floor}m #{(seconds % 60).round}s" if seconds < 3600
+
+      "#{(seconds / 3600).floor}h #{((seconds % 3600) / 60).floor}m"
+    end
+
+    def detail_timing(job:, claimed_execution:, failed_execution:)
+      created_at = job.created_at
+      started_at = claimed_execution&.created_at
+      finished_at = job.finished_at
+      failed_at = failed_execution&.created_at
+      end_time = finished_at || failed_at
+
+      {
+        queue_wait: started_at && created_at ? started_at - created_at : nil,
+        execution: started_at && end_time ? end_time - started_at : nil,
+        total: created_at && end_time ? end_time - created_at : nil
+      }
+    end
+
+    def pretty_arguments(args)
+      return '-' if args.blank?
+
+      JSON.pretty_generate(args)
+    rescue JSON::GeneratorError
+      args.inspect
+    end
+
+    def recent_job_duration(job)
+      end_time = job.finished_at || job.failed_execution&.created_at
+      return '-' unless end_time
+
+      detail_duration(end_time - job.created_at)
+    end
+  end
+end