fix(monitor): DB-accurate max_age metrics

.rubocop.yml

@@ -22,6 +22,10 @@ Rails/EnvironmentVariableAccess:
 RSpec/IndexedLet:
   Enabled: false
 
+Layout/LineLength:
+  Exclude:
+    - 'spec/**/*'
+
 Rails/SquishedSQLHeredocs:
   Exclude:
     - 'spec/**/*'

lib/delayed/monitor.rb

@@ -35,6 +35,33 @@ def query_for(metric)
       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
@@ -75,7 +102,15 @@ def grouped_count(scope)
 
     def grouped_min(scope, column)
       Delayed::Job.from(scope.select("priority, queue, MIN(#{column}) AS #{column}"))
-        .group(priority_case_statement, :queue).minimum(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
@@ -107,16 +142,16 @@ def failed_count_grouped
     end
 
     def max_lock_age_grouped
-      oldest_locked_job_grouped.transform_values { |locked_at| Job.db_time_now - locked_at }
+      oldest_locked_at_query.transform_values { |j| db_now(j) - j.locked_at }
     end
 
     def max_age_grouped
-      oldest_workable_job_grouped.transform_values { |run_at| Job.db_time_now - run_at }
+      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 |((priority, queue), run_at), metrics|
-        max_age = Job.db_time_now - run_at
+      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
@@ -129,11 +164,23 @@ def workable_count_grouped
     alias working_count_grouped locked_count_grouped
 
     def oldest_locked_job_grouped
-      grouped_min(jobs.claimed, :locked_at)
+      oldest_locked_at_query.transform_values(&:locked_at)
     end
 
     def oldest_workable_job_grouped
-      @memo[:oldest_workable_job_grouped] ||= grouped_min(jobs.claimable, :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

spec/delayed/__snapshots__/monitor_spec.rb.snap

@@ -318,10 +318,10 @@ GroupAggregate  (cost=...)
 SNAP
 
 snapshots["runs the expected postgresql query for max_lock_age 1"] = <<-SNAP
-SELECT MIN(locked_at) AS minimum_locked_at, CASE WHEN priority >= 0
+SELECT (CASE WHEN priority >= 0
     AND priority < 10 THEN 0 WHEN priority >= 10
     AND priority < 20 THEN 10 WHEN priority >= 20
-    AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"queue\" AS queue
+    AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END) AS priority, queue, MIN(locked_at) AS locked_at, TIMEZONE('UTC', NOW()) AS db_now_utc
   FROM (SELECT priority, queue, MIN(locked_at) AS locked_at
   FROM \"delayed_jobs\"
   WHERE \"delayed_jobs\".\"locked_at\" >= '2025-11-10 16:59:43'
@@ -336,7 +336,7 @@ SNAP
 
 snapshots["produces the expected postgresql query plan for max_lock_age 1"] = <<-SNAP
 GroupAggregate  (cost=...)
-  Output: min(subquery.locked_at), (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
+  Output: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue, min(subquery.locked_at), timezone('UTC'::text, now())
   Group Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
   ->  Sort  (cost=...)
         Output: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue, subquery.locked_at
@@ -357,7 +357,7 @@ SNAP
 
 snapshots["[legacy index] produces the expected postgresql query plan for max_lock_age 1"] = <<-SNAP
 GroupAggregate  (cost=...)
-  Output: min(subquery.locked_at), (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
+  Output: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue, min(subquery.locked_at), timezone('UTC'::text, now())
   Group Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
   ->  Sort  (cost=...)
         Output: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue, subquery.locked_at
@@ -377,10 +377,10 @@ GroupAggregate  (cost=...)
 SNAP
 
 snapshots["runs the expected postgresql query for max_age 1"] = <<-SNAP
-SELECT MIN(run_at) AS minimum_run_at, CASE WHEN priority >= 0
+SELECT (CASE WHEN priority >= 0
     AND priority < 10 THEN 0 WHEN priority >= 10
     AND priority < 20 THEN 10 WHEN priority >= 20
-    AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"queue\" AS queue
+    AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END) AS priority, queue, MIN(run_at) AS run_at, TIMEZONE('UTC', NOW()) AS db_now_utc
   FROM (SELECT priority, queue, MIN(run_at) AS run_at
   FROM \"delayed_jobs\"
   WHERE (\"delayed_jobs\".\"locked_at\" IS NULL
@@ -396,7 +396,7 @@ SNAP
 
 snapshots["produces the expected postgresql query plan for max_age 1"] = <<-SNAP
 GroupAggregate  (cost=...)
-  Output: min(subquery.run_at), (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
+  Output: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue, min(subquery.run_at), timezone('UTC'::text, now())
   Group Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
   ->  Sort  (cost=...)
         Output: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue, subquery.run_at
@@ -417,7 +417,7 @@ SNAP
 
 snapshots["[legacy index] produces the expected postgresql query plan for max_age 1"] = <<-SNAP
 GroupAggregate  (cost=...)
-  Output: min(subquery.run_at), (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
+  Output: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue, min(subquery.run_at), timezone('UTC'::text, now())
   Group Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
   ->  Sort  (cost=...)
         Output: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue, subquery.run_at
@@ -556,10 +556,10 @@ GroupAggregate  (cost=...)
 SNAP
 
 snapshots["runs the expected postgresql query for alert_age_percent 1"] = <<-SNAP
-SELECT MIN(run_at) AS minimum_run_at, CASE WHEN priority >= 0
+SELECT (CASE WHEN priority >= 0
     AND priority < 10 THEN 0 WHEN priority >= 10
     AND priority < 20 THEN 10 WHEN priority >= 20
-    AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"queue\" AS queue
+    AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END) AS priority, queue, MIN(run_at) AS run_at, TIMEZONE('UTC', NOW()) AS db_now_utc
   FROM (SELECT priority, queue, MIN(run_at) AS run_at
   FROM \"delayed_jobs\"
   WHERE (\"delayed_jobs\".\"locked_at\" IS NULL
@@ -575,7 +575,7 @@ SNAP
 
 snapshots["produces the expected postgresql query plan for alert_age_percent 1"] = <<-SNAP
 GroupAggregate  (cost=...)
-  Output: min(subquery.run_at), (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
+  Output: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue, min(subquery.run_at), timezone('UTC'::text, now())
   Group Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
   ->  Sort  (cost=...)
         Output: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue, subquery.run_at
@@ -596,7 +596,7 @@ SNAP
 
 snapshots["[legacy index] produces the expected postgresql query plan for alert_age_percent 1"] = <<-SNAP
 GroupAggregate  (cost=...)
-  Output: min(subquery.run_at), (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
+  Output: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue, min(subquery.run_at), timezone('UTC'::text, now())
   Group Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
   ->  Sort  (cost=...)
         Output: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue, subquery.run_at
@@ -795,10 +795,10 @@ USE TEMP B-TREE FOR GROUP BY
 SNAP
 
 snapshots["runs the expected sqlite3 query for max_lock_age 1"] = <<-SNAP
-SELECT MIN(locked_at) AS minimum_locked_at, CASE WHEN priority >= 0
+SELECT (CASE WHEN priority >= 0
     AND priority < 10 THEN 0 WHEN priority >= 10
     AND priority < 20 THEN 10 WHEN priority >= 20
-    AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"queue\" AS queue
+    AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END) AS priority, queue, MIN(locked_at) AS locked_at, CURRENT_TIMESTAMP AS db_now_utc
   FROM (SELECT priority, queue, MIN(locked_at) AS locked_at
   FROM \"delayed_jobs\"
   WHERE \"delayed_jobs\".\"locked_at\" >= '2025-11-10 16:59:43'
@@ -828,10 +828,10 @@ USE TEMP B-TREE FOR GROUP BY
 SNAP
 
 snapshots["runs the expected sqlite3 query for max_age 1"] = <<-SNAP
-SELECT MIN(run_at) AS minimum_run_at, CASE WHEN priority >= 0
+SELECT (CASE WHEN priority >= 0
     AND priority < 10 THEN 0 WHEN priority >= 10
     AND priority < 20 THEN 10 WHEN priority >= 20
-    AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"queue\" AS queue
+    AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END) AS priority, queue, MIN(run_at) AS run_at, CURRENT_TIMESTAMP AS db_now_utc
   FROM (SELECT priority, queue, MIN(run_at) AS run_at
   FROM \"delayed_jobs\"
   WHERE (\"delayed_jobs\".\"locked_at\" IS NULL
@@ -929,10 +929,10 @@ USE TEMP B-TREE FOR GROUP BY
 SNAP
 
 snapshots["runs the expected sqlite3 query for alert_age_percent 1"] = <<-SNAP
-SELECT MIN(run_at) AS minimum_run_at, CASE WHEN priority >= 0
+SELECT (CASE WHEN priority >= 0
     AND priority < 10 THEN 0 WHEN priority >= 10
     AND priority < 20 THEN 10 WHEN priority >= 20
-    AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"queue\" AS queue
+    AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END) AS priority, queue, MIN(run_at) AS run_at, CURRENT_TIMESTAMP AS db_now_utc
   FROM (SELECT priority, queue, MIN(run_at) AS run_at
   FROM \"delayed_jobs\"
   WHERE (\"delayed_jobs\".\"locked_at\" IS NULL
@@ -1149,10 +1149,10 @@ snapshots["[legacy index] produces the expected mysql2 query plan for failed_cou
 SNAP
 
 snapshots["runs the expected mysql2 query for max_lock_age 1"] = <<-SNAP
-SELECT MIN(locked_at) AS minimum_locked_at, CASE WHEN priority >= 0
+SELECT (CASE WHEN priority >= 0
     AND priority < 10 THEN 0 WHEN priority >= 10
     AND priority < 20 THEN 10 WHEN priority >= 20
-    AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, `queue` AS queue
+    AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END) AS priority, queue, MIN(locked_at) AS locked_at, UTC_TIMESTAMP() AS db_now_utc
   FROM (SELECT priority, queue, MIN(locked_at) AS locked_at
   FROM `delayed_jobs`
   WHERE `delayed_jobs`.`locked_at` >= '2025-11-10 16:59:43'
@@ -1188,10 +1188,10 @@ snapshots["[legacy index] produces the expected mysql2 query plan for max_lock_a
 SNAP
 
 snapshots["runs the expected mysql2 query for max_age 1"] = <<-SNAP
-SELECT MIN(run_at) AS minimum_run_at, CASE WHEN priority >= 0
+SELECT (CASE WHEN priority >= 0
     AND priority < 10 THEN 0 WHEN priority >= 10
     AND priority < 20 THEN 10 WHEN priority >= 20
-    AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, `queue` AS queue
+    AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END) AS priority, queue, MIN(run_at) AS run_at, UTC_TIMESTAMP() AS db_now_utc
   FROM (SELECT priority, queue, MIN(run_at) AS run_at
   FROM `delayed_jobs`
   WHERE (`delayed_jobs`.`locked_at` IS NULL
@@ -1307,10 +1307,10 @@ snapshots["[legacy index] produces the expected mysql2 query plan for workable_c
 SNAP
 
 snapshots["runs the expected mysql2 query for alert_age_percent 1"] = <<-SNAP
-SELECT MIN(run_at) AS minimum_run_at, CASE WHEN priority >= 0
+SELECT (CASE WHEN priority >= 0
     AND priority < 10 THEN 0 WHEN priority >= 10
     AND priority < 20 THEN 10 WHEN priority >= 20
-    AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, `queue` AS queue
+    AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END) AS priority, queue, MIN(run_at) AS run_at, UTC_TIMESTAMP() AS db_now_utc
   FROM (SELECT priority, queue, MIN(run_at) AS run_at
   FROM `delayed_jobs`
   WHERE (`delayed_jobs`.`locked_at` IS NULL

spec/delayed/job_spec.rb

@@ -1006,12 +1006,6 @@ def create_job(opts = {})
     end
   end
 
-  if ActiveRecord::VERSION::MAJOR >= 7
-    delegate :default_timezone=, to: ActiveRecord
-  else
-    delegate :default_timezone=, to: ActiveRecord::Base
-  end
-
   context "db_time_now" do
     after do
       Time.zone = nil