good_job 3.1.0 → 3.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc6e3cffa2189a101181b7ceb278de97ded27d14dd6da915ea8fe3729907dd88
-  data.tar.gz: 0504d2f2efd09d1d52669597e364f62b69edc739d3c76b8bcfdd1933ea7cb8da
+  metadata.gz: cabb124450eb5e88a460635fb4aa70f3e5a53406ded6554bb32018fa2aa890bc
+  data.tar.gz: 0d83085806f8a1f30eff6136df4995f7982064b90a497ee56a4f8b9d922f4fbb
 SHA512:
-  metadata.gz: c10f675a3635f481e370502828ed0902aff3464e19f161bf5f300463a2671ecac09643eb0943030eda30163171b67986b0f9e31ca423ad5da9e4ffd5b23a7df7
-  data.tar.gz: 3ab12e91adb910040a4007140054cc048a0f83e34e54ee649e52ea673a27b95cfb267b56fae98a7605616e4c3f55d17af403c99bf9ba2a5d504dffdd917a7cbb
+  metadata.gz: 7f17d4379517d9909ac771c9920b3472b1d5bbb18ce45bd78b160f76eba6b6a1169e6b89ec044cd8f3c5ad93a311be45174bd43b99468c5ff9a5c4bad088263f
+  data.tar.gz: 27f6aa3048d4035feb1e55b7cd4a3ba8410deb74ec9268fba23bac9a75c9db26bc3599d1f140bf68182b2f2307183013bc6601927a6eec19cab6051fcf03a927

data/CHANGELOG.md

@@ -1,12 +1,70 @@
 # Changelog
 
