good_job 2.2.0 → 2.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd267297ac5f8e889d5af7d3efb0d12f3564ddedb8c645fde37bc044e18d48d0
-  data.tar.gz: 5fc5715400914b895fb38fc087bb7bb08ea63ffb4db8938cea9e2933b32ade36
+  metadata.gz: a0546a16ecd5760e3ca0dd5097ec950767b5993ac613489d5591d5d44eadc021
+  data.tar.gz: 9e21d8930806b1843d4c32abef233f89f48292229386da593ba82b3a94617eae
 SHA512:
-  metadata.gz: d3da94d9ad1b43e5102d0795d0c3909912ba90178678187d7340170a48c2df733ba7aba4bd33da8fdb50084f82fb4ff960c71dd4db0c23bc1a68278a1d1fbd21
-  data.tar.gz: 9810497b9bdef82a95e79bf98414e60652dc912ccb6cfe9ce0893a898708fe6e547b89d67530c62b721fff01cc2c7bfa679f450c511ca5f68d3a5ef0d0a387ca
+  metadata.gz: 6e3aa1deaa9973f0d435bc6eb77e4557f509a5e9dbd38e267a4268987561576323eda9bfb8bfa3af5ad7aec72c51b17f88121f7d202b1455c1ea17c8272cb6de
+  data.tar.gz: b812a3371f589db1464f3dabe35badee94bf2a8f132e68e64c438e8ddde4415598d133f2e956d335e021a0ea82b59fbc61c3eb77cab230be760516dbca270402

data/CHANGELOG.md

@@ -1,5 +1,78 @@
 # Changelog
 
