delayed 2.0.1 → 2.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b69cac642b56964d70aba6e210125180c11fcd690ffe666a6501db5f5cc52779
-  data.tar.gz: 6a2aca999b32ec0d2fb28fde33bb57725085c090eb6f2bcee29e50baa8f66a6f
+  metadata.gz: 4227961278ab7f1ed435e8357cbf83998ee6d1d597f981fc4d1ab92a0d1069fa
+  data.tar.gz: fd108cb072de3ec495d2713326821b231cfe8ffa153782a80f84da06d272ecfa
 SHA512:
-  metadata.gz: d74267db864b39c8861136fc374a392608f08b47400cc872adfc5c19cc4188be202a4f6e68354f370987f56c9f5f7f9221432358c0a4663021b1718e18703127
-  data.tar.gz: ac7f99b72554e9ec1ad69ecace6f637bd9aec6d6f4a74034030962ffc0542b3761542622775f52225e762ab248ef9e57a691b07852a16673574998fdb0099585
+  metadata.gz: 36fd83967d57e3ae7d58a2edfceb790d35bcf3f9a49a9bf3de9e34c15528ba2c3ae36468c7847e8e49d7d90ca8b03ef1e39a62620257fb06cb8f321a5af0909e
+  data.tar.gz: df0443f6ca1f859e5b4155a0b38aa72310e0607f57c30ba31dcd0fda39825e0ae81903d0b019886c7405e607d1817f3733c47fbfed81b25cb897440cb2be8da8

data/lib/delayed/helpers/migration.rb

@@ -20,13 +20,17 @@ module Delayed
       end
 
       def upsert_index(*args, **opts)
-        dir(:up) { _add_or_replace_index(*args, **opts) }
-        dir(:down) { _drop_index_if_exists(*args, **opts) }
+        with_retry_loop(**opts) do
+          dir(:up) { _add_or_replace_index(*args, **opts) }
+          dir(:down) { _drop_index_if_exists(*args, **opts) }
+        end
       end
 
       def remove_index_if_exists(*args, **opts)
-        dir(:up) { _drop_index_if_exists(*args, **opts) }
-        dir(:down) { _add_or_replace_index(*args, **opts) }
+        with_retry_loop(**opts) do
+          dir(:up) { _drop_index_if_exists(*args, **opts) }
+          dir(:down) { _add_or_replace_index(*args, **opts) }
+        end
       end
 
       RETRY_EXCEPTIONS = [
@@ -48,7 +52,7 @@ module Delayed
         end
       end
 
-      def with_timeouts(statement_timeout: 1.minute, lock_timeout: 5.seconds)
+      def with_timeouts(statement_timeout: 1.minute, lock_timeout: 5.seconds, **_opts)
         dir(:both) { set_timeouts!(statement_timeout: statement_timeout, lock_timeout: lock_timeout) }
         yield
       ensure
@@ -61,24 +65,15 @@ module Delayed
         index = _lookup_index(table, columns, **opts)
         if index && !_index_matches?(index, **opts)
           Delayed.logger.warn("Recreating index #{index.name} (is invalid or does not match desired options)")
-          _drop_index(table, name: index.name, **opts)
+          remove_index(table, name: index.name)
         end
-        _add_index(table, columns, **opts) if !index || !_index_matches?(index, **opts)
+        opts = opts.except(:wait_timeout, :statement_timeout, :lock_timeout)
+        add_index(table, columns, **opts) if !index || !_index_matches?(index, **opts)
       end
 
       def _drop_index_if_exists(table, columns, **opts)
         index = _lookup_index(table, columns, **opts)
-        _drop_index(table, name: index.name, **opts) if index
-      end
-
-      def _add_index(*args, **opts)
-        index_opts = opts.slice!(:wait_timeout, :statement_timeout, :lock_timeout)
-        with_retry_loop(**opts) { add_index(*args, **index_opts) }
-      end
-
-      def _drop_index(table, name:, **opts)
-        opts.slice!(:wait_timeout, :statement_timeout, :lock_timeout)
-        with_retry_loop(**opts) { remove_index(table, name: name) }
+        remove_index(table, name: index.name) if index
       end
 
       def _lookup_index(table, columns, **opts)

data/lib/delayed/monitor.rb

@@ -18,7 +18,7 @@ module Delayed
     cattr_accessor :sleep_delay, instance_writer: false, default: 60
 
     def initialize
-      @jobs = Job.group(priority_case_statement).group(:queue)
+      @jobs = Job.group(:priority, :queue)
       @jobs = @jobs.where(queue: Worker.queues) if Worker.queues.any?
       @memo = {}
     end
@@ -68,63 +68,72 @@ module Delayed
       }
     end
 
