solid_queue_monitor 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1014e5b1b9afceff146efc3a81849dd12866578198b8172452d9b6edf42d7786
-  data.tar.gz: 0b2c11f5ba47a7e977c93cdb7a048c91d092b9ea97d72af27e908f6f24387fbf
+  metadata.gz: bc739f10c21ca234c61c65a5b94d9c548cfc8d332dac0d1db3311d0d113fe035
+  data.tar.gz: 4a131b01c6c3e330b46413029278dbcee09e4f6410f1edf44b14da5902ec5b1a
 SHA512:
-  metadata.gz: 58bf74bb26fbb518d58e555d1a22695d3175b0ea683529685b4cec6322091722fd7a8eb912bb0fbbfa0fce391663777fc69cde137bf4a4cb0fb1e1cf9d16bbf2
-  data.tar.gz: 59be98bcc8ee044ac0eac816cab397534c79da53cb98cfb670da1e0747552425f33eaf6dce51e2f906c44f9053b4097a8a79e3f2d6fe30534ddbad6e7f3d3d70
+  metadata.gz: 02b79913620ac69eb63c15b2c92a1ba76f44f981036f977eb72fe684faa28ae2057ea187582e8bbd5cb09c0de9f030be89e07b8e8e8e754ee0ffebd6e7c33f84
+  data.tar.gz: 853dc16edd433afa568a7cef1efb78b295d54595a72e1e7c177e7991ff50b3e396d80ab1092754e65972dbe0fa9072e2a4563ab68b4785ebe7b5d77b5373e086

data/README.md

@@ -72,7 +72,7 @@ A lightweight, zero-dependency web interface for monitoring Solid Queue backgrou
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'solid_queue_monitor', '~> 1.1'
+gem 'solid_queue_monitor', '~> 1.2'
 ```
 
 Then execute:
@@ -118,9 +118,22 @@ SolidQueueMonitor.setup do |config|
 
   # Auto-refresh interval in seconds (default: 30)
   config.auto_refresh_interval = 30
+
+  # Disable the chart on the overview page to skip chart queries entirely
+  # config.show_chart = true
 end
 ```
 
+### Performance at Scale
+
+SolidQueueMonitor is optimized for large datasets (millions of rows in `solid_queue_jobs`). All dashboard queries are designed to stay fast regardless of table size.
+
+If you don't need the job activity chart, disable it to skip chart queries entirely:
+
+```ruby
+config.show_chart = false
+```
+
 ### Authentication
 
 By default, Solid Queue Monitor does not require authentication to access the dashboard. This makes it easy to get started in development environments.

data/app/controllers/solid_queue_monitor/base_controller.rb

@@ -91,17 +91,13 @@ module SolidQueueMonitor
         when 'completed'
           relation = relation.where.not(finished_at: nil)
         when 'failed'
-          failed_job_ids = SolidQueue::FailedExecution.pluck(:job_id)
-          relation = relation.where(id: failed_job_ids)
+          relation = relation.where(id: SolidQueue::FailedExecution.select(:job_id))
         when 'scheduled'
-          scheduled_job_ids = SolidQueue::ScheduledExecution.pluck(:job_id)
-          relation = relation.where(id: scheduled_job_ids)
+          relation = relation.where(id: SolidQueue::ScheduledExecution.select(:job_id))
         when 'pending'
-          # Pending jobs are those that are not completed, failed, or scheduled
-          failed_job_ids = SolidQueue::FailedExecution.pluck(:job_id)
-          scheduled_job_ids = SolidQueue::ScheduledExecution.pluck(:job_id)
           relation = relation.where(finished_at: nil)
-                             .where.not(id: failed_job_ids + scheduled_job_ids)
+                             .where.not(id: SolidQueue::FailedExecution.select(:job_id))
+                             .where.not(id: SolidQueue::ScheduledExecution.select(:job_id))
         end
       end
 
@@ -117,16 +113,13 @@ module SolidQueueMonitor
       return relation unless params[:class_name].present? || params[:queue_name].present? || params[:arguments].present?
 
       if params[:class_name].present?
