que-scheduler 3.4.3 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ba02202915db229bcbd1c2e859f29299803507dbf61bd460008400abca3611c
-  data.tar.gz: 6293d7b6e6766d0e75fe65df01850f356b44b030c8b8ae539eb4c71059d9d15d
+  metadata.gz: a75db11d923c140204bd92360916e4cacaac5531fc25470616a4d558dde22dd3
+  data.tar.gz: ba08caa1a8bf8a87532da3fa5cbfc8b720784e88354ab74b240c5d724c46fb07
 SHA512:
-  metadata.gz: d8d18550867d7d54cfb5c03aaa68876d423876a870b972cde0fbc4e8399fb616d327ef0410ebbc8e3d9021a34d73a960774eabb808f2b33a526e11ea2fb579fe
-  data.tar.gz: bfc0e4be1f64d2b070dacb0863cc710ce13cf58cb30924fcf9f301d2e535be4ef9530740949bdb5abb90c0173924e71f7f151e4622405caf8c14a9d7d6f0469d
+  metadata.gz: 19ad5f4284dd03b6129d970e87cdd1652f8e992a5c141c032fc4935beaea2bbf15f35253c5c5f6c93e3cf6b32875beb6138112d43e8e5e123235c32fa9593984
+  data.tar.gz: f8618b848befcccf03387fe2e891f201790c1dc8b736406a62bd3d63990ac1c8f47737966103713d843a627ec39d2ff23128570dd6b03cd28682bc4613638fcf

data/README.md

@@ -28,7 +28,7 @@ resque-scheduler files, but with additional features.
     ```ruby
     class CreateQueSchedulerSchema < ActiveRecord::Migration
       def change
-        Que::Scheduler::Migrations.migrate!(version: 5)
+        Que::Scheduler::Migrations.migrate!(version: 6)
       end
     end
     ```
@@ -36,8 +36,8 @@ resque-scheduler files, but with additional features.
 ## Schedule configuration
 
 The schedule file should be placed here: `config/que_schedule.yml`. Alternatively if you
-wish to generate the configuration dynamically, you can set it directly with
-`Que::Scheduler.schedule = some_hash`.
+wish to generate the configuration dynamically, you can set it directly using an initializer
+(see "Gem configuration" below).
 
 The file is a list of que job classes with arguments and a schedule frequency (in crontab 
 syntax). The format is similar to the resque-scheduler format, though priorities must be supplied as
@@ -135,19 +135,42 @@ A job can have a `schedule_type` assigned to it. Valid values are:
 
 ## Gem configuration
 
-You can configure some aspects of the gem with an initializer. The default is given below.
+You can configure some aspects of the gem with a config block (eg in a Rails initializer). 
+The default is given below. You can omit any configuration sections you are not intending to change.
+It is quite likely you won't have to create this config at all.
 
 ```ruby
 Que::Scheduler.configure do |config|
   # The location of the schedule yaml file.
-  config.schedule_location = ENV.fetch('QUE_SCHEDULER_CONFIG_LOCATION', 'config/que_schedule.yml')
+  config.schedule_location = ENV.fetch("QUE_SCHEDULER_CONFIG_LOCATION", "config/que_schedule.yml")
+
+  # The schedule as a hash. You can use this if you want to build the schedule yourself at runtime.
+  # This will override the above value if provided.
+  config.schedule = {
+    SpecifiedByHashTestJob: {
+      cron: "02 11 * * *"
+    }
+  }
   
-  # Specify a transaction block adapter. By default, que-scheduler uses the one supplied by que.
-  # However, if, for example you rely on listeners to ActiveRecord's exact `transaction` method, or 
+  # The transaction block adapter. By default, que-scheduler uses the one supplied by que.
+  # However if, for example, you rely on listeners to ActiveRecord's exact `transaction` method, or 
   # Sequel's DB.after_commit helper, then you can supply it here.
   config.transaction_adapter = ::Que.method(:transaction)
-end
 
+  # Which queue name the que-scheduler job should self-schedule on. Typically this is the default
+  # queue of que, which has a different name in Que 0.x ("") and 1.x ("default").
+  # It *must* be the "highest throughput" queue - do not work the scheduler on a "long 
+  # running jobs" queue. It is very unlikely you will want to change this. 
+  config.que_scheduler_queue = ENV.fetch("QUE_SCHEDULER_QUEUE", "" or "default")
+  
+  # If que-scheduler is being used with Rails, then it will inherit the time zone from that 
+  # framework, and you can leave the value as nil as shown below. However, if you are not using
+  # Rails, you may need to set the time zone here. If que-scheduler cannot determine the time zone
+  # it will yield an error prompting you for action.
+  # If you need to set a value, use the string representation:
+  # eg: config.time_zone = "Europe/London"
+  config.time_zone = nil
+end
 ```
 
 ## Scheduler Audit
@@ -159,9 +182,29 @@ migration tasks.
 Additionally, there is the audit table `que_scheduler_audit_enqueued`. This logs every job that 
 the scheduler enqueues.
 
+que-scheduler comes with the `QueSchedulerAuditClearDownJob` job built in that you can optionally
+schedule to clear down audit rows if you don't need to retain them indefinitely. You should add this
+to your own scheduler config yaml.
+
+For example:
+
+```yaml
+# This will clear down the oldest que-scheduler audit rows. Since que-scheduler
+# runs approximately every minute, 129600 is 90 days.
+Que::Scheduler::Jobs::QueSchedulerAuditClearDownJob:
+  cron: "0 0 * * *"
+  args:
+    retain_row_count: 129600
+```
+
+## Required migrations
+
 When there is a major version (breaking) change, a migration should be run in. The version of the 
-migration proceeds at a faster rate than the version of the gem. To run in all the migrations required
-up to a number, just migrate to that number with one line, and it will perform all the intermediary steps. 
+latest migration proceeds at a faster rate than the version of the gem. eg If the gem is on version
+3 then the migrations may be on version 6). 
+
+To run in all the migrations required up to a number, just migrate to that number with one line, and
+it will perform all the intermediary steps. 
 
 ie, This will perform all migrations necessary up to the latest version, skipping any already 
 performed.
@@ -169,7 +212,7 @@ performed.
 ```ruby
 class CreateQueSchedulerSchema < ActiveRecord::Migration
   def change
-    Que::Scheduler::Migrations.migrate!(version: 5)
+    Que::Scheduler::Migrations.migrate!(version: 6)
   end
 end
 ```
@@ -183,22 +226,15 @@ The changes in past migrations were:
 |    3    | Added the audit table `que_scheduler_audit_enqueued`.                           |
 |    4    | Updated the the audit tables to use bigints                                     |
 |    5    | Dropped an unnecessary index                                                    |
+|    6    | Enforced single scheduler job at the trigger level                              |
 
