good_job 4.3.0 → 4.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec5d4c89f52824a8023774ca2179f67579c21ae7772737a367ee912bc58db9bd
-  data.tar.gz: f8526687220d9bd8ec7222f897f2302ab7d42f8883627c43195390b7ab9cf0be
+  metadata.gz: f7e5a7c2df1683ddffde677bddf6bbd9d2d316ec646f571161749e4648ec7da7
+  data.tar.gz: dd2e664a3ada0f89e2a07731ef5d1ebff9c5edd87768ce584622f5ac33a0da12
 SHA512:
-  metadata.gz: 3760a509091f29ca67d90366b06940cb4b12428bbe99a5fd451315ec9895291d2083168603f1f81a3b87ccf1a6df9bcf657d9c89a811768436fdd6a80aa60737
-  data.tar.gz: 9ca52b976c7399f386e141c7ea6d54bfbf3b1b8036ef6f1ac37cc24dede46966ab7644c1c8a5bcde491c3a768862fd1edbd66b7054e06a0e6955e5f7b3d8245f
+  metadata.gz: 5faa526ba40039167498cf5c1046251feca2d0255746170de2f153531a5f973fdfc326319b16dcff30d893b38131fbb76d814cf4c4a15f5276b0f371bc05a3be
+  data.tar.gz: a8db86f639120ddc90b5de3245962a4630e006a26fc832b98dbb8892f9131298251780128ce03d7d3a94b59ec9b117d4fd277adc3e34fa96234c85c1378c9f8e