-        job_ids = SolidQueue::Job.where('class_name LIKE ?', "%#{params[:class_name]}%").pluck(:id)
-        relation = relation.where(job_id: job_ids)
+        relation = relation.where(job_id: SolidQueue::Job.where('class_name LIKE ?', "%#{params[:class_name]}%").select(:id))
       end
 
       relation = relation.where('queue_name LIKE ?', "%#{params[:queue_name]}%") if params[:queue_name].present?
 
-      # Add arguments filtering
       if params[:arguments].present?
-        job_ids = SolidQueue::Job.where('arguments::text ILIKE ?', "%#{params[:arguments]}%").pluck(:id)
-        relation = relation.where(job_id: job_ids)
+        relation = relation.where(job_id: SolidQueue::Job.where('arguments::text ILIKE ?', "%#{params[:arguments]}%").select(:id))
       end
 
       relation
@@ -136,16 +129,13 @@ module SolidQueueMonitor
       return relation unless params[:class_name].present? || params[:queue_name].present? || params[:arguments].present?
 
       if params[:class_name].present?
-        job_ids = SolidQueue::Job.where('class_name LIKE ?', "%#{params[:class_name]}%").pluck(:id)
-        relation = relation.where(job_id: job_ids)
+        relation = relation.where(job_id: SolidQueue::Job.where('class_name LIKE ?', "%#{params[:class_name]}%").select(:id))
       end
 
       relation = relation.where('queue_name LIKE ?', "%#{params[:queue_name]}%") if params[:queue_name].present?
 
-      # Add arguments filtering
       if params[:arguments].present?
-        job_ids = SolidQueue::Job.where('arguments::text ILIKE ?', "%#{params[:arguments]}%").pluck(:id)
-        relation = relation.where(job_id: job_ids)
+        relation = relation.where(job_id: SolidQueue::Job.where('arguments::text ILIKE ?', "%#{params[:arguments]}%").select(:id))
       end
 
       relation
@@ -170,25 +160,19 @@ module SolidQueueMonitor
       return relation unless params[:class_name].present? || params[:queue_name].present? || params[:arguments].present?
 
       if params[:class_name].present?
-        job_ids = SolidQueue::Job.where('class_name LIKE ?', "%#{params[:class_name]}%").pluck(:id)
-        relation = relation.where(job_id: job_ids)
+        relation = relation.where(job_id: SolidQueue::Job.where('class_name LIKE ?', "%#{params[:class_name]}%").select(:id))
       end
 
       if params[:queue_name].present?
-        # Check if FailedExecution has queue_name column
-        if relation.column_names.include?('queue_name')
-          relation = relation.where('queue_name LIKE ?', "%#{params[:queue_name]}%")
-        else
-          # If not, filter by job's queue_name
-          job_ids = SolidQueue::Job.where('queue_name LIKE ?', "%#{params[:queue_name]}%").pluck(:id)
-          relation = relation.where(job_id: job_ids)
-        end
+        relation = if relation.column_names.include?('queue_name')
+                     relation.where('queue_name LIKE ?', "%#{params[:queue_name]}%")
+                   else
+                     relation.where(job_id: SolidQueue::Job.where('queue_name LIKE ?', "%#{params[:queue_name]}%").select(:id))
+                   end
       end
 
-      # Add arguments filtering
       if params[:arguments].present?
-        job_ids = SolidQueue::Job.where('arguments::text ILIKE ?', "%#{params[:arguments]}%").pluck(:id)
-        relation = relation.where(job_id: job_ids)
+        relation = relation.where(job_id: SolidQueue::Job.where('arguments::text ILIKE ?', "%#{params[:arguments]}%").select(:id))
       end
 
       relation

data/app/controllers/solid_queue_monitor/in_progress_jobs_controller.rb

@@ -22,13 +22,11 @@ module SolidQueueMonitor
       return relation if params[:class_name].blank? && params[:arguments].blank?
 
       if params[:class_name].present?
-        job_ids = SolidQueue::Job.where('class_name LIKE ?', "%#{params[:class_name]}%").pluck(:id)
-        relation = relation.where(job_id: job_ids)
+        relation = relation.where(job_id: SolidQueue::Job.where('class_name LIKE ?', "%#{params[:class_name]}%").select(:id))
       end
 
       if params[:arguments].present?
