good_job 1.11.3 → 1.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5e0f0ca8d7f8b024f5e84b515b8603d362b6c755d54680221e517369b6877c07
-  data.tar.gz: e69518c9d71d7b08e3707c9df8c6429ca4d9823fd1adea32adc6c0bf41ad33f4
+  metadata.gz: bdf4b1eebb1224acd53f07753d5cda9cb9fde7a44baf300824d7816da94980f2
+  data.tar.gz: 4b90c9cd8133f179f87094683218ed1a1aed3582512169dd914a00dd62a81628
 SHA512:
-  metadata.gz: 50d2542bfad082dfba516c08bd994dad3fcd6e8311a8380dc012988c3e2745378271adc7d41cb91897d087a6b2b100cfb69362d3a11cd55c92c2610ceabeb80c
-  data.tar.gz: 69ffc79dc9367fc8522bdcf669cede6791d4e7903847edbc99887404b29ec43361de54a960841ee6cdeaaf236cc77d8c9c60b2c61793b5256bf2455667e0c387
+  metadata.gz: e95350cb8bd69198231d8030cc07adb9c87649499d30b6aa467ad4a06244920f2e950f46eae891e6963532fa879000959fcaa2eddf6093b8cd9d960eefef9abb
+  data.tar.gz: 1e09cf2851ca64fc34407e29f5afbac5bd7a72f072cef7c22798458b9ebc5678e287abbb03ee0d070cea8aa0665d85b017b94b68737e3e26ce7c0f67905c66e0

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [v1.12.0](https://github.com/bensheldon/good_job/tree/v1.12.0) (2021-07-27)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v1.11.3...v1.12.0)
+
+**Implemented enhancements:**
+
+- Add the ability to schedule repeating / recurring / cron-like jobs [\#53](https://github.com/bensheldon/good_job/issues/53)
+- Add cron-like support for recurring/repeating jobs [\#297](https://github.com/bensheldon/good_job/pull/297) ([bensheldon](https://github.com/bensheldon))
+
+**Merged pull requests:**
+
+- Place Dashboard shared view partials under `good_job` namespace [\#310](https://github.com/bensheldon/good_job/pull/310) ([bensheldon](https://github.com/bensheldon))
+- Ensure Dashboard inline javascript has CSP nonce for strict Content-Security Policy [\#309](https://github.com/bensheldon/good_job/pull/309) ([bensheldon](https://github.com/bensheldon))
+
 ## [v1.11.3](https://github.com/bensheldon/good_job/tree/v1.11.3) (2021-07-25)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v1.11.2...v1.11.3)

data/README.md

@@ -38,7 +38,8 @@ For more of the story of GoodJob, read the [introductory blog post](https://isla
     - [Configuration options](#configuration-options)
     - [Global options](#global-options)
     - [Dashboard](#dashboard)
-    - [ActiveJob Concurrency](#activejob-concurrency)
+    - [ActiveJob concurrency](#activejob-concurrency)
+    - [Cron-style repeating/recurring jobs](#cron-style-repeatingrecurring-jobs)
     - [Updating](#updating)
 - [Go deeper](#go-deeper)
     - [Exceptions, retries, and reliability](#exceptions-retries-and-reliability)
@@ -156,6 +157,7 @@ Options:
   [--poll-interval=SECONDS]    # Interval between polls for available jobs in seconds (env var: GOOD_JOB_POLL_INTERVAL, default: 1)
   [--max-cache=COUNT]          # Maximum number of scheduled jobs to cache in memory (env var: GOOD_JOB_MAX_CACHE, default: 10000)
   [--shutdown-timeout=SECONDS] # Number of seconds to wait for jobs to finish when shutting down before stopping the thread. (env var: GOOD_JOB_SHUTDOWN_TIMEOUT, default: -1 (forever))
+  [--enable-cron]              # Whether to run cron process (default: false)
   [--daemonize]                # Run as a background daemon (default: false)
   [--pidfile=PIDFILE]          # Path to write daemonized Process ID (env var: GOOD_JOB_PIDFILE, default: tmp/pids/good_job.pid)
 
@@ -212,7 +214,8 @@ config.good_job.execution_mode = :async_server
 config.good_job.max_threads = 5
 config.good_job.poll_interval = 30 # seconds
 config.good_job.shutdown_timeout = 25 # seconds
-
+config.good_job.enable_cron = true
+config.good_job.cron = { example: { cron: '0 * * * *', class: 'ExampleJob'  } }
 
 # ...or all at once.
 config.good_job = {
@@ -220,6 +223,13 @@ config.good_job = {
   max_threads: 5,
   poll_interval: 30,
   shutdown_timeout: 25,
+  enable_cron: true,
+  cron: {
+    example: {
+      cron: '0 * * * *',
+      class: 'ExampleJob'
+    },
+  },
 }
 ```
 
@@ -235,6 +245,8 @@ Available configuration options are:
 - `poll_interval` (integer) sets the number of seconds between polls for jobs when `execution_mode` is set to `:async` or `:async_server`. You can also set this with the environment variable `GOOD_JOB_POLL_INTERVAL`.
 - `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` (float) 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` (hash) cron configuration. Defaults to `{}`. You can also set this as a JSON string with the environment variable `GOOD_JOB_CRON`
 
 By default, GoodJob configures the following execution modes per environment:
 
@@ -320,7 +332,7 @@ GoodJob includes a Dashboard as a mountable `Rails::Engine`.
     end
     ```
 
-### ActiveJob Concurrency
+### ActiveJob concurrency
 
 GoodJob can extend ActiveJob to provide limits on concurrently running jobs, either at time of _enqueue_ or at _perform_.
 
@@ -349,6 +361,38 @@ class MyJob < ApplicationJob
 end
 ```
 
+### Cron-style repeating/recurring jobs
+
+GoodJob can enqueue jobs on a recurring basis that can be used as a replacement for cron.
+
+Cron-style jobs are run on every GoodJob process (e.g. CLI or `async` execution mode) when `config.good_job.enable_cron = true`; use GoodJob's [ActiveJob concurrency](#activejob-concurrency) extension to limit the number of jobs that are enqueued.
+
+Cron-format is parsed by the [`fugit`](https://github.com/floraison/fugit) gem, which has support for seconds-level resolution (e.g. `* * * * * *`).
+
+```ruby
+# config/environments/application.rb or a specific environment e.g. production.rb
+
+# Enable cron in this process; e.g. only run on the first Heroku worker process
+config.good_job.enable_cron = ENV['DYNO'] == 'worker.1' # or `true` or via $GOOD_JOB_ENABLE_CRON
+
+# 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(52, name: "Alice")`
+  frequent_task: { # each recurring job must have a unique key
+    cron: "*/15 * * * *", # cron-style scheduling format by fugit gem
+    class: "ExampleJob", # reference the Job class with a string
+    args: [42, { name: "Alice" }], # arguments to pass; can also be a proc e.g. `-> { { when: Time.now } }`
+    set: { priority: -10 }, # additional ActiveJob properties; can also be a lambda/proc e.g. `-> { { priority: [1,2].sample } }`
+    description: "Something helpful", # optional description that appears in Dashboard (coming soon!)
+  },
+  another_task: {
+    cron: "0 0,12 * * *",
+    class: "AnotherJob",
+  },
+  # etc.
+}
+```
+
 ### Updating
 
 GoodJob follows semantic versioning, though updates may be encouraged through deprecation warnings in minor versions.

data/engine/app/views/good_job/active_jobs/show.html.erb

@@ -1 +1 @@
-<%= render 'shared/jobs_table', jobs: @jobs %>
+<%= render 'good_job/shared/jobs_table', jobs: @jobs %>

data/engine/app/views/good_job/dashboards/index.html.erb

@@ -1,5 +1,5 @@
 <div class="card my-3 p-6">
-  <%= render 'shared/chart', chart_data: @chart %>
+  <%= render 'good_job/shared/chart', chart_data: @chart %>
 </div>
 
 <div class='card mb-2'>
@@ -38,7 +38,7 @@
 </div>
 
 <% if @filter.jobs.present? %>
-  <%= render 'shared/jobs_table', jobs: @filter.jobs %>
+  <%= render 'good_job/shared/jobs_table', jobs: @filter.jobs %>
 
   <nav aria-label="Job pagination" class="mt-3">
     <ul class="pagination">

data/engine/app/views/{shared → good_job/shared}/_chart.erb

@@ -1,6 +1,6 @@
 <div id="chart"></div>
 
-<script>
+<%= javascript_tag nonce: true do %>
   new Chartist.Line('#chart', <%== chart_data.to_json %>, {
     height: '300px',
     fullWidth: true,
@@ -49,4 +49,4 @@
     tooltipEl.style.left = (event.offsetX || event.originalEvent.layerX) + tooltipEl.offsetWidth + 10 + 'px';
     tooltipEl.style.top = (event.offsetY || event.originalEvent.layerY) + tooltipEl.offsetHeight - 20 + 'px';
   }, true);
-</script>
+<% end %>

data/engine/app/views/{shared → good_job/shared}/_jobs_table.erb

@@ -29,7 +29,7 @@
             </td>
             <td>
               <%= button_to job_path(job.id), method: :delete, class: "btn btn-sm btn-outline-danger", title: "Delete job" do %>
-                <%= render "shared/icons/trash" %>
+                <%= render "good_job/shared/icons/trash" %>
               <% end %>
             </td>
           </tr>

data/engine/app/views/layouts/good_job/base.html.erb

@@ -53,13 +53,13 @@
 
     <% if notice %>
       <div class="alert alert-success alert-dismissible fade show d-flex align-items-center offset-md-3 col-6" role="alert">
-        <%= render "shared/icons/check", class: "flex-shrink-0 me-2" %>
+        <%= render "good_job/shared/icons/check", class: "flex-shrink-0 me-2" %>
         <div><%= notice %></div>
         <button type="button" class="btn-close" data-bs-dismiss="alert" aria-label="Close"></button>
       </div>
     <% elsif alert %>
       <div class="alert alert-warning alert-dismissible fade show d-flex align-items-center offset-md-3 col-6" role="alert">
-        <%= render "shared/icons/check", class: "flex-shrink-0 me-2" %>
+        <%= render "good_job/shared/icons/check", class: "flex-shrink-0 me-2" %>
         <div><%= alert %></div>
         <button type="button" class="btn-close" data-bs-dismiss="alert" aria-label="Close"></button>
       </div>

data/lib/good_job.rb

@@ -106,16 +106,13 @@ module GoodJob
                 wait ? -1 : nil
               end
 
-    executables = Array(Notifier.instances) + Array(Poller.instances) + Array(Scheduler.instances)
-    _shutdown_all(executables, timeout: timeout)
+    _shutdown_all(_executables, timeout: timeout)
   end
 
   # Tests whether jobs have stopped executing.
   # @return [Boolean] whether background threads are shut down
   def self.shutdown?
-    Notifier.instances.all?(&:shutdown?) &&
-      Poller.instances.all?(&:shutdown?) &&
-      Scheduler.instances.all?(&:shutdown?)
+    _executables.all?(&:shutdown?)
   end
 
   # Stops and restarts executing jobs.
@@ -126,8 +123,7 @@ module GoodJob
   # @param timeout [Numeric, nil] Seconds to wait for active threads to finish.
   # @return [void]
   def self.restart(timeout: -1)
-    executables = Array(Notifier.instances) + Array(Poller.instances) + Array(Scheduler.instances)
-    _shutdown_all(executables, :restart, timeout: timeout)
+    _shutdown_all(_executables, :restart, timeout: timeout)
   end
 
   # Sends +#shutdown+ or +#restart+ to executable objects ({GoodJob::Notifier}, {GoodJob::Poller}, {GoodJob::Scheduler})
@@ -146,5 +142,14 @@ module GoodJob
     end
   end
 
+  def self._executables
+    [].concat(
+      CronManager.instances,
+      Notifier.instances,
+      Poller.instances,
+      Scheduler.instances
+    )
+  end
+
   ActiveSupport.run_load_hooks(:good_job, self)
 end

data/lib/good_job/adapter.rb

@@ -57,6 +57,8 @@ module GoodJob
         @scheduler = GoodJob::Scheduler.from_configuration(@configuration, warm_cache_on_initialize: Rails.application.initialized?)
         @notifier.recipients << [@scheduler, :create_thread]
         @poller.recipients << [@scheduler, :create_thread]
+
+        @cron_manager = GoodJob::CronManager.new(@configuration.cron, start_on_initialize: Rails.application.initialized?) if @configuration.enable_cron?
       end
     end
 

data/lib/good_job/cli.rb

@@ -70,12 +70,16 @@ module GoodJob
                   type: :numeric,
                   banner: 'SECONDS',
                   desc: "Number of seconds to wait for jobs to finish when shutting down before stopping the thread. (env var: GOOD_JOB_SHUTDOWN_TIMEOUT, default: -1 (forever))"
+    method_option :enable_cron,
+                  type: :boolean,
+                  desc: "Whether to run cron process (default: false)"
     method_option :daemonize,
                   type: :boolean,
                   desc: "Run as a background daemon (default: false)"
     method_option :pidfile,
                   type: :string,
                   desc: "Path to write daemonized Process ID (env var: GOOD_JOB_PIDFILE, default: tmp/pids/good_job.pid)"
+
     def start
       set_up_application!
       configuration = GoodJob::Configuration.new(options)
@@ -87,7 +91,7 @@ module GoodJob
       scheduler = GoodJob::Scheduler.from_configuration(configuration, warm_cache_on_initialize: true)
       notifier.recipients << [scheduler, :create_thread]
       poller.recipients << [scheduler, :create_thread]
-
+      cron_manager = GoodJob::CronManager.new(configuration.cron, start_on_initialize: true) if configuration.enable_cron?
       @stop_good_job_executable = false
       %w[INT TERM].each do |signal|
         trap(signal) { @stop_good_job_executable = true }
@@ -98,7 +102,7 @@ module GoodJob
         break if @stop_good_job_executable || scheduler.shutdown? || notifier.shutdown?
       end
 
-      executors = [notifier, poller, scheduler]
+      executors = [notifier, poller, cron_manager, scheduler].compact
       GoodJob._shutdown_all(executors, timeout: configuration.shutdown_timeout)
     end
 
@@ -124,6 +128,7 @@ module GoodJob
                   type: :numeric,
                   banner: 'SECONDS',
                   desc: "Delete records finished more than this many seconds ago (env var: GOOD_JOB_CLEANUP_PRESERVED_JOBS_BEFORE_SECONDS_AGO, default: 86400)"
+
     def cleanup_preserved_jobs
       set_up_application!
 

data/lib/good_job/configuration.rb

@@ -18,6 +18,8 @@ module GoodJob
     DEFAULT_CLEANUP_PRESERVED_JOBS_BEFORE_SECONDS_AGO = 24 * 60 * 60
     # Default to always wait for jobs to finish for {Adapter#shutdown}
     DEFAULT_SHUTDOWN_TIMEOUT = -1
+    # Default to not running cron
+    DEFAULT_ENABLE_CRON = false
 
     # The options that were explicitly set when initializing +Configuration+.
     # @return [Hash]
@@ -129,6 +131,28 @@ module GoodJob
       ).to_f
     end
 
+    # Whether to run cron
+    # @return [Boolean]
+    def enable_cron
+      value = ActiveModel::Type::Boolean.new.cast(
+        options[:enable_cron] ||
+        rails_config[:enable_cron] ||
+        env['GOOD_JOB_ENABLE_CRON'] ||
+        false
+      )
+      value && cron.size.positive?
+    end
+    alias enable_cron? enable_cron
+
+    def cron
+      env_cron = JSON.parse(ENV['GOOD_JOB_CRON']) if ENV['GOOD_JOB_CRON'].present?
+
+      options[:cron] ||
+        rails_config[:cron] ||
+        env_cron ||
+        {}
+    end
+
     # Number of seconds to preserve jobs when using the +good_job cleanup_preserved_jobs+ CLI command.
     # This configuration is only used when {GoodJob.preserve_job_records} is +true+.
     # @return [Integer]

data/lib/good_job/cron_manager.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+require "concurrent/hash"
+require "concurrent/scheduled_task"
+require "fugit"
+
+module GoodJob # :nodoc:
+  #
+  # CronManagers enqueue jobs on a repeating schedule.
+  #
+  class CronManager
+    # @!attribute [r] instances
+    #   @!scope class
+    #   List of all instantiated CronManagers in the current process.
+    #   @return [Array<GoodJob::CronManagers>, nil]
+    cattr_reader :instances, default: [], instance_reader: false
+
+    # Task observer for cron task
+    # @param time [Time]
+    # @param output [Object]
+    # @param thread_error [Exception]
+    def self.task_observer(time, output, thread_error) # rubocop:disable Lint/UnusedMethodArgument
+      return if thread_error.is_a? Concurrent::CancelledOperationError
+
+      GoodJob.on_thread_error.call(thread_error) if thread_error && GoodJob.on_thread_error.respond_to?(:call)
+    end
+
+    # Job configuration to be scheduled
+    # @return [Hash]
+    attr_reader :schedules
+
+    # @param schedules [Hash]
+    # @param start_on_initialize [Boolean]
+    def initialize(schedules = {}, start_on_initialize: false)
+      @running = false
+      @schedules = schedules
+      @tasks = Concurrent::Hash.new
+
+      self.class.instances << self
+
+      start if start_on_initialize
+    end
+
+    # Schedule tasks that will enqueue jobs based on their schedule
+    def start
+      ActiveSupport::Notifications.instrument("cron_manager_start.good_job", cron_jobs: @schedules) do
+        @running = true
+        schedules.each_key { |cron_key| create_task(cron_key) }
+      end
+    end
+
+    # Stop/cancel any scheduled tasks
+    # @param timeout [Numeric, nil] Unused but retained for compatibility
+    def shutdown(timeout: nil) # rubocop:disable Lint/UnusedMethodArgument
+      @running = false
+      @tasks.each do |_cron_key, task|
+        task.cancel
+      end
+      @tasks.clear
+    end
+
+    # Stop and restart
+    # @param timeout [Numeric, nil] Unused but retained for compatibility
+    def restart(timeout: nil) # rubocop:disable Lint/UnusedMethodArgument
+      shutdown
+      start
+    end
+
+    # Tests whether the manager is running.
+    # @return [Boolean, nil]
+    def running?
+      @running
+    end
+
+    # Tests whether the manager is shutdown.
+    # @return [Boolean, nil]
+    def shutdown?
+      !running?
+    end
+
+    # Enqueues a scheduled task
+    # @param cron_key [Symbol, String] the key within the schedule to use
+    def create_task(cron_key)
+      schedule = @schedules[cron_key]
+      return false if schedule.blank?
+
+      fugit = Fugit::Cron.parse(schedule.fetch(:cron))
+      delay = [(fugit.next_time - Time.current).to_f, 0].max
+
+      future = Concurrent::ScheduledTask.new(delay, args: [self, cron_key]) do |thr_scheduler, thr_cron_key|
+        # Re-schedule the next cron task before executing the current task
+        thr_scheduler.create_task(thr_cron_key)
+
+        CurrentExecution.reset
+        CurrentExecution.cron_key = thr_cron_key
+
+        Rails.application.executor.wrap do
+          schedule = thr_scheduler.schedules.fetch(thr_cron_key).with_indifferent_access
+          job_class = schedule.fetch(:class).constantize
+
+          job_set_value = schedule.fetch(:set, {})
+          job_set = job_set_value.respond_to?(:call) ? job_set_value.call : job_set_value
+
+          job_args_value = schedule.fetch(:args, [])
+          job_args = job_args_value.respond_to?(:call) ? job_args_value.call : job_args_value
+
+          job_class.set(job_set).perform_later(*job_args)
+        end
+      end
+
+      @tasks[cron_key] = future
+      future.add_observer(self.class, :task_observer)
+      future.execute
+    end
+  end
+end

data/lib/good_job/current_execution.rb

@@ -11,6 +11,12 @@ module GoodJob
     #   @return [String, nil]
     thread_mattr_accessor :active_job_id
 
+    # @!attribute [rw] cron_key
+    #   @!scope class
+    #   Cron Key
+    #   @return [String, nil]
+    thread_mattr_accessor :cron_key
+
     # @!attribute [rw] error_on_discard
     #   @!scope class
     #   Error captured by discard_on

data/lib/good_job/job.rb

@@ -199,6 +199,7 @@ module GoodJob
     def self.enqueue(active_job, scheduled_at: nil, create_with_advisory_lock: false)
       ActiveSupport::Notifications.instrument("enqueue_job.good_job", { active_job: active_job, scheduled_at: scheduled_at, create_with_advisory_lock: create_with_advisory_lock }) do |instrument_payload|
         good_job_args = {
+          cron_key: CurrentExecution.cron_key,
           queue_name: active_job.queue_name.presence || DEFAULT_QUEUE_NAME,
           priority: active_job.priority || DEFAULT_PRIORITY,
           serialized_params: active_job.serialize,
@@ -285,6 +286,25 @@ module GoodJob
       super || serialized_params['job_id']
     end
 
+    def cron_key
+      if self.class.column_names.include?('cron_key')
+        super
+      else
+        ActiveSupport::Deprecation.warn(<<~DEPRECATION)
+          GoodJob has pending database migrations. To create the migration files, run:
+
+              rails generate good_job:update
+
+          To apply the migration files, run:
+
+              rails db:migrate
+
+        DEPRECATION
+
+        nil
+      end
+    end
+
     private
 
     # @return [ExecutionResult]
@@ -295,6 +315,7 @@ module GoodJob
 
       GoodJob::CurrentExecution.reset
       GoodJob::CurrentExecution.active_job_id = active_job_id
+      GoodJob::CurrentExecution.cron_key = cron_key
       ActiveSupport::Notifications.instrument("perform_job.good_job", { good_job: self, process_id: GoodJob::CurrentExecution.process_id, thread_name: GoodJob::CurrentExecution.thread_name }) do
         value = ActiveJob::Base.execute(params)
 

data/lib/good_job/log_subscriber.rb

@@ -57,6 +57,16 @@ module GoodJob
       end
     end
 
+    # @!macro notification_responder
+    def cron_manager_start(event)
+      cron_jobs = event.payload[:cron_jobs]
+      cron_jobs_count = cron_jobs.size
+
+      info do
+        "GoodJob started cron with #{cron_jobs_count} #{'jobs'.pluralize(cron_jobs_count)}."
+      end
+    end
+
     # @!macro notification_responder
     def scheduler_shutdown_start(event)
       process_id = event.payload[:process_id]

data/lib/good_job/railtie.rb

@@ -3,6 +3,7 @@ module GoodJob
   # Ruby on Rails integration.
   class Railtie < ::Rails::Railtie
     config.good_job = ActiveSupport::OrderedOptions.new
+    config.good_job.cron = {}
 
     initializer "good_job.logger" do |_app|
       ActiveSupport.on_load(:good_job) do
@@ -23,6 +24,7 @@ module GoodJob
 
     config.after_initialize do
       GoodJob::Scheduler.instances.each(&:warm_cache)
+      GoodJob::CronManager.instances.each(&:start)
     end
   end
 end

data/lib/good_job/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 module GoodJob
   # GoodJob gem version.
-  VERSION = '1.11.3'
+  VERSION = '1.12.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 1.11.3
+  version: 1.12.0
 platform: ruby
 authors:
 - Ben Sheldon
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-07-25 00:00:00.000000000 Z
+date: 2021-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
@@ -52,6 +52,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.0.2
+- !ruby/object:Gem::Dependency
+  name: fugit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: railties
   requirement: !ruby/object:Gem::Requirement
@@ -345,12 +359,12 @@ files:
 - engine/app/helpers/good_job/application_helper.rb
 - engine/app/views/good_job/active_jobs/show.html.erb
 - engine/app/views/good_job/dashboards/index.html.erb
+- engine/app/views/good_job/shared/_chart.erb
+- engine/app/views/good_job/shared/_jobs_table.erb
+- engine/app/views/good_job/shared/icons/_check.html.erb
+- engine/app/views/good_job/shared/icons/_exclamation.html.erb
+- engine/app/views/good_job/shared/icons/_trash.html.erb
 - engine/app/views/layouts/good_job/base.html.erb
-- engine/app/views/shared/_chart.erb
-- engine/app/views/shared/_jobs_table.erb
-- engine/app/views/shared/icons/_check.html.erb
-- engine/app/views/shared/icons/_exclamation.html.erb
-- engine/app/views/shared/icons/_trash.html.erb
 - engine/config/routes.rb
 - engine/lib/good_job/engine.rb
 - exe/good_job
@@ -367,6 +381,7 @@ files:
 - lib/good_job/adapter.rb
 - lib/good_job/cli.rb
 - lib/good_job/configuration.rb
+- lib/good_job/cron_manager.rb
 - lib/good_job/current_execution.rb
 - lib/good_job/daemon.rb
 - lib/good_job/execution_result.rb