+## [v2.4.1](https://github.com/bensheldon/good_job/tree/v2.4.1) (2021-10-11)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v2.4.0...v2.4.1)
+
+**Implemented enhancements:**
+
+- Support Datadog APM / `dd-trace-rb` [\#323](https://github.com/bensheldon/good_job/issues/323)
+- Display info about used timezone. [\#398](https://github.com/bensheldon/good_job/pull/398) ([morgoth](https://github.com/morgoth))
+- Display cron schedules args in dashboard [\#396](https://github.com/bensheldon/good_job/pull/396) ([aried3r](https://github.com/aried3r))
+
+**Fixed bugs:**
+
+- Inline adapter should raise unhandled exceptions during execution [\#416](https://github.com/bensheldon/good_job/pull/416) ([bensheldon](https://github.com/bensheldon))
+- Enforce english locale in UI [\#407](https://github.com/bensheldon/good_job/pull/407) ([morgoth](https://github.com/morgoth))
+
+**Closed issues:**
+
+- Finished jobs don't show up as finished [\#415](https://github.com/bensheldon/good_job/issues/415)
+- Inline adapter should raise unhandled exceptions during execution [\#410](https://github.com/bensheldon/good_job/issues/410)
+- Rewrite Scheduler "worker" thread name to be `thread` [\#406](https://github.com/bensheldon/good_job/issues/406)
+- "WARNING: you don't own a lock of type ExclusiveLock" in Development [\#388](https://github.com/bensheldon/good_job/issues/388)
+- Improve Readme's "Optimize queues, threads, processes" section [\#132](https://github.com/bensheldon/good_job/issues/132)
+
+**Merged pull requests:**
+
+- Ignore Rails HEAD Appraisal until `rails new` fixed [\#419](https://github.com/bensheldon/good_job/pull/419) ([bensheldon](https://github.com/bensheldon))
+- Warn in Readme that configuration should not go into `config/initializers/*.rb` [\#418](https://github.com/bensheldon/good_job/pull/418) ([bensheldon](https://github.com/bensheldon))
+- Replace worker wording [\#409](https://github.com/bensheldon/good_job/pull/409) ([Hugo-Hache](https://github.com/Hugo-Hache))
+- Improve Readme's "Optimize queues, threads, processes" section [\#405](https://github.com/bensheldon/good_job/pull/405) ([Hugo-Hache](https://github.com/Hugo-Hache))
+- Update GH Test Matrix with more PG versions [\#401](https://github.com/bensheldon/good_job/pull/401) ([tedhexaflow](https://github.com/tedhexaflow))
+- Extract cron configuration hash into CronEntry ActiveModel objects [\#400](https://github.com/bensheldon/good_job/pull/400) ([bensheldon](https://github.com/bensheldon))
+- Remove errant copy-paste from app.json [\#397](https://github.com/bensheldon/good_job/pull/397) ([morgoth](https://github.com/morgoth))
+
+## [v2.4.0](https://github.com/bensheldon/good_job/tree/v2.4.0) (2021-10-02)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v2.3.1...v2.4.0)
+
+**Implemented enhancements:**
+
+- Display schedule time relative to now. [\#394](https://github.com/bensheldon/good_job/pull/394) ([morgoth](https://github.com/morgoth))
+- Display cron schedules properties in dashboard [\#391](https://github.com/bensheldon/good_job/pull/391) ([aried3r](https://github.com/aried3r))
+
+**Fixed bugs:**
+
+- Correct icon for alert flash [\#395](https://github.com/bensheldon/good_job/pull/395) ([morgoth](https://github.com/morgoth))
+
+## [v2.3.1](https://github.com/bensheldon/good_job/tree/v2.3.1) (2021-09-30)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v2.3.0...v2.3.1)
+
+**Fixed bugs:**
+
+- Wrap Scheduler task execution with Rails `reloader` instead of `executor` to avoid database connection changing during code reload [\#389](https://github.com/bensheldon/good_job/pull/389) ([bensheldon](https://github.com/bensheldon))
+
+**Merged pull requests:**
+
+- Log Cleanup thread tests, introduce "Slow" ExampleJob type, refactor ExampleJob types, run cron and log Postgres warnings in GoodJob Development harness [\#390](https://github.com/bensheldon/good_job/pull/390) ([bensheldon](https://github.com/bensheldon))
+
+## [v2.3.0](https://github.com/bensheldon/good_job/tree/v2.3.0) (2021-09-25)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v2.2.0...v2.3.0)
+
+**Implemented enhancements:**
+
+- Create an ActiveJobJob model and Dashboard [\#383](https://github.com/bensheldon/good_job/pull/383) ([bensheldon](https://github.com/bensheldon))
+- Preserve page filter when deleting execution [\#381](https://github.com/bensheldon/good_job/pull/381) ([morgoth](https://github.com/morgoth))
+
+**Merged pull requests:**
+
+- Update GH Test Matrix with latest JRuby 9.3.0.0 [\#387](https://github.com/bensheldon/good_job/pull/387) ([tedhexaflow](https://github.com/tedhexaflow))
+- Improve test support's ShellOut command's process termination and add test logs [\#385](https://github.com/bensheldon/good_job/pull/385) ([bensheldon](https://github.com/bensheldon))
+- @bensheldon Add Rails 7 alpha to Appraisal; update development dependencies [\#384](https://github.com/bensheldon/good_job/pull/384) ([bensheldon](https://github.com/bensheldon))
+
 ## [v2.2.0](https://github.com/bensheldon/good_job/tree/v2.2.0) (2021-09-15)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v2.1.0...v2.2.0)

data/README.md

@@ -212,7 +212,11 @@ to delete old records and preserve space in your database.
 
 To use GoodJob, you can set `config.active_job.queue_adapter` to a `:good_job`.
 
-Additional configuration can be provided via `config.good_job.OPTION = ...` for example:
+Additional configuration can be provided via `config.good_job.OPTION = ...`.
+
+_Configuration **must** be placed into `config/application.rb` or `config/environments/{RAILS_ENV}.rb`; configuration may not work correctly if placed into `config/initializers/*.rb` because application initializers run _after_ gem initialization (see [Rails#36650](https://github.com/rails/rails/issues/36650) and [GoodJob#380](https://github.com/bensheldon/good_job/issues/380))._
+
+Configuration examples:
 
 ```ruby
 # config/application.rb
@@ -576,43 +580,62 @@ end
 
 By default, GoodJob creates a single thread execution pool that will execute jobs from any queue. Depending on your application's workload, job types, and service level objectives, you may wish to optimize execution resources. For example, providing dedicated execution resources for transactional emails so they are not delayed by long-running batch jobs. Some options:
 
-- Multiple execution pools within a single process:
+- Multiple isolated execution pools within a single process:
+
+    For moderate workloads, multiple isolated thread execution pools offers a good balance between congestion management and economy.
+
+    A pool is configured with the following syntax `<participating_queues>:<thread_count>`:
+
+    - `<participating_queues>`: either `queue1,queue2` (only those queues), `*` (all) or `-queue1,queue2` (all except those queues).
+    - `<thread_count>`: a count overriding for this specific pool the global `max-threads`.
+
+    Pool configurations are separated with a semicolon (;) in the `queues` configuration
 
     ```bash
-    $ bundle exec good_job --queues="transactional_messages:2;batch_processing:1;-transactional_messages,batch_processing:2;*" --max-threads=5
+    $ bundle exec good_job \
+        --queues="transactional_messages:2;batch_processing:1;-transactional_messages,batch_processing:2;*" \
+        --max-threads=5
     ```
 
-    This configuration will result in a single process with 4 isolated thread execution pools. Isolated execution pools are separated with a semicolon (`;`) and queue names and thread counts with a colon (`:`)
+    This configuration will result in a single process with 4 isolated thread execution pools.
 
-    - `transactional_messages:2`: execute jobs enqueued on `transactional_messages` with up to 2 threads.
-    - `batch_processing:1` execute jobs enqueued on `batch_processing` with a single thread.
-    - `-transactional_messages,batch_processing`: execute jobs enqueued on _any_ queue _excluding_ `transactional_messages` or `batch_processing` with up to 2 threads.
-    - `*`: execute jobs on any queue on up to 5 threads, as configured by `--max-threads=5`
-
-    For moderate workloads, multiple isolated thread execution pools offers a good balance between congestion management and economy.
+    - `transactional_messages:2`: execute jobs enqueued on `transactional_messages`, with up to 2 threads.
+    - `batch_processing:1` execute jobs enqueued on `batch_processing`, with a single thread.
+    - `-transactional_messages,batch_processing`: execute jobs enqueued on _any_ queue _excluding_ `transactional_messages` or `batch_processing`, with up to 2 threads.
+    - `*`: execute jobs on any queue, with up to 5 threads (as configured by `--max-threads=5`).
 
     Configuration can be injected by environment variables too:
 
     ```bash
-    $ GOOD_JOB_QUEUES="transactional_messages:2;batch_processing:1;-transactional_messages,batch_processing:2;*" GOOD_JOB_MAX_THREADS=5 bundle exec good_job
+    $ GOOD_JOB_QUEUES="transactional_messages:2;batch_processing:1;-transactional_messages,batch_processing:2;*" \
+      GOOD_JOB_MAX_THREADS=5 \
+      bundle exec good_job
     ```
 
-- Multiple processes; for example, on Heroku:
+- Multiple processes:
+
+    While multiple isolated thread execution pools offer a way to provide dedicated execution resources, those resources are bound to a single machine. To scale them independently, define several processes.
+
+    For example, this configuration on Heroku allows to customize the dyno count (instances), or type (CPU/RAM), per process type:
 
     ```procfile
     # Procfile
 
-    # Separate dyno types
+    # Separate process types
     worker: bundle exec good_job --max-threads=5
     transactional_worker: bundle exec good_job --queues="transactional_messages" --max-threads=2
     batch_worker: bundle exec good_job --queues="batch_processing" --max-threads=1
+    ```
+
+    To optimize for CPU performance at the expense of greater memory and system resource usage, while keeping a single process type (and thus a single dyno), combine several processes and wait for them:
 
-    # Combined multi-process dyno
+    ```procfile
+    # Procfile
+
+    # Combined multi-process
     combined_worker: bundle exec good_job --max-threads=5 & bundle exec good_job --queues="transactional_messages" --max-threads=2 & bundle exec good_job --queues="batch_processing" --max-threads=1 & wait -n
     ```
 
-    Running multiple processes can optimize for CPU performance at the expense of greater memory and system resource usage.
-
 Keep in mind, queue operations and management is an advanced discipline. This stuff is complex, especially for heavy workloads and unique processing requirements. Good job 👍
 
 ### Database connections

data/engine/app/controllers/good_job/base_controller.rb

@@ -2,5 +2,13 @@
 module GoodJob
   class BaseController < ActionController::Base # rubocop:disable Rails/ApplicationController
     protect_from_forgery with: :exception
+
+    around_action :switch_locale
+
+    private
+
+    def switch_locale(&action)
+      I18n.with_locale(:en, &action)
+    end
   end
 end

data/engine/app/controllers/good_job/cron_schedules_controller.rb

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
-
 module GoodJob
   class CronSchedulesController < GoodJob::BaseController
     def index
       configuration = GoodJob::Configuration.new({})
-      @cron_schedules = configuration.cron
+      @cron_entries = configuration.cron_entries
     end
   end
 end

data/engine/app/controllers/good_job/executions_controller.rb

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
 module GoodJob
   class ExecutionsController < GoodJob::BaseController
+    def index
+      @filter = ExecutionsFilter.new(params)
+    end
+
     def destroy
       deleted_count = GoodJob::Execution.where(id: params[:id]).delete_all
       message = deleted_count.positive? ? { notice: "Job execution deleted" } : { alert: "Job execution not deleted" }
-      redirect_to root_path, **message
+      redirect_back fallback_location: root_path, **message
     end
   end
 end

data/engine/app/controllers/good_job/{active_jobs_controller.rb → jobs_controller.rb}

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
 module GoodJob
-  class ActiveJobsController < GoodJob::BaseController
+  class JobsController < GoodJob::BaseController
+    def index
+      @filter = JobsFilter.new(params)
+    end
+
     def show
       @executions = GoodJob::Execution.active_job_id(params[:id])
                                       .order(Arel.sql("COALESCE(scheduled_at, created_at) DESC"))
-      raise ActiveRecord::RecordNotFound if @executions.empty?
+      redirect_to root_path, alert: "Executions for Active Job #{params[:id]} not found" if @executions.empty?
     end
   end
 end

data/engine/app/filters/good_job/base_filter.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+module GoodJob
+  class BaseFilter
+    attr_accessor :params
+
+    def initialize(params)
+      @params = params
+    end
+
+    def records
+      after_scheduled_at = params[:after_scheduled_at].present? ? Time.zone.parse(params[:after_scheduled_at]) : nil
+
+      filtered_query.display_all(
+        after_scheduled_at: after_scheduled_at,
+        after_id: params[:after_id]
+      ).limit(params.fetch(:limit, 25))
+    end
+
+    def last
+      @_last ||= records.last
+    end
+
+    def job_classes
+      base_query.group("serialized_params->>'job_class'").count
+                .sort_by { |name, _count| name }
+                .to_h
+    end
+
+    def queues
+      base_query.group(:queue_name).count
+                .sort_by { |name, _count| name }
+                .to_h
+    end
+
+    def states
+      raise NotImplementedError
+    end
+
+    def to_params(override)
+      {
+        state: params[:state],
+        job_class: params[:job_class],
+      }.merge(override).delete_if { |_, v| v.nil? }
+    end
+
+    def chart_data
+      count_query = Arel.sql(GoodJob::Execution.pg_or_jdbc_query(<<~SQL.squish))
+        SELECT *
+        FROM generate_series(
+          date_trunc('hour', $1::timestamp),
+          date_trunc('hour', $2::timestamp),
+          '1 hour'
+        ) timestamp
+        LEFT JOIN (
+          SELECT
+              date_trunc('hour', scheduled_at) AS scheduled_at,
+              queue_name,
+              count(*) AS count
+            FROM (
+              #{filtered_query.except(:select).select('queue_name', 'COALESCE(good_jobs.scheduled_at, good_jobs.created_at)::timestamp AS scheduled_at').to_sql}
+            ) sources
+            GROUP BY date_trunc('hour', scheduled_at), queue_name
+        ) sources ON sources.scheduled_at = timestamp
+        ORDER BY timestamp ASC
+      SQL
+
+      current_time = Time.current
+      binds = [[nil, current_time - 1.day], [nil, current_time]]
+      executions_data = GoodJob::Execution.connection.exec_query(count_query, "GoodJob Dashboard Chart", binds)
+
+      queue_names = executions_data.map { |d| d['queue_name'] }.uniq
+      labels = []
+      queues_data = executions_data.to_a.group_by { |d| d['timestamp'] }.each_with_object({}) do |(timestamp, values), hash|
+        labels << timestamp.in_time_zone.strftime('%H:%M %z')
+        queue_names.each do |queue_name|
+          (hash[queue_name] ||= []) << values.find { |d| d['queue_name'] == queue_name }&.[]('count')
+        end
+      end
+
+      {
+        labels: labels,
+        series: queues_data.map do |queue, data|
+          {
+            name: queue,
+            data: data,
+          }
+        end,
+      }
+    end
+
+    private
+
+    def base_query
+      raise NotImplementedError
+    end
+
+    def filtered_query
+      raise NotImplementedError
+    end
+  end
+end

data/engine/app/filters/good_job/executions_filter.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+module GoodJob
+  class ExecutionsFilter < BaseFilter
+    def states
+      {
+        'finished' => base_query.finished.count,
+        'unfinished' => base_query.unfinished.count,
+        'running' => base_query.running.count,
+        'errors' => base_query.where.not(error: nil).count,
+      }
+    end
+
+    private
+
+    def base_query
+      GoodJob::Execution.all
+    end
+
+    def filtered_query
+      query = base_query
+      query = query.job_class(params[:job_class]) if params[:job_class]
+      query = query.where(queue_name: params[:queue_name]) if params[:queue_name]
+
+      if params[:state]
+        case params[:state]
+        when 'finished'
+          query = query.finished
+        when 'unfinished'
+          query = query.unfinished
+        when 'running'
+          query = query.running
+        when 'errors'
+          query = query.where.not(error: nil)
+        end
+      end
+
+      query
+    end
+  end
+end

data/engine/app/filters/good_job/jobs_filter.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+module GoodJob
+  class JobsFilter < BaseFilter
+    def states
+      {
+        'scheduled' =>  base_query.scheduled.count,
+        'retried' => base_query.retried.count,
+        'queued' => base_query.queued.count,
+        'running' => base_query.running.count,
+        'finished' => base_query.finished.count,
+        'discarded' => base_query.discarded.count,
+      }
+    end
+
+    private
+
+    def base_query
+      GoodJob::ActiveJobJob.all
+    end
+
+    def filtered_query
+      query = base_query
+      query = query.job_class(params[:job_class]) if params[:job_class]
+      query = query.where(queue_name: params[:queue_name]) if params[:queue_name]
+
+      if params[:state]
+        case params[:state]
+        when 'discarded'
+          query = query.discarded
+        when 'finished'
+          query = query.finished
+        when 'retried'
+          query = query.retried
+        when 'scheduled'
+          query = query.scheduled
+        when 'running'
+          query = query.running.select('good_jobs.*', 'pg_locks.locktype')
+        when 'queued'
+          query = query.queued
+        end
+      end
+
+      query
+    end
+  end
+end

data/engine/app/helpers/good_job/application_helper.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 module GoodJob
   module ApplicationHelper
+    def relative_time(timestamp)
+      text = timestamp.future? ? "in #{time_ago_in_words(timestamp)}" : "#{time_ago_in_words(timestamp)} ago"
+      tag.time(text, datetime: timestamp, title: timestamp)
+    end
   end
 end

data/engine/app/models/good_job/active_job_job.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+module GoodJob
+  # ActiveRecord model that represents an +ActiveJob+ job.
+  # Is the same record data as a {GoodJob::Execution} but only the most recent execution.
+  # Parent class can be configured with +GoodJob.active_record_parent_class+.
+  # @!parse
+  #   class ActiveJob < ActiveRecord::Base; end
+  class ActiveJobJob < Object.const_get(GoodJob.active_record_parent_class)
+    include GoodJob::Lockable
+
+    self.table_name = 'good_jobs'
+    self.primary_key = 'active_job_id'
+    self.advisory_lockable_column = 'active_job_id'
+
+    has_many :executions, -> { order(created_at: :asc) }, class_name: 'GoodJob::Execution', foreign_key: 'active_job_id'
+
+    # Only the most-recent unretried execution represents a "Job"
+    default_scope { where(retried_good_job_id: nil) }
+
+    # Get Jobs with given class name
+    # @!method job_class
+    # @!scope class
+    # @param string [String]
+    #   Execution class name
+    # @return [ActiveRecord::Relation]
+    scope :job_class, ->(job_class) { where("serialized_params->>'job_class' = ?", job_class) }
+
+    # First execution will run in the future
+    scope :scheduled, -> { where(finished_at: nil).where('COALESCE(scheduled_at, created_at) > ?', DateTime.current).where("(serialized_params->>'executions')::integer < 2") }
+    # Execution errored, will run in the future
+    scope :retried, -> { where(finished_at: nil).where('COALESCE(scheduled_at, created_at) > ?', DateTime.current).where("(serialized_params->>'executions')::integer > 1") }
+    # Immediate/Scheduled time to run has passed, waiting for an available thread run
+    scope :queued, -> { where(finished_at: nil).where('COALESCE(scheduled_at, created_at) <= ?', DateTime.current).joins_advisory_locks.where(pg_locks: { locktype: nil }) }
+    # Advisory locked and executing
+    scope :running, -> { where(finished_at: nil).joins_advisory_locks.where.not(pg_locks: { locktype: nil }) }
+    # Completed executing successfully
+    scope :finished, -> { where.not(finished_at: nil).where(error: nil) }
+    # Errored but will not be retried
+    scope :discarded, -> { where.not(finished_at: nil).where.not(error: nil) }
+
+    # Get Jobs in display order with optional keyset pagination.
+    # @!method display_all(after_scheduled_at: nil, after_id: nil)
+    # @!scope class
+    # @param after_scheduled_at [DateTime, String, nil]
+    #   Display records scheduled after this time for keyset pagination
+    # @param after_id [Numeric, String, nil]
+    #   Display records after this ID for keyset pagination
+    # @return [ActiveRecord::Relation]
+    scope :display_all, (lambda do |after_scheduled_at: nil, after_id: nil|
+      query = order(Arel.sql('COALESCE(scheduled_at, created_at) DESC, id DESC'))
+      if after_scheduled_at.present? && after_id.present?
+        query = query.where(Arel.sql('(COALESCE(scheduled_at, created_at), id) < (:after_scheduled_at, :after_id)'), after_scheduled_at: after_scheduled_at, after_id: after_id)
+      elsif after_scheduled_at.present?
+        query = query.where(Arel.sql('(COALESCE(scheduled_at, created_at)) < (:after_scheduled_at)'), after_scheduled_at: after_scheduled_at)
+      end
+      query
+    end)
+
+    def id
+      active_job_id
+    end
+
+    def _execution_id
+      attributes['id']
+    end
+
+    def job_class
+      serialized_params['job_class']
+    end
+
+    def status
+      if finished_at.present?
+        if error.present?
+          :discarded
+        else
+          :finished
+        end
+      elsif (scheduled_at || created_at) > DateTime.current
+        if serialized_params.fetch('executions', 0) > 1
+          :retried
+        else
+          :scheduled
+        end
+      elsif running?
+        :running
+      else
+        :queued
+      end
+    end
+
+    def head_execution
+      executions.last
+    end
+
+    def tail_execution
+      executions.first
+    end
+
+    def executions_count
+      aj_count = serialized_params.fetch('executions', 0)
+      # The execution count within serialized_params is not updated
+      # once the underlying execution has been executed.
+      if status.in? [:discarded, :finished, :running]
+        aj_count + 1
+      else
+        aj_count
+      end
+    end
+
+    def preserved_executions_count
+      executions.size
+    end
+
+    def recent_error
+      error.presence || executions[-2]&.error
+    end
+
+    def running?
+      # Avoid N+1 Query: `.joins_advisory_locks.select('good_jobs.*', 'pg_locks.locktype AS locktype')`
+      if has_attribute?(:locktype)
+        self['locktype'].present?
+      else
+        advisory_locked?
+      end
+    end
+  end
+end

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

@@ -1,22 +1,66 @@
-<% if @cron_schedules.present? %>
+<% if @cron_entries.present? %>
   <div class="card my-3">
     <div class="table-responsive">
       <table class="table card-table table-bordered table-hover table-sm mb-0">
         <thead>
           <th>Cron Job Name</th>
           <th>Configuration</th>
+          <th>
+            Set&nbsp;
+            <%= tag.button "Toggle", type: "button", class: "btn btn-sm btn-outline-primary", role: "button",
+                           data: { bs_toggle: "collapse", bs_target: ".job-properties" },
+                           aria: { expanded: false, controls: @cron_entries.map { |cron_entry| dom_id(cron_entry, 'properties') }.join(" ") }
+            %>
+          </th>
+          <th>
+            Args&nbsp;
+            <%= tag.button "Toggle", type: "button", class: "btn btn-sm btn-outline-primary", role: "button",
+                           data: { bs_toggle: "collapse", bs_target: ".job-args" },
+                           aria: { expanded: false, controls: @cron_entries.map { |cron_entry| dom_id(cron_entry, 'args') }.join(" ") }
+            %>
+          </th>
           <th>Class</th>
           <th>Description</th>
           <th>Next scheduled</th>
         </thead>
         <tbody>
-          <% @cron_schedules.each do |job_key, job| %>
+          <% @cron_entries.each do |cron_entry| %>
             <tr>
-              <td class="font-monospace"><%= job_key %></td>
-              <td class="font-monospace"><%= job[:cron] %></td>
-              <td class="font-monospace"><%= job[:class] %></td>
-              <td><%= job[:description] %></td>
-              <td><%= Fugit.parse_cron(job[:cron]).next_time.to_local_time %></td>
+              <td class="font-monospace"><%= cron_entry.key %></td>
+              <td class="font-monospace"><%= cron_entry.cron %></td>
+              <td>
+                <%=
+                  case cron_entry.set
+                  when NilClass
+                    "None"
+                  when Proc
+                    "Lambda/Callable"
+                  when Hash
+                    tag.button("Preview", type: "button", class: "btn btn-sm btn-outline-primary", role: "button",
+                        data: { bs_toggle: "collapse", bs_target: "##{dom_id(cron_entry, 'properties')}" },
+                        aria: { expanded: false, controls: dom_id(cron_entry, 'properties') }) +
+                      tag.pre(JSON.pretty_generate(cron_entry.set), id: dom_id(cron_entry, 'properties'), class: "collapse job-properties")
+                  end
+                %>
+              </td>
+              <td>
+                <%=
+                  case cron_entry.args
+                  when NilClass
+                    "None"
+                  when Proc
+                    "Lambda/Callable"
+                  when Hash
+                    tag.button("Preview", type: "button", class: "btn btn-sm btn-outline-primary", role: "button",
+                        data: { bs_toggle: "collapse", bs_target: "##{dom_id(cron_entry, 'args')}" },
+                        aria: { expanded: false, controls: dom_id(cron_entry, 'args') }) +
+                      tag.pre(JSON.pretty_generate(cron_entry.args), id: dom_id(cron_entry, 'args'), class: "collapse job-args")
+                  end
+                %>
+              </td>
+              <td class="font-monospace"><%= cron_entry.job_class %></td>
+              <td><%= cron_entry.description %></td>
+              <td><%= cron_entry.next_at.to_local_time %></td>
             </tr>
           <% end %>
         </tbody>