-        job_ids = SolidQueue::Job.where('arguments::text ILIKE ?', "%#{params[:arguments]}%").pluck(:id)
-        relation = relation.where(job_id: job_ids)
+        relation = relation.where(job_id: SolidQueue::Job.where('arguments::text ILIKE ?', "%#{params[:arguments]}%").select(:id))
       end
 
       relation

data/app/controllers/solid_queue_monitor/overview_controller.rb

@@ -6,7 +6,7 @@ module SolidQueueMonitor
 
     def index
       @stats = SolidQueueMonitor::StatsCalculator.calculate
-      @chart_data = SolidQueueMonitor::ChartDataService.new(time_range: time_range_param).calculate
+      @chart_data = SolidQueueMonitor.show_chart ? SolidQueueMonitor::ChartDataService.new(time_range: time_range_param).calculate : nil
 
       recent_jobs_query = SolidQueue::Job.limit(100)
       sorted_query = apply_sorting(filter_jobs(recent_jobs_query), SORTABLE_COLUMNS, 'created_at', :desc)
@@ -29,13 +29,13 @@ module SolidQueueMonitor
     end
 
     def generate_overview_content
-      SolidQueueMonitor::StatsPresenter.new(@stats).render +
-        SolidQueueMonitor::ChartPresenter.new(@chart_data).render +
-        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
+      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

@@ -10,8 +10,13 @@ module SolidQueueMonitor
                                   .select('queue_name, COUNT(*) as job_count')
       @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, sort: sort_params).render)
+      render_page('Queues', SolidQueueMonitor::QueuesPresenter.new(
+        @queues, @paused_queues,
+        queue_stats: @queue_stats,
+        sort: sort_params
+      ).render)
     end
 
     def show
@@ -57,6 +62,15 @@ module SolidQueueMonitor
 
     private
 