data/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## [v4.4.0](https://github.com/bensheldon/good_job/tree/v4.4.0) (2024-10-08)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v4.3.0...v4.4.0)
+
+**Fixed bugs:**
+
+- fix: unable to use keyword args when including the `Labels` extension [\#1500](https://github.com/bensheldon/good_job/pull/1500) ([ElMassimo](https://github.com/ElMassimo))
+- Fix GoodJob::Setting duplicate keys [\#1498](https://github.com/bensheldon/good_job/pull/1498) ([mohammednasser-32](https://github.com/mohammednasser-32))
+- Allow `GoodJob::Job#retry_job`'s transaction to be joinable \(fix CI for current `rails-head`\) [\#1496](https://github.com/bensheldon/good_job/pull/1496) ([Earlopain](https://github.com/Earlopain))
+
+**Closed issues:**
+
+- Inline adapter doesn't retry jobs that throw a retryable error [\#1497](https://github.com/bensheldon/good_job/issues/1497)
+- scheduled\_at not respecting given timezone [\#1491](https://github.com/bensheldon/good_job/issues/1491)
+- Multiple same values in cron\_keys\_disabled, cron\_keys\_enabled in good\_job\_settings table [\#1490](https://github.com/bensheldon/good_job/issues/1490)
+- Cron jobs can be missed if deploys are timed just right [\#1484](https://github.com/bensheldon/good_job/issues/1484)
+- Configuring connection pool in external mode [\#1483](https://github.com/bensheldon/good_job/issues/1483)
+- GoodJob Timezone Day Light Savings [\#1480](https://github.com/bensheldon/good_job/issues/1480)
+- Unable to use labels with kwargs in job initializer  [\#1350](https://github.com/bensheldon/good_job/issues/1350)
+
+**Merged pull requests:**
+
+- Bump puma from 6.4.2 to 6.4.3 [\#1492](https://github.com/bensheldon/good_job/pull/1492) ([dependabot[bot]](https://github.com/apps/dependabot))
+- Add `cron_graceful_restart_period` to avoid missing recurring jobs that occurred during deployment downtime [\#1488](https://github.com/bensheldon/good_job/pull/1488) ([bensheldon](https://github.com/bensheldon))
+
 ## [v4.3.0](https://github.com/bensheldon/good_job/tree/v4.3.0) (2024-09-14)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v4.2.1...v4.3.0)

data/README.md

@@ -257,6 +257,7 @@ Rails.application.configure do
   config.good_job.shutdown_timeout = 25 # seconds
   config.good_job.enable_cron = true
   config.good_job.cron = { example: { cron: '0 * * * *', class: 'ExampleJob'  } }
+  config.good_job.cron_graceful_restart_period = 5.minutes
   config.good_job.dashboard_default_locale = :en
 
   # ...or all at once.
@@ -298,6 +299,7 @@ Available configuration options are:
 - `max_cache` (integer) sets the maximum number of scheduled jobs that will be stored in memory to reduce execution latency when also polling for scheduled jobs. Caching 10,000 scheduled jobs uses approximately 20MB of memory. You can also set this with the environment variable `GOOD_JOB_MAX_CACHE`.
 - `shutdown_timeout` (integer) number of seconds to wait for jobs to finish when shutting down before stopping the thread. Defaults to forever: `-1`. You can also set this with the environment variable `GOOD_JOB_SHUTDOWN_TIMEOUT`.
 - `enable_cron` (boolean) whether to run cron process. Defaults to `false`. You can also set this with the environment variable `GOOD_JOB_ENABLE_CRON`.
+- `cron_graceful_restart_period` (integer) when restarting cron, attempt to re-enqueue jobs that would have been enqueued by cron within this time period (e.g. `1.minute`). This should match the expected downtime during deploys.
 - `enable_listen_notify` (boolean) whether to enqueue and read jobs with Postgres LISTEN/NOTIFY. Defaults to `true`. You can also set this with the environment variable `GOOD_JOB_ENABLE_LISTEN_NOTIFY`.
 - `cron` (hash) cron configuration. Defaults to `{}`. You can also set this as a JSON string with the environment variable `GOOD_JOB_CRON`
 - `cleanup_discarded_jobs` (boolean) whether to destroy discarded jobs when cleaning up preserved jobs using the `$ good_job cleanup_preserved_jobs` CLI command or calling `GoodJob.cleanup_preserved_jobs`. Defaults to `true`. Can also be set with  the environment variable `GOOD_JOB_CLEANUP_DISCARDED_JOBS`. _This configuration is only used when {GoodJob.preserve_job_records} is `true`._
@@ -625,6 +627,9 @@ If you use the [Dashboard](#dashboard) the scheduled tasks can be viewed in the
 # Enable cron enqueuing in this process
 config.good_job.enable_cron = true
 
+# Without zero-downtime deploys, re-attempt previous schedules after a deploy
+config.good_job.cron_graceful_restart_period = 1.minute
+
 # Configure cron with a hash that has a unique key for each recurring job
 config.good_job.cron = {
   # Every 15 minutes, enqueue `ExampleJob.set(priority: -10).perform_later(42, "life", name: "Alice")`

data/app/models/good_job/cron_entry.rb

@@ -71,6 +71,19 @@ module GoodJob # :nodoc:
       end
     end
 
+    def within(period, previously_at: nil)
+      if cron_proc?
+        result = Rails.application.executor.wrap { cron.call(previously_at || last_job_at) }
+        if result.is_a?(String)
+          Fugit.parse(result).within(period).map(&:to_t)
+        else
+          result
+        end
+      else
+        fugit.within(period).map(&:to_t)
+      end
+    end
+
     def enabled?
       GoodJob::Setting.cron_key_enabled?(key, default: enabled_by_default?)
     end

data/app/models/good_job/job.rb

@@ -478,7 +478,7 @@ module GoodJob
           current_thread.job = self
           current_thread.retry_now = true
 
-          self.class.transaction(joinable: false, requires_new: true) do
+          transaction do
             new_active_job = active_job.retry_job(wait: 0, error: error)
             self.error_event = :retried if error
             save!

data/app/models/good_job/setting.rb

@@ -19,30 +19,32 @@ module GoodJob
     end
 
     def self.cron_key_enable(key)
+      key_string = key.to_s
       enabled_setting = find_or_initialize_by(key: CRON_KEYS_ENABLED) do |record|
         record.value = []
       end
-      enabled_setting.value << key unless enabled_setting.value.include?(key)
+      enabled_setting.value << key unless enabled_setting.value.include?(key_string)
       enabled_setting.save!
 
       disabled_setting = GoodJob::Setting.find_by(key: CRON_KEYS_DISABLED)
-      return unless disabled_setting&.value&.include?(key.to_s)
+      return unless disabled_setting&.value&.include?(key_string)
 
-      disabled_setting.value.delete(key.to_s)
+      disabled_setting.value.delete(key_string)
       disabled_setting.save!
     end
 
     def self.cron_key_disable(key)
       enabled_setting = GoodJob::Setting.find_by(key: CRON_KEYS_ENABLED)
-      if enabled_setting&.value&.include?(key.to_s)
-        enabled_setting.value.delete(key.to_s)
+      key_string = key.to_s
+      if enabled_setting&.value&.include?(key_string)
+        enabled_setting.value.delete(key_string)
         enabled_setting.save!
       end
 
       disabled_setting = find_or_initialize_by(key: CRON_KEYS_DISABLED) do |record|
         record.value = []
       end
-      disabled_setting.value << key unless disabled_setting.value.include?(key)
+      disabled_setting.value << key unless disabled_setting.value.include?(key_string)
       disabled_setting.save!
     end
   end

data/lib/good_job/active_job_extensions/labels.rb

@@ -6,7 +6,7 @@ module GoodJob
       extend ActiveSupport::Concern
 
       module Prepends
-        def initialize(*arguments)
+        def initialize(...)
           super
           self.good_job_labels = Array(self.class.good_job_labels.dup)
         end

data/lib/good_job/configuration.rb

@@ -219,6 +219,12 @@ module GoodJob
       cron.map { |cron_key, params| GoodJob::CronEntry.new(params.merge(key: cron_key)) }
     end
 
+    def cron_graceful_restart_period
+      options[:cron_graceful_restart_period] ||
+        rails_config[:cron_graceful_restart_period] ||
+        env['GOOD_JOB_CRON_GRACEFUL_RESTART_PERIOD']
+    end
+
     # The number of queued jobs to select when polling for a job to run.
     # This limit is intended to avoid locking a large number of rows when selecting eligible jobs
     # from the queue. This value should be higher than the total number of threads across all good_job

data/lib/good_job/cron_manager.rb

@@ -31,11 +31,12 @@ module GoodJob # :nodoc:
 
     # @param cron_entries [Array<CronEntry>]
     # @param start_on_initialize [Boolean]
-    def initialize(cron_entries = [], start_on_initialize: false, executor: Concurrent.global_io_executor)
+    def initialize(cron_entries = [], start_on_initialize: false, graceful_restart_period: nil, executor: Concurrent.global_io_executor)
       @executor = executor
       @running = false
       @cron_entries = cron_entries
       @tasks = Concurrent::Hash.new
+      @graceful_restart_period = graceful_restart_period
 
       start if start_on_initialize
       self.class.instances << self
@@ -47,6 +48,7 @@ module GoodJob # :nodoc:
         @running = true
         cron_entries.each do |cron_entry|
           create_task(cron_entry)
+          create_graceful_tasks(cron_entry) if @graceful_restart_period
         end
       end
     end
@@ -97,5 +99,24 @@ module GoodJob # :nodoc:
       future.add_observer(self.class, :task_observer)
       future.execute
     end
+
+    # Uses the graceful restart period to re-enqueue jobs that were scheduled to run during the period.
+    # The existing uniqueness logic should ensure this does not create duplicate jobs.
+    # @param cron_entry [CronEntry] the CronEntry object to schedule
+    def create_graceful_tasks(cron_entry)
+      return unless @graceful_restart_period
+
+      time_period = @graceful_restart_period.ago..Time.current
+      cron_entry.within(time_period).each do |cron_at|
+        future = Concurrent::Future.new(args: [self, cron_entry, cron_at], executor: @executor) do |_thr_scheduler, thr_cron_entry, thr_cron_at|
+          Rails.application.executor.wrap do
+            cron_entry.enqueue(thr_cron_at) if thr_cron_entry.enabled?
+          end
+        end
+
+        future.add_observer(self.class, :task_observer)
+        future.execute
+      end
+    end
   end
 end

data/lib/good_job/version.rb

@@ -2,7 +2,7 @@
 
 module GoodJob
   # GoodJob gem version.
-  VERSION = '4.3.0'
+  VERSION = '4.4.0'
 
   # GoodJob version as Gem::Version object
   GEM_VERSION = Gem::Version.new(VERSION)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 4.3.0
+  version: 4.4.0
 platform: ruby
 authors:
 - Ben Sheldon
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-09-14 00:00:00.000000000 Z
+date: 2024-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob