delayed 2.0.2 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 16d1a1a8e3f41bee282a4d725afdf3be6419fceba8c5cef58a3eb35a7a406823
-  data.tar.gz: 9ad241b6880c13997ea7b58ba2bcfba02a1beb6692b050698fac30301cc9c90c
+  metadata.gz: 984a910472fc4f1dedafcf4060cf076bcda408196bfa80f08039ed2527533a41
+  data.tar.gz: 98f7de42e2964ee1576ba6ae3fc2b39cbe76a841263054a5b9634f7e55ce1114
 SHA512:
-  metadata.gz: a63a4f0a56f26c9b5bb3a987b6c2877068016823b21efb059744effc0eeb68255b4b193e7f0e0292f6d790e12138ad8c57bab032a7f1f3c1a89e2c533db45df6
-  data.tar.gz: 7912ee6d5d633293a2f1707d890c2fd5a60cbdb1c44ec215a8d2414db35902a272e4caad4ece1947c6475f4e90a7b5c1fe54ef320549681c04c948d7786cd4a8
+  metadata.gz: dcb018c429ff591409796e410c570f49408eb0b8363759f6c8970ac4ee1773abccc117b5398c3596ecf8491c0e70db548bd4a2ea54ef39a77fa78da43b6cbfe4
+  data.tar.gz: 020a785c7bfc81456b8cc7b8ddace55fad1f9468edb3b9cef0ef066eb6aed64b580d30974b48ce97bc7b1602294c9901c7c26fa294d3e4b4ecebd177aef677c8

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
@@ -35,6 +35,33 @@ module Delayed
       send(:"#{metric}_grouped")
     end
 
+    def self.sql_now_in_utc
+      case ActiveRecord::Base.connection.adapter_name
+      when 'PostgreSQL'
+        "TIMEZONE('UTC', NOW())"
+      when 'MySQL', 'Mysql2'
+        "UTC_TIMESTAMP()"
+      else
+        "CURRENT_TIMESTAMP"
+      end
+    end
+
+    def self.parse_utc_time(string)
+      # Depending on Rails version & DB adapter, this will be either a String or a DateTime.
+      # If it's a DateTime, and if connection is running with the `:local` time zone config,
+      # then by default Rails incorrectly assumes it's in local time instead of UTC.
+      # We use `strftime` to strip the encoded TZ info and re-parse it as UTC.
+      #
+      # Example:
+      # - "2026-02-05 10:01:23"        -> DB-returned string
+      # - "2026-02-05 10:01:23 -0600"  -> Rails-parsed DateTime with incorrect TZ
+      # - "2026-02-05 10:01:23"        -> `strftime` output
+      # - "2026-02-05 04:01:23 -0600"  -> Re-parsed as UTC and converted to local time
+      string = string.strftime('%Y-%m-%d %H:%M:%S') if string.respond_to?(:strftime)
+
+      ActiveSupport::TimeZone.new("UTC").parse(string)
+    end
+
     private
 
     attr_reader :jobs
@@ -68,63 +95,92 @@ 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)
+        .select(<<~SQL.squish)
+          (#{priority_case_statement}) AS priority,
+          queue,
+          MIN(#{column}) AS #{column},
+          #{self.class.sql_now_in_utc} AS db_now_utc
+        SQL
+        .group_by { |j| [j.priority.to_i, j.queue] }
+        .transform_values(&:first)
+    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_at_query.transform_values { |j| db_now(j) - j.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_run_at_query.transform_values { |j| db_now(j) - j.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_run_at_query.each_with_object({}) do |((priority, queue), j), metrics|
+        max_age = db_now(j) - j.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")
+      oldest_locked_at_query.transform_values(&: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")
+      oldest_run_at_query.transform_values(&:run_at)
+    end
+
+    def oldest_locked_at_query
+      @memo[:oldest_locked_at_query] ||= grouped_min(jobs.claimed, :locked_at)
+    end
+
+    def oldest_run_at_query
+      @memo[:oldest_run_at_query] ||= grouped_min(jobs.claimable, :run_at)
+    end
+
+    def db_now(record)
+      self.class.parse_utc_time(record.db_now_utc)
     end
 
     def priority_case_statement

data/lib/delayed/tasks.rb

@@ -10,17 +10,37 @@ namespace :delayed do
 
     next unless defined?(Rails.application.config)
 
-    # By default, Rails < 6.1 overrides eager_load to 'false' inside of rake tasks, which is not ideal in production environments.
-    # Additionally, the classic Rails autoloader is not threadsafe, so we do not want any autoloading after we start the worker.
-    # While the zeitwork autoloader technically does not need this workaround, we will still eager load for consistency's sake.
-    # We will use the cache_classes config as a proxy for determining if we should eager load before booting workers.
-    if !Rails.application.config.respond_to?(:rake_eager_load) && Rails.application.config.cache_classes
-      Rails.application.config.eager_load = true
-      Rails::Application::Finisher.initializers
-        .find { |i| i.name == :eager_load! }
-        .bind(Rails.application)
-        .run
-    end
+    # By default, Rails wants to disable eager loading inside of `rake`
+    # commands, even if `eager_load` is set to true. This is done to speed up
+    # the boot time of rake tasks that don't need the entire application loaded.
+    #
+    # The problem is that long-lived processes like `delayed` **do** want to
+    # eager load the application before spawning any threads or forks.
+    # (Especially if in a production environment where we want full load-order
+    # parity with the `rails server` processes!)
+    #
+    # When a Rails app boots, it chooses whether to eager load based on its
+    # `eager_load` config and whether or not it was initiated by a `rake`
+    # command. If it did eager load, we don't want to eager load again, but if
+    # it was initiated by a `rake` command, it sets `eager_load` to false before
+    # the point at which `delayed` starts setting up _its_ rake environment.
+    #
+    # So we cannot rely on that config to know whether or not to eager load --
+    # instead we must make an inference:
+    # - Newer rails versions (~7.0+) have a `config.rake_eager_load` option,
+    # which tells us whether the app has already eager loaded in a `rake`
+    # context.
+    # - If `rake_eager_loading` is not defined or `false`, we will then check
+    # `cache_classes` & explicitly eager load if true.
+
+    eager_loaded = Rails.application.config.respond_to?(:rake_eager_load) && Rails.application.config.rake_eager_load
+    next if eager_loaded || !Rails.application.config.cache_classes
+
+    Rails.application.config.eager_load = true
+    Rails::Application::Finisher.initializers
+      .find { |i| i.name == :eager_load! }
+      .bind(Rails.application)
+      .run
   end
 
   desc 'start a delayed worker'

data/lib/delayed/version.rb

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