+## [v3.3.1](https://github.com/bensheldon/good_job/tree/v3.3.1) (2022-07-26)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v3.3.0...v3.3.1)
+
+**Implemented enhancements:**
+
+- Show basename of proctitle [\#679](https://github.com/bensheldon/good_job/pull/679) ([bkeepers](https://github.com/bkeepers))
+
+**Fixed bugs:**
+
+- Only count \_active\_ processes in the Navbar [\#680](https://github.com/bensheldon/good_job/pull/680) ([bensheldon](https://github.com/bensheldon))
+- Remove Zeitwerk and use explicit requires to be more like an engine [\#677](https://github.com/bensheldon/good_job/pull/677) ([bensheldon](https://github.com/bensheldon))
+
+**Closed issues:**
+
+- Dashboard UI Invalid count of running process  [\#678](https://github.com/bensheldon/good_job/issues/678)
+
+**Merged pull requests:**
+
+- Lock to dotenv 2.7.x for Ruby 2.5 compatibility [\#682](https://github.com/bensheldon/good_job/pull/682) ([bensheldon](https://github.com/bensheldon))
+- Create global GoodJob.configuration object [\#681](https://github.com/bensheldon/good_job/pull/681) ([bensheldon](https://github.com/bensheldon))
+
+## [v3.3.0](https://github.com/bensheldon/good_job/tree/v3.3.0) (2022-07-24)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v3.2.0...v3.3.0)
+
+**Implemented enhancements:**
+
+- Dashboard: Update cron and processes to match jobs listing [\#676](https://github.com/bensheldon/good_job/pull/676) ([bkeepers](https://github.com/bkeepers))
+- Dashboard: improvements to jobs index and show pages [\#672](https://github.com/bensheldon/good_job/pull/672) ([bkeepers](https://github.com/bkeepers))
+
+**Fixed bugs:**
+
+- Replace "timestamp" column-type in migrations with "datetime" [\#671](https://github.com/bensheldon/good_job/pull/671) ([bensheldon](https://github.com/bensheldon))
+
+**Closed issues:**
+
+- Calculating database connections [\#669](https://github.com/bensheldon/good_job/issues/669)
+- Unable to Replace GoodJob's Logger [\#667](https://github.com/bensheldon/good_job/issues/667)
+- Readme should consistently encourage usage of `config.good_job....` instead of `GoodJob.` configuration [\#628](https://github.com/bensheldon/good_job/issues/628)
+- Improve the "Gem development" section of README? [\#551](https://github.com/bensheldon/good_job/issues/551)
+- Simplify Rails initialization to only be a mountable Engine [\#543](https://github.com/bensheldon/good_job/issues/543)
+
+**Merged pull requests:**
+
+- Improve Readme description of v3 job preservation defaults [\#670](https://github.com/bensheldon/good_job/pull/670) ([bensheldon](https://github.com/bensheldon))
+- update Gemfile.lock to latest dependencies [\#647](https://github.com/bensheldon/good_job/pull/647) ([jrochkind](https://github.com/jrochkind))
+
+## [v3.2.0](https://github.com/bensheldon/good_job/tree/v3.2.0) (2022-07-12)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v3.1.0...v3.2.0)
+
+**Implemented enhancements:**
+
+- Ordered queue handling by workers [\#665](https://github.com/bensheldon/good_job/pull/665) ([jrochkind](https://github.com/jrochkind))
+
 ## [v3.1.0](https://github.com/bensheldon/good_job/tree/v3.1.0) (2022-07-11)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v3.0.2...v3.1.0)
 
 **Implemented enhancements:**
 
+- Show job/cron/process counts in the Navbar [\#663](https://github.com/bensheldon/good_job/pull/663) ([bensheldon](https://github.com/bensheldon))
 - Improve Dashboard display of parameters \(CronEntry kwargs; Process configuration; Job and Execution database values\) [\#662](https://github.com/bensheldon/good_job/pull/662) ([bensheldon](https://github.com/bensheldon))
+- Dequeing should be first-in first-out [\#651](https://github.com/bensheldon/good_job/pull/651) ([jrochkind](https://github.com/jrochkind))
 
 **Fixed bugs:**
 
@@ -19,11 +77,6 @@
 - Cron schedule page in dashboard not showing kwargs [\#608](https://github.com/bensheldon/good_job/issues/608)
 - Paralelism x database connections [\#569](https://github.com/bensheldon/good_job/issues/569)
 
-**Merged pull requests:**
-
-- Show job/cron/process counts in the Navbar [\#663](https://github.com/bensheldon/good_job/pull/663) ([bensheldon](https://github.com/bensheldon))
-- Dequeing should be first-in first-out [\#651](https://github.com/bensheldon/good_job/pull/651) ([jrochkind](https://github.com/jrochkind))
-
 ## [v3.0.2](https://github.com/bensheldon/good_job/tree/v3.0.2) (2022-07-10)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v3.0.1...v3.0.2)
@@ -53,13 +106,16 @@
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v3.0.0...v3.0.1)
 
+**Fixed bugs:**
+
+- Fix `GoodJob.cleanup_preserved_jobs` to use `delete_all` instead of `destroy_all` [\#652](https://github.com/bensheldon/good_job/pull/652) ([bensheldon](https://github.com/bensheldon))
+
 **Closed issues:**
 
 - ERROR:  relation "good\_jobs" does not exist at character 454 [\#308](https://github.com/bensheldon/good_job/issues/308)
 
 **Merged pull requests:**
 
-- Fix `GoodJob.cleanup_preserved_jobs` to use `delete_all` instead of `destroy_all` [\#652](https://github.com/bensheldon/good_job/pull/652) ([bensheldon](https://github.com/bensheldon))
 - Create codeql-analysis.yml [\#648](https://github.com/bensheldon/good_job/pull/648) ([bensheldon](https://github.com/bensheldon))
 
 ## [v3.0.0](https://github.com/bensheldon/good_job/tree/v3.0.0) (2022-06-26)
@@ -1047,7 +1103,6 @@
 - PgBouncer and prepared statements [\#269](https://github.com/bensheldon/good_job/issues/269)
 - Question about locking internals [\#212](https://github.com/bensheldon/good_job/issues/212)
 - Encoding::UndefinedConversionError \("\xE2" from ASCII-8BIT to UTF-8\) [\#198](https://github.com/bensheldon/good_job/issues/198)
-- tools for managing a 'fleet' of processes [\#150](https://github.com/bensheldon/good_job/issues/150)
 
 **Merged pull requests:**
 

data/README.md

@@ -117,7 +117,7 @@ For more of the story of GoodJob, read the [introductory blog post](https://isla
     YourJob.set(queue: :some_queue, wait: 5.minutes, priority: 10).perform_later
     ```
 
-1. In development, GoodJob executes jobs immediately in a separate thread (async mode). In production, GoodJob provides different options:
+1. In development, GoodJob executes jobs immediately in a separate thread ("async" mode). In production, GoodJob provides different options:
 
     - By default, GoodJob separates job enqueuing from job execution so that jobs can be scaled independently of the web server.  Use the GoodJob command-line tool to execute jobs:
 
@@ -199,7 +199,7 @@ Usage:
   good_job cleanup_preserved_jobs
 
 Options:
-  [--before-seconds-ago=SECONDS] # Destroy records finished more than this many seconds ago (env var:  GOOD_JOB_CLEANUP_PRESERVED_JOBS_BEFORE_SECONDS_AGO, default: 86400)
+  [--before-seconds-ago=SECONDS] # Destroy records finished more than this many seconds ago (env var:  GOOD_JOB_CLEANUP_PRESERVED_JOBS_BEFORE_SECONDS_AGO, default: 1209600 (14 days))
 
 Destroys preserved job records.
 
@@ -226,6 +226,8 @@ GoodJob configuration can be placed within Rails `config` directory for all envi
 Configuration examples:
 
 ```ruby
+# config/initializers/good_job.rb OR config/application.rb OR config/environments/{RAILS_ENV}.rb
+
 Rails.application.configure do
   # Configure options individually...
   config.good_job.preserve_job_records = true
@@ -275,9 +277,9 @@ Available configuration options are:
 - `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`
 - `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`._
-- `cleanup_preserved_jobs_before_seconds_ago` (integer) number of seconds to preserve jobs when using the `$ good_job cleanup_preserved_jobs` CLI command or calling `GoodJob.cleanup_preserved_jobs`. Defaults to `86400` (1 day). Can also be set with  the environment variable `GOOD_JOB_CLEANUP_PRESERVED_JOBS_BEFORE_SECONDS_AGO`.  _This configuration is only used when {GoodJob.preserve_job_records} is `true`._
-- `cleanup_interval_jobs` (integer) Number of jobs a Scheduler will execute before cleaning up preserved jobs. Defaults to `nil`. Can also be set with  the environment variable `GOOD_JOB_CLEANUP_INTERVAL_JOBS`.
-- `cleanup_interval_seconds` (integer) Number of seconds a Scheduler will wait before cleaning up preserved jobs. Defaults to `nil`. Can also be set with  the environment variable `GOOD_JOB_CLEANUP_INTERVAL_SECONDS`.
+- `cleanup_preserved_jobs_before_seconds_ago` (integer) number of seconds to preserve jobs when using the `$ good_job cleanup_preserved_jobs` CLI command or calling `GoodJob.cleanup_preserved_jobs`. Defaults to `1209600` (14 days). Can also be set with  the environment variable `GOOD_JOB_CLEANUP_PRESERVED_JOBS_BEFORE_SECONDS_AGO`.  _This configuration is only used when {GoodJob.preserve_job_records} is `true`._
+- `cleanup_interval_jobs` (integer) Number of jobs a Scheduler will execute before cleaning up preserved jobs. Defaults to `1000`. Can also be set with  the environment variable `GOOD_JOB_CLEANUP_INTERVAL_JOBS`.
+- `cleanup_interval_seconds` (integer) Number of seconds a Scheduler will wait before cleaning up preserved jobs. Defaults to `600` (10 minutes). Can also be set with  the environment variable `GOOD_JOB_CLEANUP_INTERVAL_SECONDS`.
 - `inline_execution_respects_schedule` (boolean) Opt-in to future behavior of inline execution respecting scheduled jobs. Defaults to `false`.
 - `logger` ([Rails Logger](https://api.rubyonrails.org/classes/ActiveSupport/Logger.html)) lets you set a custom logger for GoodJob. It should be an instance of a Rails `Logger` (Default: `Rails.logger`).
 - `preserve_job_records` (boolean) keeps job records in your database even after jobs are completed. (Default: `true`)
@@ -310,21 +312,21 @@ config.good_job.execution_mode = :external
 Good Job’s general behavior can also be configured via attributes directly on the `GoodJob` module:
 
 - **`GoodJob.active_record_parent_class`** (string) The ActiveRecord parent class inherited by GoodJob's ActiveRecord model `GoodJob::Job` (defaults to `"ActiveRecord::Base"`). Configure this when using [multiple databases with ActiveRecord](https://guides.rubyonrails.org/active_record_multiple_databases.html) or when other custom configuration is necessary for the ActiveRecord model to connect to the Postgres database. _The value must be a String to avoid premature initialization of ActiveRecord._
-- **`GoodJob.logger`** ([Rails Logger](https://api.rubyonrails.org/classes/ActiveSupport/Logger.html)) lets you set a custom logger for GoodJob. It should be an instance of a Rails `Logger`.
-- **`GoodJob.preserve_job_records`** (boolean) keeps job records in your database even after jobs are completed. (Default: `true`)
-- **`GoodJob.retry_on_unhandled_error`** (boolean) causes jobs to be re-queued and retried if they raise an instance of `StandardError`. Be advised this may lead to jobs being repeated infinitely ([see below for more on retries](#retries)). Instances of `Exception`, like SIGINT, will *always* be retried, regardless of this attribute’s value. (Default: `false`)
-- **`GoodJob.on_thread_error`** (proc, lambda, or callable) will be called when an Exception. It can be useful for logging errors to bug tracking services, like Sentry or Airbrake.
 
 You’ll generally want to configure these in `config/initializers/good_job.rb`, like so:
 
 ```ruby
 # config/initializers/good_job.rb
 GoodJob.active_record_parent_class = "ApplicationRecord"
-GoodJob.preserve_job_records = true
-GoodJob.retry_on_unhandled_error = false
-GoodJob.on_thread_error = -> (exception) { Raven.capture_exception(exception) }
 ```
 
+The following options are also configurable via accessors, but you are encouraged to use the configuration attributes instead because these may be deprecated and removed in the future:
+
+- **`GoodJob.logger`** ([Rails Logger](https://api.rubyonrails.org/classes/ActiveSupport/Logger.html)) lets you set a custom logger for GoodJob. It should be an instance of a Rails `Logger`.
+- **`GoodJob.preserve_job_records`** (boolean) keeps job records in your database even after jobs are completed. (Default: `true`)
+- **`GoodJob.retry_on_unhandled_error`** (boolean) causes jobs to be re-queued and retried if they raise an instance of `StandardError`. Be advised this may lead to jobs being repeated infinitely ([see below for more on retries](#retries)). Instances of `Exception`, like SIGINT, will *always* be retried, regardless of this attribute’s value. (Default: `false`)
+- **`GoodJob.on_thread_error`** (proc, lambda, or callable) will be called when an Exception. It can be useful for logging errors to bug tracking services, like Sentry or Airbrake.
+
 ### Dashboard
 
 ![Dashboard UI](https://github.com/bensheldon/good_job/raw/main/SCREENSHOT.png)
@@ -361,14 +363,7 @@ GoodJob includes a Dashboard as a mountable `Rails::Engine`.
     end
     ```
 
-1. If you want to see finished (successful) and discarded (failed) jobs on the dashboard, you will have to configure job records to be preserved:
-
-    ```ruby
-    # eg in config/initializers/good_job.rb
-    GoodJob.preserve_job_records = true
-    ```
-
-    See more at [Monitor and preserve worked jobs](#monitor-and-preserve-worked-jobs)
+_To view finished (successful) and discarded (failed) jobs on the Dashboard, GoodJob must be configured to preserve job records. Preservation is enabled by default._
 
 **Troubleshooting the Dashboard:** Some applications are unable to autoload the Goodjob Engine. To work around this, explicitly require the Engine at the top of your `config/application.rb` file, immediately after Rails is required and before Bundler requires the Rails' groups.
 
@@ -665,7 +660,7 @@ By default, GoodJob creates a single thread execution pool that will execute job
 
     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).
+    - `<participating_queues>`: either `queue1,queue2` (only those queues), `+queue1,queue2` (only those queues, and processed in order), `*` (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
@@ -683,6 +678,12 @@ By default, GoodJob creates a single thread execution pool that will execute job
     - `-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`).
 
+    When a pool is performing jobs from multiple queues, jobs will be performed from specified queues, ordered by priority and creation time. To perform jobs from queues in the queues' given order, use the `+` modifier. In this example, jobs in `batch_processing` will be performed only when there are no jobs in `transactional_messages`:
+
+    ```bash
+    bundle exec good_job --queues="+transactional_messages,batch_processing"
+    ```
+
     Configuration can be injected by environment variables too:
 
     ```bash
@@ -872,25 +873,24 @@ If your application is already using an ActiveJob backend, you will need to inst
 
 GoodJob is fully instrumented with [`ActiveSupport::Notifications`](https://edgeguides.rubyonrails.org/active_support_instrumentation.html#introduction-to-instrumentation).
 
-By default, GoodJob will preserve job records for 14 days after they are run, regardless of whether they succeed or not (raising a kind of `StandardError`), unless they are interrupted (raising a kind of `Exception`).
+By default, GoodJob will preserve job records for 14 days after they are run, regardless of whether they succeed or raised an exception.
 
-To not preserve job records for later inspection, set an initializer:
+To instead delete job records immediately after they are finished:
 
 ```ruby
 # config/initializers/good_job.rb
-GoodJob.preserve_job_records = false # defaults to true, or `false` or `:on_unhandled_error`
+config.good_job.preserve_job_records = false # defaults to true; can also be `false` or `:on_unhandled_error`
 ```
 
-GoodJob will automatically delete these job records after 14 days. The retention period, as well as the frequency GoodJob checks for deletable records can be configured:
+GoodJob will automatically delete preserved job records after 14 days. The retention period, as well as the frequency GoodJob checks for deletable records can be configured:
 
 ```ruby
-
-config.cleanup_preserved_jobs_before_seconds_ago = 14.days.to_i
-config.cleanup_interval_jobs = 1_000 # Number of executed jobs between deletion sweeps.
-config.cleanup_interval_seconds = 10.minutes.to_i # Number of seconds between deletion sweeps.
+config.good_job.cleanup_preserved_jobs_before_seconds_ago = 14.days.to_i
+config.good_job.cleanup_interval_jobs = 1_000 # Number of executed jobs between deletion sweeps.
+config.good_job.cleanup_interval_seconds = 10.minutes.to_i # Number of seconds between deletion sweeps.
 ```
 
-It is also possible to manually trigger a cleanup:
+It is also possible to manually trigger a cleanup of preserved job records:
 
 - For example, in a Rake task:
 
@@ -1035,7 +1035,7 @@ For gem development and debugging information, please review the [README's Gem D
 # Clone the repository locally
 git clone git@github.com:bensheldon/good_job.git
 
-# Set up the local environment
+# Set up the gem development environment
 bin/setup
 ```
 
@@ -1074,6 +1074,10 @@ bundle install
 Tests can be run against the primary development environment:
 
 ```bash
+# Set up the gem development environment
+bin/setup
+
+# Run the tests
 bin/rspec
 ```
 

data/app/assets/good_job/modules/application.js

@@ -4,11 +4,13 @@ import renderCharts from "charts";
 import checkboxToggle from "checkbox_toggle";
 import documentReady from "document_ready";
 import showToasts from "toasts";
+import setupPopovers from "popovers";
 import LivePoll from "live_poll";
 
 documentReady(function() {
   renderCharts();
   showToasts();
+  setupPopovers();
   checkboxToggle();
 
   const livePoll = new LivePoll

data/app/assets/good_job/modules/popovers.js

@@ -0,0 +1,7 @@
+export default function() {
+  document.querySelectorAll('[data-bs-toggle="popover"]').forEach((el) => {
+    new bootstrap.Popover(el, {
+      template: '<div class="popover" role="tooltip"><div class="popover-arrow"></div><h3 class="popover-header"></h3><pre class="popover-body text-wrap text-break"></pre></div>'
+    })
+  })
+}

data/app/assets/good_job/style.css

@@ -39,3 +39,7 @@
   background-color: red;
   color: white;
 }
+
+.btn-outline-secondary {
+  border-color: #ced4da; /* $gray-400 */
+}

data/app/helpers/good_job/application_helper.rb

@@ -34,8 +34,8 @@ module GoodJob
     STATUS_COLOR = {
       discarded: "danger",
       finished: "success",
-      queued: "warning",
-      retried: "secondary",
+      queued: "secondary",
+      retried: "warning",
       running: "primary",
       scheduled: "secondary",
     }.freeze

data/app/models/concerns/good_job/reportable.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+module GoodJob
+  module Reportable
+    # There are 3 buckets of non-overlapping statuses:
+    #   1. The job will be executed
+    #     - queued: The job will execute immediately when an execution thread becomes available.
+    #     - scheduled: The job is scheduled to execute in the future.
+    #     - retried: The job previously errored on execution and will be re-executed in the future.
+    #   2. The job is being executed
+    #     - running: the job is actively being executed by an execution thread
+    #   3. The job will not execute
+    #     - finished: The job executed successfully
+    #     - discarded: The job previously errored on execution and will not be re-executed in the future.
+    #
+    # @return [Symbol]
+    def status
+      if finished_at.present?
+        if error.present? && retried_good_job_id.present?
+          :retried
+        elsif error.present? && retried_good_job_id.nil?
+          :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
+
+    # The last relevant timestamp for this execution
+    def last_status_at
+      finished_at || performed_at || scheduled_at || created_at
+    end
+  end
+end

data/{lib → app}/models/good_job/cron_entry.rb

@@ -13,7 +13,7 @@ module GoodJob # :nodoc:
     attr_reader :params
 
     def self.all(configuration: nil)
-      configuration ||= GoodJob::Configuration.new({})
+      configuration ||= GoodJob.configuration
       configuration.cron_entries
     end
 

data/{lib → app}/models/good_job/execution.rb

@@ -4,6 +4,7 @@ module GoodJob
   class Execution < BaseRecord
     include Lockable
     include Filterable
+    include Reportable
 
     # Raised if something attempts to execute a previously completed Execution again.
     PreviouslyPerformedError = Class.new(StandardError)
@@ -29,15 +30,21 @@ module GoodJob
     #     not match.
     #   - +{ include: Array<String> }+ indicates the listed queue names should
     #     match.
+    #   - +{ include: Array<String>, ordered_queues: true }+ indicates the listed
+    #     queue names should match, and dequeue should respect queue order.
     # @example
     #   GoodJob::Execution.queue_parser('-queue1,queue2')
     #   => { exclude: [ 'queue1', 'queue2' ] }
     def self.queue_parser(string)
       string = string.presence || '*'
 
-      if string.first == '-'
+      case string.first
+      when '-'
         exclude_queues = true
         string = string[1..-1]
+      when '+'
+        ordered_queues = true
+        string = string[1..-1]
       end
 
       queues = string.split(',').map(&:strip)
@@ -46,6 +53,11 @@ module GoodJob
         { all: true }
       elsif exclude_queues
         { exclude: queues }
+      elsif ordered_queues
+        {
+          include: queues,
+          ordered_queues: true,
+        }
       else
         { include: queues }
       end
@@ -95,10 +107,34 @@ module GoodJob
     scope :creation_ordered, -> { order('created_at ASC') }
 
     # Order jobs for de-queueing
-    # @!method dequeue_ordered
+    # @!method dequeueing_ordered
     # @!scope class
-    # @return [ActiveRecord:Relation]
-    scope :dequeue_ordered, -> { priority_ordered.creation_ordered }
+    # @param parsed_queues [Hash]
+    #   optional output of .queue_parser, parsed queues, will be used for
+    #   ordered queues.
+    # @return [ActiveRecord::Relation]
+    scope :dequeueing_ordered, (lambda do |parsed_queues|
+      relation = self
+      relation = relation.queue_ordered(parsed_queues[:include]) if parsed_queues && parsed_queues[:ordered_queues] && parsed_queues[:include]
+      relation = relation.priority_ordered.creation_ordered
+
+      relation
+    end)
+
+    # Order jobs in order of queues in array param
+    # @!method queue_ordered
+    # @!scope class
+    # @param queues [Array<string] ordered names of queues
+    # @return [ActiveRecord::Relation]
+    scope :queue_ordered, (lambda do |queues|
+      clauses = queues.map.with_index do |queue_name, index|
+        "WHEN queue_name = '#{queue_name}' THEN #{index}"
+      end
+
+      order(
+        Arel.sql("(CASE #{clauses.join(' ')} ELSE #{queues.length} END)")
+      )
+    end)
 
     # Order jobs by scheduled or created (oldest first).
     # @!method schedule_ordered
@@ -165,8 +201,8 @@ module GoodJob
     #   return value for the job's +#perform+ method, and the exception the job
     #   raised, if any (if the job raised, then the second array entry will be
     #   +nil+). If there were no jobs to execute, returns +nil+.
-    def self.perform_with_advisory_lock
-      unfinished.dequeue_ordered.only_scheduled.limit(1).with_advisory_lock(unlock_session: true) do |executions|
+    def self.perform_with_advisory_lock(parsed_queues: nil)
+      unfinished.dequeueing_ordered(parsed_queues).only_scheduled.limit(1).with_advisory_lock(unlock_session: true) do |executions|
         execution = executions.first
         break if execution.blank?
         break :unlocked unless execution&.executable?
@@ -277,40 +313,6 @@ module GoodJob
       end
     end
 
-    # There are 3 buckets of non-overlapping statuses:
-    #   1. The job will be executed
-    #     - queued: The job will execute immediately when an execution thread becomes available.
-    #     - scheduled: The job is scheduled to execute in the future.
-    #     - retried: The job previously errored on execution and will be re-executed in the future.
-    #   2. The job is being executed
-    #     - running: the job is actively being executed by an execution thread
-    #   3. The job will not execute
-    #     - finished: The job executed successfully
-    #     - discarded: The job previously errored on execution and will not be re-executed in the future.
-    #
-    # @return [Symbol]
-    def status
-      if finished_at.present?
-        if error.present? && retried_good_job_id.present?
-          :retried
-        elsif error.present? && retried_good_job_id.nil?
-          :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
-
     # Return formatted serialized_params for display in the dashboard
     # @return [Hash]
     def display_serialized_params
@@ -331,11 +333,6 @@ module GoodJob
       serialized_params.fetch('executions', 0) + 1
     end
 
-    # The last relevant timestamp for this execution
-    def last_status_at
-      finished_at || performed_at || scheduled_at || created_at
-    end
-
     # Time between when this job was expected to run and when it started running
     def queue_latency
       now = Time.zone.now

data/{lib → app}/models/good_job/job.rb

@@ -8,6 +8,7 @@ module GoodJob
   class Job < BaseRecord
     include Filterable
     include Lockable
+    include Reportable
 
     # Raised when an inappropriate action is applied to a Job based on its state.
     ActionForStateMismatchError = Class.new(StandardError)
@@ -27,7 +28,7 @@ module GoodJob
     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', inverse_of: :job
+    has_many :executions, -> { order(created_at: :asc) }, class_name: 'GoodJob::Execution', foreign_key: 'active_job_id', inverse_of: :job # rubocop:disable Rails/HasManyOrHasOneDependent
 
     # Only the most-recent unretried execution represents a "Job"
     default_scope { where(retried_good_job_id: nil) }
@@ -73,32 +74,6 @@ module GoodJob
       serialized_params['job_class']
     end
 
-    def last_status_at
-      finished_at || performed_at || scheduled_at || created_at
-    end
-
-    def status
-      if finished_at.present?
-        if error.present? && retried_good_job_id.present?
-          :retried
-        elsif error.present? && retried_good_job_id.nil?
-          :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
-
     # Override #reload to add a custom scope to ensure the reloaded record is the head execution
     # @return [Job]
     def reload(options = nil)

data/{lib → app}/models/good_job/process.rb

@@ -71,5 +71,9 @@ module GoodJob # :nodoc:
       destroy!
       advisory_unlock
     end
+
+    def basename
+      File.basename(state["proctitle"])
+    end
   end
 end