+    def aggregate_queue_stats
+      {
+        ready: SolidQueue::ReadyExecution.group(:queue_name).count,
+        scheduled: SolidQueue::ScheduledExecution.group(:queue_name).count,
+        failed: SolidQueue::FailedExecution.joins(:job)
+                                           .group('solid_queue_jobs.queue_name').count
+      }
+    end
+
     def calculate_queue_counts(queue_name)
       {
         total: SolidQueue::Job.where(queue_name: queue_name).count,
@@ -77,17 +91,13 @@ module SolidQueueMonitor
         when 'completed'
           relation = relation.where.not(finished_at: nil)
         when 'failed'
-          failed_job_ids = SolidQueue::FailedExecution.pluck(:job_id)
-          relation = relation.where(id: failed_job_ids)
+          relation = relation.where(id: SolidQueue::FailedExecution.select(:job_id))
         when 'scheduled'
-          scheduled_job_ids = SolidQueue::ScheduledExecution.pluck(:job_id)
-          relation = relation.where(id: scheduled_job_ids)
+          relation = relation.where(id: SolidQueue::ScheduledExecution.select(:job_id))
         when 'pending'
-          ready_job_ids = SolidQueue::ReadyExecution.pluck(:job_id)
-          relation = relation.where(id: ready_job_ids)
+          relation = relation.where(id: SolidQueue::ReadyExecution.select(:job_id))
         when 'in_progress'
-          claimed_job_ids = SolidQueue::ClaimedExecution.pluck(:job_id)
-          relation = relation.where(id: claimed_job_ids)
+          relation = relation.where(id: SolidQueue::ClaimedExecution.select(:job_id))
         end
       end
 

data/app/presenters/solid_queue_monitor/queues_presenter.rb

@@ -2,10 +2,11 @@
 
 module SolidQueueMonitor
   class QueuesPresenter < BasePresenter
-    def initialize(records, paused_queues = [], sort: {})
-      @records = records
+    def initialize(records, paused_queues = [], sort: {}, queue_stats: {})
+      @records       = records
       @paused_queues = paused_queues
-      @sort = sort
+      @sort          = sort
+      @queue_stats   = queue_stats
     end
 
     def render
@@ -39,16 +40,16 @@ module SolidQueueMonitor
 
     def generate_row(queue)
       queue_name = queue.queue_name || 'default'
-      paused = @paused_queues.include?(queue_name)
+      paused     = @paused_queues.include?(queue_name)
 
       <<-HTML
         <tr class="#{paused ? 'queue-paused' : ''}">
           <td>#{queue_link(queue_name)}</td>
           <td>#{status_badge(paused)}</td>
           <td>#{queue.job_count}</td>
-          <td>#{ready_jobs_count(queue_name)}</td>
-          <td>#{scheduled_jobs_count(queue_name)}</td>
-          <td>#{failed_jobs_count(queue_name)}</td>
+          <td>#{@queue_stats.dig(:ready, queue_name) || 0}</td>
+          <td>#{@queue_stats.dig(:scheduled, queue_name) || 0}</td>
+          <td>#{@queue_stats.dig(:failed, queue_name) || 0}</td>
           <td class="actions-cell">#{action_button(queue_name, paused)}</td>
         </tr>
       HTML
@@ -84,19 +85,5 @@ module SolidQueueMonitor
         HTML
       end
     end
-
-    def ready_jobs_count(queue_name)
-      SolidQueue::ReadyExecution.where(queue_name: queue_name).count
-    end
-
-    def scheduled_jobs_count(queue_name)
-      SolidQueue::ScheduledExecution.where(queue_name: queue_name).count
-    end
-
-    def failed_jobs_count(queue_name)
-      SolidQueue::FailedExecution.joins(:job)
-                                 .where(solid_queue_jobs: { queue_name: queue_name })
-                                 .count
-    end
   end
 end

data/app/presenters/solid_queue_monitor/stats_presenter.rb

@@ -11,13 +11,12 @@ module SolidQueueMonitor
         <div class="stats-container">
           <h3>Queue Statistics</h3>
           <div class="stats">
-            #{generate_stat_card('Total Jobs', @stats[:total_jobs])}
+            #{generate_stat_card('Active Jobs', @stats[:active_jobs])}
             #{generate_stat_card('Ready', @stats[:ready])}
             #{generate_stat_card('In Progress', @stats[:in_progress])}
             #{generate_stat_card('Scheduled', @stats[:scheduled])}
             #{generate_stat_card('Recurring', @stats[:recurring])}
             #{generate_stat_card('Failed', @stats[:failed])}
-            #{generate_stat_card('Completed', @stats[:completed])}
           </div>
         </div>
       HTML

data/app/services/solid_queue_monitor/chart_data_service.rb

@@ -5,47 +5,42 @@ module SolidQueueMonitor
     TIME_RANGES = {
       '15m' => { duration: 15.minutes, buckets: 15, label_format: '%H:%M', label: 'Last 15 minutes' },
       '30m' => { duration: 30.minutes, buckets: 15, label_format: '%H:%M', label: 'Last 30 minutes' },
-      '1h' => { duration: 1.hour, buckets: 12, label_format: '%H:%M', label: 'Last 1 hour' },
-      '3h' => { duration: 3.hours, buckets: 18, label_format: '%H:%M', label: 'Last 3 hours' },
-      '6h' => { duration: 6.hours, buckets: 24, label_format: '%H:%M', label: 'Last 6 hours' },
+      '1h' => { duration: 1.hour,     buckets: 12, label_format: '%H:%M', label: 'Last 1 hour' },
+      '3h' => { duration: 3.hours,    buckets: 18, label_format: '%H:%M', label: 'Last 3 hours' },
+      '6h' => { duration: 6.hours,    buckets: 24, label_format: '%H:%M', label: 'Last 6 hours' },
       '12h' => { duration: 12.hours, buckets: 24, label_format: '%H:%M', label: 'Last 12 hours' },
-      '1d' => { duration: 1.day, buckets: 24, label_format: '%H:%M', label: 'Last 24 hours' },
-      '3d' => { duration: 3.days, buckets: 36, label_format: '%m/%d %H:%M', label: 'Last 3 days' },
-      '1w' => { duration: 7.days, buckets: 28, label_format: '%m/%d', label: 'Last 7 days' }
+      '1d' => { duration: 1.day,      buckets: 24, label_format: '%H:%M', label: 'Last 24 hours' },
+      '3d' => { duration: 3.days,     buckets: 36, label_format: '%m/%d %H:%M', label: 'Last 3 days' },
+      '1w' => { duration: 7.days,     buckets: 28, label_format: '%m/%d', label: 'Last 7 days' }
     }.freeze
 
     DEFAULT_TIME_RANGE = '1d'
 
     def initialize(time_range: DEFAULT_TIME_RANGE)
       @time_range = TIME_RANGES.key?(time_range) ? time_range : DEFAULT_TIME_RANGE
-      @config = TIME_RANGES[@time_range]
+      @config     = TIME_RANGES[@time_range]
     end
 
     def calculate
-      end_time = Time.current
-      start_time = end_time - @config[:duration]
-      bucket_duration = @config[:duration] / @config[:buckets]
+      end_time       = Time.current
+      start_time     = end_time - @config[:duration]
+      bucket_seconds = (@config[:duration] / @config[:buckets]).to_i
+      buckets        = build_buckets(start_time, bucket_seconds)
 
-      buckets = build_buckets(start_time, bucket_duration)
+      created_data   = bucket_counts(SolidQueue::Job, :created_at,  start_time, end_time, bucket_seconds)
+      completed_data = bucket_counts(SolidQueue::Job, :finished_at, start_time, end_time, bucket_seconds, exclude_nil: true)
+      failed_data    = bucket_counts(SolidQueue::FailedExecution, :created_at, start_time, end_time, bucket_seconds)
 
-      created_counts = fetch_created_counts(start_time, end_time)
-      completed_counts = fetch_completed_counts(start_time, end_time)
-      failed_counts = fetch_failed_counts(start_time, end_time)
-
-      created_data = assign_to_buckets(created_counts, buckets, bucket_duration)
-      completed_data = assign_to_buckets(completed_counts, buckets, bucket_duration)
-      failed_data = assign_to_buckets(failed_counts, buckets, bucket_duration)
+      created_arr   = fill_buckets(buckets, created_data)
+      completed_arr = fill_buckets(buckets, completed_data)
+      failed_arr    = fill_buckets(buckets, failed_data)
 
       {
         labels: buckets.map { |b| b[:label] }, # rubocop:disable Rails/Pluck
-        created: created_data,
-        completed: completed_data,
-        failed: failed_data,
-        totals: {
-          created: created_data.sum,
-          completed: completed_data.sum,
-          failed: failed_data.sum
-        },
+        created: created_arr,
+        completed: completed_arr,
+        failed: failed_arr,
+        totals: { created: created_arr.sum, completed: completed_arr.sum, failed: failed_arr.sum },
         time_range: @time_range,
         time_range_label: @config[:label],
         available_ranges: TIME_RANGES.transform_values { |v| v[:label] }
@@ -54,47 +49,48 @@ module SolidQueueMonitor
 
     private
 
-    def build_buckets(start_time, bucket_duration)
+    def build_buckets(start_time, bucket_seconds)
       @config[:buckets].times.map do |i|
-        bucket_start = start_time + (i * bucket_duration)
-        {
-          start: bucket_start,
-          end: bucket_start + bucket_duration,
-          label: bucket_start.strftime(@config[:label_format])
-        }
+        bucket_start = start_time + (i * bucket_seconds)
+        { index: i, start: bucket_start, label: bucket_start.strftime(@config[:label_format]) }
       end
     end
 
-    def fetch_created_counts(start_time, end_time)
-      SolidQueue::Job
-        .where(created_at: start_time..end_time)
-        .pluck(:created_at)
-    end
-
-    def fetch_completed_counts(start_time, end_time)
-      SolidQueue::Job
-        .where(finished_at: start_time..end_time)
-        .where.not(finished_at: nil)
-        .pluck(:finished_at)
+    # Returns a Hash of { bucket_index => count } using SQL GROUP BY.
+    # The bucket index is computed as: (epoch(column) - epoch(start_time)) / interval
+    # This works identically on PostgreSQL and SQLite.
+    def bucket_counts(model, column, start_time, end_time, interval, exclude_nil: false)
+      start_epoch = start_time.to_i
+      expr = bucket_index_expr(column, start_epoch, interval)
+
+      scope = model.where(column => start_time..end_time)
+      scope = scope.where.not(column => nil) if exclude_nil
+
+      # rubocop:disable Style/HashTransformKeys -- pluck returns Array<Array>, not Hash
+      scope
+        .group(Arel.sql(expr))
+        .pluck(Arel.sql("#{expr} AS bucket_idx, COUNT(*) AS cnt"))
+        .to_h { |idx, cnt| [idx.to_i, cnt] }
+      # rubocop:enable Style/HashTransformKeys
     end
 
-    def fetch_failed_counts(start_time, end_time)
-      SolidQueue::FailedExecution
-        .where(created_at: start_time..end_time)
-        .pluck(:created_at)
+    def fill_buckets(buckets, index_counts)
+      buckets.map { |b| index_counts.fetch(b[:index], 0) }
     end
 
-    def assign_to_buckets(timestamps, buckets, _bucket_duration)
-      counts = Array.new(buckets.size, 0)
-
-      timestamps.each do |timestamp|
-        bucket_index = buckets.find_index do |bucket|
-          timestamp >= bucket[:start] && timestamp < bucket[:end]
-        end
-        counts[bucket_index] += 1 if bucket_index
+    # Cross-DB bucket index expression.
+    # PostgreSQL: CAST((EXTRACT(EPOCH FROM col) - start) / interval AS INTEGER)
+    # SQLite:     CAST((CAST(strftime('%s', col) AS INTEGER) - start) / interval AS INTEGER)
+    def bucket_index_expr(column, start_epoch, interval_seconds)
+      if sqlite?
+        "CAST((CAST(strftime('%s', #{column}) AS INTEGER) - #{start_epoch}) / #{interval_seconds} AS INTEGER)"
+      else
+        "CAST((EXTRACT(EPOCH FROM #{column}) - #{start_epoch}) / #{interval_seconds} AS INTEGER)"
       end
+    end
 
-      counts
+    def sqlite?
+      ActiveRecord::Base.connection.adapter_name.downcase.include?('sqlite')
     end
   end
 end

data/app/services/solid_queue_monitor/stats_calculator.rb

@@ -3,15 +3,19 @@
 module SolidQueueMonitor
   class StatsCalculator
     def self.calculate
+      scheduled   = SolidQueue::ScheduledExecution.count
+      ready       = SolidQueue::ReadyExecution.count
+      failed      = SolidQueue::FailedExecution.count
+      in_progress = SolidQueue::ClaimedExecution.count
+      recurring   = SolidQueue::RecurringTask.count
+
       {
-        total_jobs: SolidQueue::Job.count,
-        unique_queues: SolidQueue::Job.distinct.count(:queue_name),
-        scheduled: SolidQueue::ScheduledExecution.count,
-        ready: SolidQueue::ReadyExecution.count,
-        failed: SolidQueue::FailedExecution.count,
-        in_progress: SolidQueue::ClaimedExecution.count,
-        completed: SolidQueue::Job.where.not(finished_at: nil).count,
-        recurring: SolidQueue::RecurringTask.count
+        active_jobs: ready + scheduled + in_progress + failed,
+        scheduled: scheduled,
+        ready: ready,
+        failed: failed,
+        in_progress: in_progress,
+        recurring: recurring
       }
     end
   end

data/lib/generators/solid_queue_monitor/templates/initializer.rb

@@ -20,4 +20,7 @@ SolidQueueMonitor.setup do |config|
 
   # Auto-refresh interval in seconds (default: 30)
   # config.auto_refresh_interval = 30
+
+  # Disable the chart on the overview page to skip chart queries entirely.
+  # config.show_chart = true
 end

data/lib/solid_queue_monitor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SolidQueueMonitor
-  VERSION = '1.1.0'
+  VERSION = '1.2.0'
 end

data/lib/solid_queue_monitor.rb

@@ -7,7 +7,7 @@ module SolidQueueMonitor
   class Error < StandardError; end
   class << self
     attr_accessor :username, :password, :jobs_per_page, :authentication_enabled,
-                  :auto_refresh_enabled, :auto_refresh_interval
+                  :auto_refresh_enabled, :auto_refresh_interval, :show_chart
   end
 
   @username = 'admin'
@@ -16,6 +16,7 @@ module SolidQueueMonitor
   @authentication_enabled = false
   @auto_refresh_enabled = true
   @auto_refresh_interval = 30 # seconds
+  @show_chart = true
 
   def self.setup
     yield self

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solid_queue_monitor
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Vishal Sadriya