-## Built in optional job for audit clear down
-
-que-scheduler comes with the `QueSchedulerAuditClearDownJob` job built in that you can optionally
-schedule to clear down audit rows if you don't need to retain them indefinitely. You should add this
-to your own scheduler config yaml.
+The changes to the DB ([DDL](https://en.wikipedia.org/wiki/Data_definition_language)) are all 
+captured in the structure.sql so will be re-run in correctly if squashed - except for the actual 
+scheduling of the job itself (as that is [DML](https://en.wikipedia.org/wiki/Data_manipulation_language)).
+If you squash your migrations make sure this is added as the final line:
 
-For example:
-
-```yaml
-# This will clear down the oldest que-scheduler audit rows. Since que-scheduler
-# runs approximately every minute, 129600 is 90 days.
-Que::Scheduler::Jobs::QueSchedulerAuditClearDownJob:
-  cron: "0 0 * * *"
-  args:
-    retain_row_count: 129600
+```ruby
+Que::Scheduler::Migrations.reenqueue_scheduler_if_missing
 ```
 
 ## HA Redundancy and DB restores
@@ -214,8 +250,8 @@ in a coherent state with the rest of your database.
 ## Concurrent scheduler detection
 
 No matter how many tasks you have defined in your schedule, you will only ever need one que-scheduler
-job enqueued. que-scheduler knows this, and it will check before performing any operations that 
-there is only one of itself present.
+job enqueued. que-scheduler knows this, and there are DB constraints in place to ensure there is
+only ever exactly one scheduler job.
 
 It also follows que job design [best practices](https://github.com/chanks/que/blob/master/docs/writing_reliable_jobs.md),
 using ACID guarantees, to ensure that it will never run multiple times. If the scheduler crashes for any reason,
@@ -267,9 +303,13 @@ The scheduler will then continue to retry indefinitely.
 que-scheduler uses [semantic versioning](https://semver.org/), so major version changes will usually 
 require additional actions to be taken upgrading from one major version to another. 
 
+## Changelog
+
+A full changelog can be found here: [CHANGELOG.md](https://github.com/hlascelles/que-scheduler/blob/master/CHANGELOG.md)
+
 ## System requirements
 
-Your [postgres](https://www.postgresql.org/) database must be at least version 9.4.0.
+Your [postgres](https://www.postgresql.org/) database must be at least version 9.5.0.
 
 ## Inspiration
 
@@ -277,9 +317,10 @@ This gem was inspired by the makers of the excellent [Que](https://github.com/ch
 
 ## Contributors
 
+* @bnauta
+* @bjeanes
+* @JackDanger
 * @jish
 * @joehorsnell
-* @bnauta
-* @papodaca
 * @krzyzak
-* @JackDanger
+* @papodaca

data/lib/que/scheduler.rb

@@ -1,6 +1,7 @@
 require "que/scheduler/version"
 require "que/scheduler/version_support"
-require "que/scheduler/config"
+require "que/scheduler/configuration"
+require "que/scheduler/time_zone"
 require "que/scheduler/scheduler_job"
 require "que/scheduler/db"
 require "que/scheduler/audit"

data/lib/que/scheduler/configuration.rb

@@ -0,0 +1,34 @@
+require "que"
+require_relative "version_support"
+
+module Que
+  module Scheduler
+    class Configuration
+      attr_accessor :schedule_location, :schedule, :transaction_adapter, :que_scheduler_queue,
+                    :time_zone
+    end
+
+    class << self
+      attr_accessor :configuration
+
+      def configure
+        self.configuration ||= Configuration.new
+        yield(configuration)
+      end
+
+      def apply_defaults
+        configure do |config|
+          config.schedule_location =
+            ENV.fetch("QUE_SCHEDULER_CONFIG_LOCATION", "config/que_schedule.yml")
+          config.transaction_adapter = ::Que.method(:transaction)
+          config.que_scheduler_queue =
+            ENV.fetch("QUE_SCHEDULER_QUEUE", Que::Scheduler::VersionSupport.default_scheduler_queue)
+          config.schedule = nil
+          config.time_zone = nil
+        end
+      end
+    end
+  end
+end
+
+Que::Scheduler.apply_defaults

data/lib/que/scheduler/db.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "config"
+require_relative "configuration"
 
 module Que
   module Scheduler
@@ -18,9 +18,11 @@ module Que
           Que::Scheduler::VersionSupport.execute(NOW_SQL).first.values.first
         end
 
+        # rubocop:disable Style/ExplicitBlockArgument
         def transaction
           Que::Scheduler.configuration.transaction_adapter.call { yield }
         end
+        # rubocop:enable Style/ExplicitBlockArgument
       end
     end
   end

data/lib/que/scheduler/defined_job.rb

@@ -86,10 +86,10 @@ module Que
         # queue name is only supported for a subrange of ActiveJob versions. Print this out as a
         # warning.
         if queue &&
-           Que::Scheduler::ToEnqueue.active_job_sufficient_version? &&
+           Que::Scheduler::ToEnqueue.active_job_loaded? &&
            job_class < ::ActiveJob::Base &&
            Que::Scheduler::ToEnqueue.active_job_version < Gem::Version.create("6.0.3")
-          puts <<-ERR
+          puts <<~ERR
             WARNING from que-scheduler....
             Between versions 4.2.3 and 6.0.2 (inclusive) Rails did not support setting queue names
             on que jobs with ActiveJob, so que-scheduler cannot support it.

data/lib/que/scheduler/jobs/que_scheduler_audit_clear_down_job.rb

@@ -8,7 +8,7 @@ module Que
       class QueSchedulerAuditClearDownJob < Que::Job
         class << self
           def build_sql(table_name)
-            <<-SQL
+            <<~SQL
               WITH deleted AS (
                 DELETE FROM #{table_name}
                 WHERE scheduler_job_id <= (
@@ -28,7 +28,7 @@ module Que
         Que::Scheduler::VersionSupport.set_priority(self, 100)
 
         def run(options)
-          retain_row_count = options.fetch(:retain_row_count)
+          retain_row_count = options.symbolize_keys.fetch(:retain_row_count)
           Que::Scheduler::Db.transaction do
             # This may delete zero or more than `retain_row_count` depending on if anything was
             # scheduled in each of the past schedule runs

data/lib/que/scheduler/migrations.rb

@@ -41,6 +41,11 @@ module Que
           result.any?
         end
 
+        # This method is only intended for use in squashed migrations
+        def reenqueue_scheduler_if_missing
+          Que::Scheduler::SchedulerJob.enqueue if Que::Scheduler::Db.count_schedulers.zero?
+        end
+
         private
 
         def migrate_up(current, version)

data/lib/que/scheduler/migrations/6/down.sql

@@ -0,0 +1,7 @@
+DROP TRIGGER que_scheduler_prevent_job_deletion_trigger ON que_jobs;
+
+DROP FUNCTION que_scheduler_prevent_job_deletion();
+
+DROP FUNCTION que_scheduler_check_job_exists();
+
+DROP INDEX que_scheduler_job_in_que_jobs_unique_index;

data/lib/que/scheduler/migrations/6/up.sql

@@ -0,0 +1,26 @@
+-- Ensure there is no more than one scheduler
+CREATE UNIQUE INDEX que_scheduler_job_in_que_jobs_unique_index ON que_jobs(job_class)
+WHERE job_class = 'Que::Scheduler::SchedulerJob';
+
+-- Ensure there is at least one scheduler
+CREATE OR REPLACE FUNCTION que_scheduler_check_job_exists() RETURNS bool AS $$
+SELECT EXISTS(SELECT * FROM que_jobs WHERE job_class = 'Que::Scheduler::SchedulerJob');
+$$ LANGUAGE SQL;
+
+CREATE OR REPLACE FUNCTION que_scheduler_prevent_job_deletion() RETURNS TRIGGER AS
+$BODY$
+DECLARE
+BEGIN
+    IF OLD.job_class = 'Que::Scheduler::SchedulerJob' THEN
+        IF NOT que_scheduler_check_job_exists() THEN
+            raise exception 'Deletion of que_scheduler job % prevented. Deleting the que_scheduler job is almost certainly a mistake.', OLD.job_id;
+        END IF;
+    END IF;
+    RETURN OLD;
+END;
+$BODY$
+LANGUAGE 'plpgsql';
+
+CREATE CONSTRAINT TRIGGER que_scheduler_prevent_job_deletion_trigger AFTER UPDATE OR DELETE ON que_jobs
+DEFERRABLE INITIALLY DEFERRED
+FOR EACH ROW EXECUTE PROCEDURE que_scheduler_prevent_job_deletion();

data/lib/que/scheduler/schedule.rb

@@ -1,21 +1,31 @@
+require_relative "configuration"
 require_relative "defined_job"
 
 module Que
   module Scheduler
     class Schedule
       class << self
+        # The main method for determining the schedule. It has to evaluate the schedule as late as
+        # possible (ie just as it is about to be used) as we cannot guarantee we are in a Rails
+        # app with initializers. In a future release this may change to "fast fail" in Rails by
+        # checking the config up front.
         def schedule
           @schedule ||=
             begin
-              location = Que::Scheduler.configuration.schedule_location
-              from_file(location)
+              configuration = Que::Scheduler.configuration
+              if !configuration.schedule.nil?
+                # If an explicit schedule as a hash has been defined, use that.
+                from_hash(configuration.schedule)
+              elsif File.exist?(configuration.schedule_location)
+                # If the schedule is defined as a file location, then load it and return it.
+                from_file(configuration.schedule_location)
+              else
+                raise "No que-scheduler config set, or file found " \
+                      "at #{configuration.schedule_location}"
+              end
             end
         end
 
-        def schedule=(schedule_config)
-          @schedule = schedule_config.nil? ? nil : from_yaml(schedule_config)
-        end
-
         def from_file(location)
           from_yaml(IO.read(location))
         end
@@ -27,20 +37,19 @@ module Que
 
         def from_hash(config_hash)
           config_hash.map do |name, defined_job_hash|
-            [name, hash_item_to_defined_job(name, defined_job_hash)]
+            name_str = name.to_s
+            [name_str, hash_item_to_defined_job(name_str, defined_job_hash)]
           end.to_h
         end
 
-        def hash_item_to_defined_job(name, defined_job_hash)
+        def hash_item_to_defined_job(name, defined_job_hash_in)
+          defined_job_hash = defined_job_hash_in.stringify_keys
           # Que stores arguments as a json array. If the args we have to provide are already an
           # array we can can simply pass them through. If it is a single non-nil value, then we make
           # an array with one item which is that value (this includes if it is a hash). It could
           # also be a single nil value.
           args_array =
-            if !defined_job_hash.key?("args")
-              # No args were requested
-              []
-            else
+            if defined_job_hash.key?("args")
               args = defined_job_hash["args"]
               if args.is_a?(Array)
                 # An array of args was requested
@@ -50,11 +59,14 @@ module Que
                 # be enqueued as an array of 1 item
                 [args]
               end
+            else
+              # No args were requested
+              []
             end
 
           Que::Scheduler::DefinedJob.create(
             name: name,
-            job_class: defined_job_hash["class"] || name,
+            job_class: defined_job_hash["class"]&.to_s || name,
             queue: defined_job_hash["queue"],
             args_array: args_array,
             priority: defined_job_hash["priority"],
@@ -69,10 +81,6 @@ module Que
       def schedule
         Schedule.schedule
       end
-
-      def schedule=(value)
-        Schedule.schedule = value
-      end
     end
   end
 end

data/lib/que/scheduler/scheduler_job.rb

@@ -16,8 +16,8 @@ module Que
     class SchedulerJob < Que::Job
       SCHEDULER_FREQUENCY = 60
 
-      Que::Scheduler::VersionSupport.set_priority(self, 0)
-      Que::Scheduler::VersionSupport.apply_retry_semantics(self)
+      VersionSupport.set_priority(self, 0)
+      VersionSupport.apply_retry_semantics(self)
 
       def run(options = nil)
         Que::Scheduler::Db.transaction do
@@ -27,12 +27,13 @@ module Que
           logs = ["que-scheduler last ran at #{scheduler_job_args.last_run_time}."]
           result = EnqueueingCalculator.parse(Scheduler.schedule.values, scheduler_job_args)
           enqueued_jobs = enqueue_required_jobs(result, logs)
+          # Remove this job and schedule self again
+          destroy
           enqueue_self_again(
             scheduler_job_args, scheduler_job_args.as_time, result.job_dictionary, enqueued_jobs
           )
           # Only now we're sure nothing errored, log the results
           logs.each { |str| ::Que.log(event: "que-scheduler".to_sym, message: str) }
-          destroy
         end
       end
 
@@ -59,7 +60,7 @@ module Que
 
       def enqueue_self_again(scheduler_job_args, last_full_execution, job_dictionary, enqueued_jobs)
         # Log last run...
-        job_id = Que::Scheduler::VersionSupport.job_attributes(self).fetch(:job_id)
+        job_id = VersionSupport.job_attributes(self).fetch(:job_id)
         Audit.append(job_id, scheduler_job_args.as_time, enqueued_jobs)
 
         # And rerun...
@@ -72,7 +73,7 @@ module Que
         )
 
         # rubocop:disable Style/GuardClause This reads better as a conditional
-        unless Que::Scheduler::VersionSupport.job_attributes(enqueued_job).fetch(:job_id)
+        unless enqueued_job && VersionSupport.job_attributes(enqueued_job).fetch(:job_id)
           raise "SchedulerJob could not self-schedule. Has `.enqueue` been monkey patched?"
         end
         # rubocop:enable Style/GuardClause

data/lib/que/scheduler/scheduler_job_args.rb

@@ -22,7 +22,8 @@ module Que
           else
             options = options.symbolize_keys
             {
-              last_run_time: Time.zone.parse(options.fetch(:last_run_time)),
+              last_run_time:
+                Que::Scheduler::TimeZone.time_zone.parse(options.fetch(:last_run_time)),
               job_dictionary: options.fetch(:job_dictionary),
             }
           end

data/lib/que/scheduler/state_checks.rb

@@ -8,7 +8,6 @@ module Que
       class << self
         def check
           assert_db_migrated
-          assert_one_scheduler_job
         end
 
         private
@@ -20,7 +19,7 @@ module Que
           sync_err =
             if Que::Scheduler::VersionSupport.running_synchronously? && db_version.zero?
               code = Que::Scheduler::VersionSupport.running_synchronously_code?
-              <<-ERR_SYNC
+              <<~ERR_SYNC
                 You currently have Que to run in synchronous mode using
                 #{code}, so it is most likely this error
                 has happened during an initial migration. You should disable synchronous mode and
@@ -60,21 +59,6 @@ module Que
             synchronously. This will fail as que-scheduler needs the above tables to work.
           ERR
         end
-
-        def assert_one_scheduler_job
-          schedulers = Que::Scheduler::Db.count_schedulers
-          return if schedulers == 1
-
-          raise(<<-ERR)
-            Only one #{Que::Scheduler::SchedulerJob.name} should be enqueued. #{schedulers} were found.
-
-            que-scheduler works by running a self-enqueueing version of itself that determines which
-            jobs should be enqueued based on the provided config. If two or more que-schedulers were
-            to run at once, then duplicate jobs would occur.
-
-            To resolve this problem, please remove any duplicate scheduler jobs from the que_jobs table.
-          ERR
-        end
       end
     end
   end

data/lib/que/scheduler/time_zone.rb

@@ -0,0 +1,61 @@
+module Que
+  module Scheduler
+    module TimeZone
+      BOTH_CONFIG_AND_TIME_DOT_ZONE_SET = <<~ERR.freeze
+        The que-scheduler config for time_zone has been set to a non-nil value, but
+        it appears to also have been set on Time.zone (possibly by Rails). Both of these
+        cannot be non-nil.
+        You should remove the time_zone config from the que-scheduler config block.
+      ERR
+
+      TIME_ZONE_COULD_NOT_BE_DETERMINED = <<~ERR.freeze
+        It appears Time.zone is nil. This prevents proper functioning of que-scheduler.
+
+        Resolving this issue depends on your application setup.
+
+        1) If you are using Rails, set the standard time_zone config
+           eg:
+           ```
+           # In application.rb
+           config.time_zone = "Europe/London"
+           ```
+
+        2) If you are not using Rails, set your time zone in the que-scheduler config:
+           eg:
+           ```
+           Que::Scheduler.configure do |config|
+             config.time_zone = "Europe/London"
+           end
+           ```
+      ERR
+
+      TIME_ZONE_CONFIG_IS_NOT_VALID = <<~ERR.freeze
+        The que-scheduler config for time_zone has been set to a non-nil value, but that value
+        does not yield a real time zone when passed to ActiveSupport::TimeZone.new
+      ERR
+
+      class << self
+        def time_zone
+          @time_zone ||=
+            begin
+              time_dot_zone = Time.zone
+              if time_dot_zone.present?
+                if Que::Scheduler.configuration.time_zone.present?
+                  raise BOTH_CONFIG_AND_TIME_DOT_ZONE_SET
+                end
+
+                time_dot_zone
+              elsif Que::Scheduler.configuration.time_zone
+                new_tz = ActiveSupport::TimeZone.new(Que::Scheduler.configuration.time_zone)
+                raise TIME_ZONE_CONFIG_IS_NOT_VALID unless new_tz
+
+                new_tz
+              else
+                raise TIME_ZONE_COULD_NOT_BE_DETERMINED
+              end
+            end
+        end
+      end
+    end
+  end
+end

data/lib/que/scheduler/to_enqueue.rb

@@ -22,14 +22,12 @@ module Que
           type_from_job_class(job_class).present?
         end
 
-        def active_job_version
-          Gem.loaded_specs["activejob"]&.version
+        def active_job_loaded?
+          !!active_job_version
         end
 
-        def active_job_sufficient_version?
-          # ActiveJob 4.x does not support job_ids correctly
-          # https://github.com/rails/rails/pull/20056/files
-          active_job_version && active_job_version > Gem::Version.create("5")
+        def active_job_version
+          Gem.loaded_specs["activejob"]&.version
         end
 
         def active_job_version_supports_queues?
@@ -56,7 +54,7 @@ module Que
               hash = {
                 ::Que::Job => QueJobType,
               }
-              hash[::ActiveJob::Base] = ActiveJobType if ToEnqueue.active_job_sufficient_version?
+              hash[::ActiveJob::Base] = ActiveJobType if ToEnqueue.active_job_loaded?
               hash
             end
         end
@@ -105,7 +103,13 @@ module Que
         scheduled_at =
           begin
             scheduled_at_float = data[:scheduled_at]
-            scheduled_at_float ? Time.zone.at(scheduled_at_float) : nil
+            # rubocop:disable Style/EmptyElse
+            if scheduled_at_float
+              Que::Scheduler::TimeZone.time_zone.at(scheduled_at_float)
+            else
+              nil
+            end
+            # rubocop:enable Style/EmptyElse
           end
 
         # Rails didn't support queues for ActiveJob for a while

data/lib/que/scheduler/version.rb

@@ -1,5 +1,5 @@
 module Que
   module Scheduler
-    VERSION = "3.4.3".freeze
+    VERSION = "4.1.0".freeze
   end
 end

data/lib/que/scheduler/version_support.rb

@@ -61,7 +61,11 @@ module Que
 
         def zero_major?
           # This is the only way to handle beta releases too
-          @zero_major ||= Gem.loaded_specs["que"].version.to_s.split(".").first.to_i.zero?
+          @zero_major ||= que_version.split(".").first.to_i.zero?
+        end
+
+        def que_version
+          @que_version ||= Gem.loaded_specs["que"].version.to_s
         end
 
         private

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: que-scheduler
 version: !ruby/object:Gem::Version
-  version: 3.4.3
+  version: 4.1.0
 platform: ruby
 authors:
 - Harry Lascelles
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-28 00:00:00.000000000 Z
+date: 2021-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '5.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: fugit
   requirement: !ruby/object:Gem::Requirement
@@ -90,14 +90,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '5.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: appraisal
   requirement: !ruby/object:Gem::Requirement
@@ -112,6 +112,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: climate_control
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: combustion
   requirement: !ruby/object:Gem::Requirement
@@ -244,14 +258,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.84.0
+        version: 1.5.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.84.0
+        version: 1.5.2
 - !ruby/object:Gem::Dependency
   name: rubocop-rspec
   requirement: !ruby/object:Gem::Requirement
@@ -319,7 +333,7 @@ files:
 - lib/que-scheduler.rb
 - lib/que/scheduler.rb
 - lib/que/scheduler/audit.rb
-- lib/que/scheduler/config.rb
+- lib/que/scheduler/configuration.rb
 - lib/que/scheduler/db.rb
 - lib/que/scheduler/defined_job.rb
 - lib/que/scheduler/enqueueing_calculator.rb
@@ -335,10 +349,13 @@ files:
 - lib/que/scheduler/migrations/4/up.sql
 - lib/que/scheduler/migrations/5/down.sql
 - lib/que/scheduler/migrations/5/up.sql
+- lib/que/scheduler/migrations/6/down.sql
+- lib/que/scheduler/migrations/6/up.sql
 - lib/que/scheduler/schedule.rb
 - lib/que/scheduler/scheduler_job.rb
 - lib/que/scheduler/scheduler_job_args.rb
 - lib/que/scheduler/state_checks.rb
+- lib/que/scheduler/time_zone.rb
 - lib/que/scheduler/to_enqueue.rb
 - lib/que/scheduler/version.rb
 - lib/que/scheduler/version_support.rb
@@ -359,7 +376,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/que/scheduler/config.rb

@@ -1,27 +0,0 @@
-require "que"
-require_relative "version_support"
-
-module Que
-  module Scheduler
-    class << self
-      attr_accessor :configuration
-    end
-
-    def self.configure
-      self.configuration ||= Configuration.new
-      yield(configuration)
-    end
-
-    class Configuration
-      attr_accessor :schedule_location
-      attr_accessor :transaction_adapter
-      attr_accessor :que_scheduler_queue
-    end
-  end
-end
-
-Que::Scheduler.configure do |config|
-  config.schedule_location = ENV.fetch("QUE_SCHEDULER_CONFIG_LOCATION", "config/que_schedule.yml")
-  config.transaction_adapter = ::Que.method(:transaction)
-  config.que_scheduler_queue = Que::Scheduler::VersionSupport.default_scheduler_queue
-end