+    def grouped_count(scope)
+      Delayed::Job.from(scope.select('priority, queue, COUNT(*) AS count'))
+        .group(priority_case_statement, :queue).sum(:count)
+    end
+
+    def grouped_min(scope, column)
+      Delayed::Job.from(scope.select("priority, queue, MIN(#{column}) AS #{column}"))
+        .group(priority_case_statement, :queue).minimum(column)
+    end
+
     def count_grouped
       if Job.connection.supports_partial_index?
-        failed_count_grouped.merge(jobs.live.count) { |_, l, f| l + f }
+        failed_count_grouped.merge(live_count_grouped) { |_, l, f| l + f }
       else
-        jobs.count
+        grouped_count(jobs)
       end
     end
 
+    def live_count_grouped
+      grouped_count(jobs.live)
+    end
+
     def future_count_grouped
-      jobs.future.count
+      grouped_count(jobs.future)
     end
 
     def locked_count_grouped
-      @memo[:locked_count_grouped] ||= jobs.claimed.count
+      @memo[:locked_count_grouped] ||= grouped_count(jobs.claimed)
     end
 
     def erroring_count_grouped
-      jobs.erroring.count
+      grouped_count(jobs.erroring)
     end
 
     def failed_count_grouped
-      @memo[:failed_count_grouped] ||= jobs.failed.count
+      @memo[:failed_count_grouped] ||= grouped_count(jobs.failed)
     end
 
     def max_lock_age_grouped
-      oldest_locked_job_grouped.each_with_object({}) do |job, metrics|
-        metrics[[job.priority.to_i, job.queue]] = Job.db_time_now - job.locked_at
-      end
+      oldest_locked_job_grouped.transform_values { |locked_at| Job.db_time_now - locked_at }
     end
 
     def max_age_grouped
-      oldest_workable_job_grouped.each_with_object({}) do |job, metrics|
-        metrics[[job.priority.to_i, job.queue]] = Job.db_time_now - job.run_at
-      end
+      oldest_workable_job_grouped.transform_values { |run_at| Job.db_time_now - run_at }
     end
 
     def alert_age_percent_grouped
-      oldest_workable_job_grouped.each_with_object({}) do |job, metrics|
-        max_age = Job.db_time_now - job.run_at
-        metrics[[job.priority.to_i, job.queue]] = [max_age / job.priority.alert_age * 100, 100].min if job.priority.alert_age
+      oldest_workable_job_grouped.each_with_object({}) do |((priority, queue), run_at), metrics|
+        max_age = Job.db_time_now - run_at
+        alert_age = Priority.new(priority).alert_age
+        metrics[[priority, queue]] = [max_age / alert_age * 100, 100].min if alert_age
       end
     end
 
     def workable_count_grouped
-      jobs.claimable.count
+      grouped_count(jobs.claimable)
     end
 
     alias working_count_grouped locked_count_grouped
 
     def oldest_locked_job_grouped
-      jobs.claimed
-        .select("#{priority_case_statement} AS priority, queue, MIN(locked_at) AS locked_at")
+      grouped_min(jobs.claimed, :locked_at)
     end
 
     def oldest_workable_job_grouped
-      @memo[:oldest_workable_job_grouped] ||= jobs.claimable
-        .select("(#{priority_case_statement}) AS priority, queue, MIN(run_at) AS run_at")
+      @memo[:oldest_workable_job_grouped] ||= grouped_min(jobs.claimable, :run_at)
     end
 
     def priority_case_statement

data/lib/delayed/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Delayed
-  VERSION = '2.0.1'
+  VERSION = '2.0.3'
 end