que 1.0.0.beta → 1.0.0.beta5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 9bbd70fe386be02949156458e095b91fc7af2001
-  data.tar.gz: d7029485d2eb220cad37d8b41ca8021a6089e934
+SHA256:
+  metadata.gz: 90ae5c7c65d93f4ea3833d80351c2e0d3ed3f706ba00411937e8aba2137a41d7
+  data.tar.gz: 58aba934ee2735522e602dd5777de666c6acbee1cb531d9918ce6f2b75f3b693
 SHA512:
-  metadata.gz: 94f36a7474bf38f0a06839f4ce7afc904bb855e828aff90891ccdfbf87f77e017bd823f3b92ed0bbce3ade75b931d4158c70ee1df3fd4d52d48554a8f7e2c74e
-  data.tar.gz: e90625eb0de12115e779cd2f497db6b4348e26736959f6c4d7b8bd40b58b51c9b086c6f8acaf4569f31b120733648e6bb84cfe6a52dc1628167efead9a016250
+  metadata.gz: 1cbfa5f3c6d13868897ac9f1fcf079aaeaa29c9eadfd231044a484878fbf8e99f4b159a4458690027b181b29c5da3abafcc1c9de2d33b3c487b1fac4a15c7e50
+  data.tar.gz: 1ed4b71f51cd72e3968de6ec745e2de592dc021e9d334526630b3011d3f5526388b8562da4bf513066cb68d4dee033043115027ddfc0e9bef5e816ed2c35ede5

data/.github/workflows/tests.yml

@@ -0,0 +1,43 @@
+name: tests
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby_version: [2.5.x, 2.6.x, 2.7.x]
+        gemfile: ["4.2", "5.2", "6.0"]
+        postgres_version: [9, 10, 11, 12]
+        exclude:
+          - { gemfile: "4.2", ruby_version: "2.7.x" }
+    services:
+      db:
+        image: postgres:${{ matrix.postgres_version }}
+        env:
+          POSTGRES_HOST_AUTH_METHOD: trust
+        ports: ['5432:5432']
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+    steps:
+    - uses: actions/checkout@v1
+    - name: Set up Ruby
+      uses: actions/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby_version }}
+    - name: Test with Rake
+      env:
+        PGHOST: 127.0.0.1
+        PGUSER: postgres
+        BUNDLE_GEMFILE: spec/gemfiles/Gemfile.${{ matrix.gemfile }}
+      run: |
+        sudo apt-get -yqq install libpq-dev postgresql-client
+        createdb que-test
+        gem install bundler
+        bundle install --jobs 4 --retry 3
+        USE_RAILS=true bundle exec rake test
+        bundle exec rake test

data/CHANGELOG.1.0.beta.md

@@ -0,0 +1,137 @@
+### 1.0.0.beta3 (2018-05-18)
+
+*   Added support for customizing log levels for `job_worked` events (#217).
+
+*   Began logging all `job_errored` events at the `ERROR` log level.
+
+*   Fixed the Railtie when running in test mode (#214).
+
+*   Tweaked the meanings of worker-priorities and worker-count options in the CLI, to better support use cases with low worker counts (#216).
+
+### 1.0.0.beta2 (2018-04-13)
+
+*   Fixed an incompatibility that caused the new locker to hang when using Rails in development mode (#213).
+
+*   Fixed a bug with setting the log level via the CLI when the configured logger was based on a callable (#210).
+
+*   Renamed Que.middleware to Que.job_middleware.
+
+*   Added Que.sql_middleware.
+
+*   Officially added support for Ruby 2.5.
+
+*   Internal cleanup and renamings.
+
+### 1.0.0.beta (2017-10-25)
+
+*   **A schema upgrade to version 4 will be required for this release.** See [the migration doc](https://github.com/que-rb/que/blob/master/docs/migrating.md) for information if you're upgrading from a previous release.
+
+    *   Please note that this migration requires a rewrite of the jobs table, which makes it O(n) with the size of the table. If you have a very large backlog of jobs you may want to schedule downtime for this migration.
+
+*   Que's implementation has been changed from one in which worker threads hold their own PG connections and lock their own jobs to one in which a single thread (and PG connection) locks jobs through LISTEN/NOTIFY and batch polling, and passes jobs along to worker threads. This has many benefits, including:
+
+    *   Jobs queued for immediate processing can be actively distributed to workers with LISTEN/NOTIFY, which is more efficient than having workers repeatedly poll for new jobs.
+
+    *   When polling is necessary (to pick up jobs that are scheduled for the future or that need to be retried due to errors), jobs can be locked and fetched in batches, rather than one at a time.
+
+    *   Individual workers no longer need to monopolize their own (usually idle) connections while working jobs, so Ruby processes will require fewer Postgres connections.
+
+    *   PgBouncer or another external connection pool can be used for workers' connections (though not for the connection used to lock and listen for jobs).
+
+*   Other features introduced in this version include:
+
+    *   Much better support for all versions of ActiveJob.
+
+        *   In particular, you may (optionally) include `Que::ActiveJob::JobExtensions` into `ApplicationJob` to get support for all of Que's job helper methods.
+
+    *   Custom middleware that wrap running jobs are now supported.
+
+    *   Support for categorizing jobs with tags.
+
+    *   Support for configuring a `maximum_retry_count` on individual job classes.
+
+    *   Job configuration options are now inheritable, so job class hierarchies are more useful.
+
+    *   There are now built-in models for ActiveRecord and Sequel to allow inspecting the queue easily.
+
+    *   Jobs that have finished working may optionally be retained in the database indefinitely.
+
+        *   To keep a job record, replace the `destroy` calls in your jobs with `finish`. `destroy` will still delete records entirely, for jobs that you don't want to keep.
+
+        *   If you don't resolve a job yourself one way or another, Que will still `destroy` the job for you by default.
+
+        *   Finished jobs have a timestamp set in the finished_at column.
+
+    *   Jobs that have errored too many times will now be marked as expired, and won't be retried again.
+
+        *   You can configure a maximum_retry_count in your job classes, to set the threshold at which a job will be marked expired. The default is 15.
+
+        *   To manually mark a job as expired (and keep it in the database but not try to run it again) you can call `expire` helper in your job.
+
+    *   You can now set job priority thresholds for individual workers, to ensure that there will always be space available for high-priority jobs.
+
+    *   `Que.job_states` returns a list of locked jobs and the hostname/pid of the Ruby processes that have locked them.
+
+    *   `Que.connection_proc=` has been added, to allow for the easy integration of custom connection pools.
+
+*   In keeping with semantic versioning, the major version is being bumped since the new implementation requires some backwards-incompatible changes. These changes include:
+
+    *   Support for MRI Rubies before 2.2 has been dropped.
+
+    *   Support for Postgres versions before 9.5 has been dropped (JSONB and upsert support is required).
+
+    *   JRuby support has been dropped. It will be reintroduced whenever the jruby-pg gem is production-ready.
+
+    *   The `que:work` rake task has been removed. Use the `que` executable instead.
+
+        *   Therefore, configuring workers using QUE_* environment variables is no longer supported. Please pass the appropriate options to the `que` executable instead.
+
+    *   The `mode` setter has been removed.
+
+        *   To run jobs synchronously when they are enqueued (the old `:sync` behavior) you can set `Que.run_synchronously = true`.
+
+        *   To start up the worker pool (the old :async behavior) you should use the `que` executable to start up a worker process. There's no longer a supported API for running workers outside of the `que` executable.
+
+    *   The following methods are not meaningful under the new implementation and have been removed:
+
+        *   The `Que.wake_interval` getter and setter.
+
+        *   The `Que.worker_count` getter and setter.
+
+        *   `Que.wake!`
+
+        *   `Que.wake_all!`
+
+    *   Since Que needs a dedicated Postgres connection to manage job locks, running Que through a single PG connection is no longer supported.
+
+        *   It's not clear that anyone ever actually did this.
+
+    *   `Que.worker_states` has been removed, as the connection that locks a job is no longer the one that the job is using to run. Its functionality has been partially replaced with `Que.job_states`.
+
+    *   When using Rails, for simplicity, job attributes and keys in argument hashes are now converted to symbols when retrieved from the database, rather than being converted to instances of HashWithIndifferentAccess.
+
+    *   Arguments passed to jobs are now deep-frozen, to prevent unexpected behavior when the args are mutated and the job is reenqueued.
+
+    *   Since JSONB is now used to store arguments, the order of argument hashes is no longer maintained.
+
+        *   It wouldn't have been a good idea to rely on this anyway.
+
+    *   Calling Que.log() directly is no longer supported/recommended.
+
+    *   Features marked as deprecated in the final 0.x releases have been removed.
+
+*   Finally, if you've built up your own tooling and customizations around Que, you may need to be aware of some DB schema changes made in the migration to schema version #4.
+
+    *   The `job_id` column has been renamed `id` and is now the primary key. This makes it easier to manage the queue using an ActiveRecord model.
+
+    *   Finished jobs are now kept in the DB, unless you explicitly call `destroy`. If you want to query the DB for only jobs that haven't finished yet, add a `WHERE finished_at IS NULL` condition to your query, or use the not_finished scope on one of the provided ORM models.
+
+    *   There is now an `expired_at` timestamp column, which is set when a job reaches its maximum number of retries and will not be attempted again.
+
+    *   Due to popular demand, the default queue name is now "default" rather than an empty string. The migration will move pending jobs under the "" queue to the "default" queue.
+
+    *   The `last_error` column has been split in two, to `last_error_message` and `last_error_backtrace`. These two columns are now limited to 500 and 10,000 characters, respectively. The migration will split old error data correctly, and truncate it if necessary.
+
+    *   Names for queues and job classes are now limited to 500 characters, which is still far longer than either of these values should reasonably be.
+
+    *   There is now a `data` JSONB column which is used to support various ways of organizing jobs (setting tags on them, etc).

data/CHANGELOG.md

@@ -1,6 +1,6 @@
-### 1.0.0.beta (2017-10-25)
+### 1.0.0.beta2 (2018-04-13)
 
-*   **A schema upgrade to version 4 will be required for this release.** See [the migration doc](https://github.com/chanks/que/blob/master/docs/migrating.md) for information if you're upgrading from a previous release.
+*   **A schema upgrade to version 4 will be required for this release.** See [the migration doc](https://github.com/que-rb/que/blob/master/docs/migrating.md) for information if you're upgrading from a previous release.
 
     *   Please note that this migration requires a rewrite of the jobs table, which makes it O(n) with the size of the table. If you have a very large backlog of jobs you may want to schedule downtime for this migration.
 
@@ -20,7 +20,7 @@
 
         *   In particular, you may (optionally) include `Que::ActiveJob::JobExtensions` into `ApplicationJob` to get support for all of Que's job helper methods.
 
-    *   Custom middleware that wrap running jobs are now supported.
+    *   Custom middleware that wrap running jobs and executing SQL statements are now supported.
 
     *   Support for categorizing jobs with tags.
 
@@ -68,11 +68,7 @@
 
         *   To start up the worker pool (the old :async behavior) you should use the `que` executable to start up a worker process. There's no longer a supported API for running workers outside of the `que` executable.
 
-    *   The way Que uses prepared statements internally has changed. This shouldn't affect anyone's use of Que, except that the `disable_prepared_statements` configuration option is no longer necessary and has been removed.
-
-        *   Specifically, while Que previously used prepared statements for most of its built-in queries, now only the polling query uses it, due to its complexity. Since the polling query is only run through a dedicated connection, it's no longer possible for prepared statements to conflict with external connection pools, which was the reason that `disable_prepared_statements` was supported in the first place.
-
-    *   In addition to `Que.disable_prepared_statements=`, the following methods are not meaningful under the new implementation and have been removed:
+    *   The following methods are not meaningful under the new implementation and have been removed:
 
         *   The `Que.wake_interval` getter and setter.
 
@@ -116,6 +112,32 @@
 
     *   There is now a `data` JSONB column which is used to support various ways of organizing jobs (setting tags on them, etc).
 
+For a detailed list of the changes between each beta release of 1.0.0, see [the beta Changelog](CHANGELOG.1.0.beta.md).
+
+### 0.14.3 (2018-03-02)
+
+*   Recorded errors now always include the error class, so that empty error messages can still be helpful. (  joehorsnell)
+
+*   Recorded error messages are now truncated to the first 500 characters.
+
+### 0.14.2 (2018-01-05)
+
+*   Deprecate the Que.disable_prepared_statements= accessors.
+
+*   Add Que.use_prepared_statements= configuration accessors.
+
+*   Update the generated Rails migration to declare a version. (NARKOZ)
+
+### 0.14.1 (2017-12-14)
+
+*   Fix a bug with typecasting boolean values on Rails 5+.
+
+### 0.14.0 (2017-08-11)
+
+*   Fix incompatibility with Rails 5.1.
+
+*   Drop support for waking an in-process worker when an ActiveRecord transaction commits.
+
 ### 0.13.1 (2017-07-05)
 
 *   Fix issue that caused error stacktraces to not be persisted in most cases.
@@ -250,7 +272,7 @@
 
 ### 0.6.0 (2014-02-04)
 
-*   **A schema upgrade to version 3 is required for this release.** See [the migration doc](https://github.com/chanks/que/blob/master/docs/migrating.md) for information if you're upgrading from a previous release.
+*   **A schema upgrade to version 3 is required for this release.** See [the migration doc](https://github.com/que-rb/que/blob/master/docs/migrating.md) for information if you're upgrading from a previous release.
 
 *   You can now run a job's logic directly (without enqueueing it) like `MyJob.run(arg1, arg2, other_arg: arg3)`. This is useful when a job class encapsulates logic that you want to invoke without involving the entire queue.
 
@@ -262,11 +284,11 @@
 
 *   Log lines now include the machine's hostname, since a pid alone may not uniquely identify a process.
 
-*   Multiple queues are now supported. See [the docs](https://github.com/chanks/que/blob/master/docs/multiple_queues.md) for details. (chanks, joevandyk)
+*   Multiple queues are now supported. See [the docs](https://github.com/que-rb/que/blob/master/docs/multiple_queues.md) for details. (chanks, joevandyk)
 
 *   Rubinius 2.2 is now supported. (brixen)
 
-*   Job classes may now define their own logic for determining the retry interval when a job raises an error. See [error handling](https://github.com/chanks/que/blob/master/docs/error_handling.md) for more information.
+*   Job classes may now define their own logic for determining the retry interval when a job raises an error. See [error handling](https://github.com/que-rb/que/blob/master/docs/error_handling.md) for more information.
 
 ### 0.5.0 (2014-01-14)
 
@@ -280,7 +302,7 @@
 
 *   Added a migration system to make it easier to change the schema when updating Que. You can now write, for example, `Que.migrate!(version: 2)` in your migrations. Migrations are run transactionally.
 
-*   The logging format has changed to be more easily machine-readable. You can also now customize the logging format by assigning a callable to Que.log_formatter=. See the new doc on [logging](https://github.com/chanks/que/blob/master/docs/logging.md)) for details. The default logger level is INFO - for less critical information (such as when no jobs were found to be available or when a job-lock race condition has been detected and avoided) you can set the QUE_LOG_LEVEL environment variable to DEBUG.
+*   The logging format has changed to be more easily machine-readable. You can also now customize the logging format by assigning a callable to Que.log_formatter=. See the new doc on [logging](https://github.com/que-rb/que/blob/master/docs/logging.md)) for details. The default logger level is INFO - for less critical information (such as when no jobs were found to be available or when a job-lock race condition has been detected and avoided) you can set the QUE_LOG_LEVEL environment variable to DEBUG.
 
 *   MultiJson is now a soft dependency. Que will use it if it is available, but it is not required.
 

data/README.md

@@ -1,6 +1,8 @@
-# Que
+# Que ![tests](https://github.com/que-rb/que/workflows/tests/badge.svg)
 
-**TL;DR: Que is a high-performance job queue that improves the reliability of your application by protecting your jobs with the same [ACID guarantees](https://en.wikipedia.org/wiki/ACID) as the rest of your data.**
+**This README and the rest of the docs on the master branch all refer to Que 1.0, which is currently in beta. If you're using version 0.x, please refer to the docs on [the 0.x branch](https://github.com/que-rb/que/tree/0.x).**
+
+*TL;DR: Que is a high-performance job queue that improves the reliability of your application by protecting your jobs with the same [ACID guarantees](https://en.wikipedia.org/wiki/ACID) as the rest of your data.*
 
 Que ("keɪ", or "kay") is a queue for Ruby and PostgreSQL that manages jobs using [advisory locks](http://www.postgresql.org/docs/current/static/explicit-locking.html#ADVISORY-LOCKS), which gives it several advantages over other RDBMS-backed queues:
 
@@ -15,7 +17,7 @@ Additionally, there are the general benefits of storing jobs in Postgres, alongs
   * **Fewer Dependencies** - If you're already using Postgres (and you probably should be), a separate queue is another moving part that can break.
   * **Security** - Postgres' support for SSL connections keeps your data safe in transport, for added protection when you're running workers on cloud platforms that you can't completely control.
 
-Que's primary goal is reliability. You should be able to leave your application running indefinitely without worrying about jobs being lost due to a lack of transactional support, or left in limbo due to a crashing process. Que does everything it can to ensure that jobs you queue are performed exactly once (though the occasional repetition of a job can be impossible to avoid - see the docs on [how to write a reliable job](https://github.com/chanks/que/blob/master/docs/writing_reliable_jobs.md)).
+Que's primary goal is reliability. You should be able to leave your application running indefinitely without worrying about jobs being lost due to a lack of transactional support, or left in limbo due to a crashing process. Que does everything it can to ensure that jobs you queue are performed exactly once (though the occasional repetition of a job can be impossible to avoid - see the docs on [how to write a reliable job](/docs/README.md#writing-reliable-jobs)).
 
 Que's secondary goal is performance. The worker process is multithreaded, so that a single process can run many jobs simultaneously.
 
@@ -112,23 +114,81 @@ You can also add options to run the job after a specific time, or with a specifi
 ``` ruby
 ChargeCreditCard.enqueue card.id, user_id: current_user.id, run_at: 1.day.from_now, priority: 5
 ```
+## Running the Que Worker
+In order to process jobs, you must start a separate worker process outside of your main server. 
+
+```
+bundle exec que
+```
+
+Try running `que -h` to get a list of runtime options:
+```
+$ que -h
+usage: que [options] [file/to/require] ...
+    -h, --help                       Show this help text.
+    -i, --poll-interval [INTERVAL]   Set maximum interval between polls for available jobs, in seconds (default: 5)
+    ...
+```
+
+You may need to pass que a file path to require so that it can load your app. Que will automatically load `config/environment.rb` if it exists, so you shouldn't need an argument if you're using Rails.
+
+## Additional Rails-specific Setup
+
+If you're using ActiveRecord to dump your database's schema, please [set your schema_format to :sql](http://guides.rubyonrails.org/migrations.html#types-of-schema-dumps) so that Que's table structure is managed correctly. This is a good idea regardless, as the `:ruby` schema format doesn't support many of PostgreSQL's advanced features.
+
+Pre-1.0, the default queue name needed to be configured in order for Que to work out of the box with Rails. In 1.0 the default queue name is now 'default', as Rails expects, but when Rails enqueues some types of jobs it may try to use another queue name that isn't worked by default. You can either:
+
+* [Configure Rails](https://guides.rubyonrails.org/configuring.html) to send all internal job types to the 'default' queue by adding the following to `config/application.rb`:
+```ruby
+config.action_mailer.deliver_later_queue_name = :default
+config.action_mailbox.queues.incineration = :default
+config.action_mailbox.queues.routing = :default
+config.active_storage.queues.analysis = :default
+config.active_storage.queues.purge = :default
+```
+
+* [Tell que](/docs#multiple-queues) to work all of these queues (less efficient because it requires polling all of them):
+```
+que -q default -q mailers -q action_mailbox_incineration -q action_mailbox_routing -q active_storage_analysis -q active_storage_purge
+```
+
+Also, if you would like to integrate Que with Active Job, you can do it by setting the adapter in `config/application.rb` or in a specific environment by setting it in `config/environments/production.rb`, for example:
+```ruby
+config.active_job.queue_adapter = :que
+```
+
+Que will automatically use the database configuration of your rails application, so there is no need to configure anything else.
+
+You can then write your jobs as usual following the [Active Job documentation](https://guides.rubyonrails.org/active_job_basics.html). However, be aware that you'll lose the ability to finish the job in the same transaction as other database operations. That happens because Active Job is a generic background job framework that doesn't benefit from the database integration Que provides.
+
+If you later decide to switch a job from Active Job to Que to have transactional integrity you can easily change the corresponding job class to inherit from `Que::Job` and follow the usage guidelines in the previous section.
 
 ## Testing
 
 There are a couple ways to do testing. You may want to set `Que::Job.run_synchronously = true`, which will cause JobClass.enqueue to simply execute the job's logic synchronously, as if you'd run JobClass.run(*your_args). Or, you may want to leave it disabled so you can assert on the job state once they are stored in the database.
 
-**If you're using ActiveRecord to dump your database's schema, please [set your schema_format to :sql](http://guides.rubyonrails.org/migrations.html#types-of-schema-dumps) so that Que's table structure is managed correctly.** This is a good idea regardless, as the `:ruby` schema format doesn't support many of PostgreSQL's advanced features.
+## Documentation
+
+**For full documentation, see [here](docs/README.md)**.
+
+## Related Projects
 
+These projects are tested to be compatible with Que 1.x:
+
+- [que-web](https://github.com/statianzo/que-web) is a Sinatra-based UI for inspecting your job queue.
+- [que-scheduler](https://github.com/hlascelles/que-scheduler) lets you schedule tasks using a cron style config file.
+- [que-locks](https://github.com/airhorns/que-locks) lets you lock around job execution for so only one job runs at once for a set of arguments.
+
+If you have a project that uses or relates to Que, feel free to submit a PR adding it to the list!
 
 ## Community and Contributing
 
-  * For bugs in the library, please feel free to [open an issue](https://github.com/chanks/que/issues/new).
-  * For general discussion and questions/concerns that don't relate to obvious bugs, try posting on the [que-talk Google Group](https://groups.google.com/forum/#!forum/que-talk).
+  * For bugs in the library, please feel free to [open an issue](https://github.com/que-rb/que/issues/new).
+  * For general discussion and questions/concerns that don't relate to obvious bugs, join our [Discord Server](https://discord.gg/B3EW32H).
   * For contributions, pull requests submitted via Github are welcome.
 
 Regarding contributions, one of the project's priorities is to keep Que as simple, lightweight and dependency-free as possible, and pull requests that change too much or wouldn't be useful to the majority of Que's users have a good chance of being rejected. If you're thinking of submitting a pull request that adds a new feature, consider starting a discussion in [que-talk](https://groups.google.com/forum/#!forum/que-talk) first about what it would do and how it would be implemented. If it's a sufficiently large feature, or if most of Que's users wouldn't find it useful, it may be best implemented as a standalone gem, like some of the related projects above.
 
-
 ### Specs
 
 A note on running specs - Que's worker system is multithreaded and therefore prone to race conditions. As such, if you've touched that code, a single spec run passing isn't a guarantee that any changes you've made haven't introduced bugs. One thing I like to do before pushing changes is rerun the specs many times and watching for hangs. You can do this from the command line with something like:

data/bin/command_line_interface.rb

@@ -18,12 +18,14 @@ module Que
         default_require_file: RAILS_ENVIRONMENT_FILE
       )
 
-        options        = {}
-        queues         = []
-        log_level      = 'info'
-        log_internals  = false
-        poll_interval  = 5
-        connection_url = nil
+        options           = {}
+        queues            = []
+        log_level         = 'info'
+        log_internals     = false
+        poll_interval     = 5
+        connection_url    = nil
+        worker_count      = nil
+        worker_priorities = nil
 
         parser =
           OptionParser.new do |opts|
@@ -58,6 +60,26 @@ module Que
               log_level = l
             end
 
+            opts.on(
+              '-p',
+              '--worker-priorities [LIST]',
+              Array,
+              "List of priorities to assign to workers (default: 10,30,50,any,any,any)",
+            ) do |priority_array|
+              worker_priorities =
+                priority_array.map do |p|
+                  case p
+                  when /\Aany\z/i
+                    nil
+                  when /\A\d+\z/
+                    Integer(p)
+                  else
+                    output.puts "Invalid priority option: '#{p}'. Please use an integer or the word 'any'."
+                    return 1
+                  end
+                end
+            end
+
             opts.on(
               '-q',
               '--queue-name [NAME]',
@@ -69,6 +91,15 @@ module Que
               queues << queue_name
             end
 
+            opts.on(
+              '-w',
+              '--worker-count [COUNT]',
+              Integer,
+              "Set number of workers in process (default: 6)",
+            ) do |w|
+              worker_count = w
+            end
+
             opts.on(
               '-v',
               '--version',
@@ -79,21 +110,12 @@ module Que
               return 0
             end
 
-            opts.on(
-              '-w',
-              '--worker-count [COUNT]',
-              Integer,
-              "Set number of workers in process (default: 6)",
-            ) do |w|
-              options[:worker_count] = w
-            end
-
             opts.on(
               '--connection-url [URL]',
               String,
               "Set a custom database url to connect to for locking purposes.",
             ) do |url|
-              connection_url = url
+              options[:connection_url] = url
             end
 
             opts.on(
@@ -107,19 +129,19 @@ module Que
             opts.on(
               '--maximum-buffer-size [SIZE]',
               Integer,
-              "Set maximum number of jobs to be cached in this process " \
-                "awaiting a worker (default: 8)",
+              "Set maximum number of jobs to be locked and held in this " \
+                "process awaiting a worker (default: 8)",
             ) do |s|
-              options[:maximum_queue_size] = s
+              options[:maximum_buffer_size] = s
             end
 
             opts.on(
               '--minimum-buffer-size [SIZE]',
               Integer,
-              "Set minimum number of jobs to be cached in this process " \
-                "awaiting a worker (default: 2)",
+              "Set minimum number of jobs to be locked and held in this " \
+                "process awaiting a worker (default: 2)",
             ) do |s|
-              options[:minimum_queue_size] = s
+              options[:minimum_buffer_size] = s
             end
 
             opts.on(
@@ -130,19 +152,21 @@ module Que
             ) do |p|
               options[:wait_period] = p
             end
-
-            opts.on(
-              '--worker-priorities [LIST]',
-              Array,
-              "List of priorities to assign to workers, " \
-                "unspecified workers take jobs of any priority (default: 10,30,50)",
-            ) do |p|
-              options[:worker_priorities] = p.map(&:to_i)
-            end
           end
 
         parser.parse!(args)
 
+        options[:worker_priorities] =
+          if worker_count && worker_priorities
+            worker_priorities.values_at(0...worker_count)
+          elsif worker_priorities
+            worker_priorities
+          elsif worker_count
+            Array.new(worker_count) { nil }
+          else
+            [10, 30, 50, nil, nil, nil]
+          end
+
         if args.length.zero?
           if File.exist?(default_require_file)
             args << default_require_file
@@ -159,8 +183,8 @@ OUTPUT
         args.each do |file|
           begin
             require file
-          rescue LoadError
-            output.puts "Could not load file '#{file}'"
+          rescue LoadError => e
+            output.puts "Could not load file '#{file}': #{e}"
             return 1
           end
         end
@@ -172,7 +196,7 @@ OUTPUT
         end
 
         begin
-          Que.logger.level = Logger.const_get(log_level.upcase)
+          Que.get_logger.level = Logger.const_get(log_level.upcase)
         rescue NameError
           output.puts "Unsupported logging level: #{log_level} (try debug, info, warn, error, or fatal)"
           return 1
@@ -195,19 +219,6 @@ OUTPUT
 
         options[:poll_interval] = poll_interval
 
-        if connection_url
-          uri = URI.parse(connection_url)
-
-          options[:connection] =
-            PG::Connection.open(
-              host:     uri.host,
-              user:     uri.user,
-              password: uri.password,
-              port:     uri.port || 5432,
-              dbname:   uri.path[1..-1],
-            )
-        end
-
         locker =
           begin
             Que::Locker.new(options)
@@ -221,13 +232,14 @@ OUTPUT
         $stop_que_executable = false
         %w[INT TERM].each { |signal| trap(signal) { $stop_que_executable = true } }
 
+        output.puts "Que waiting for jobs..."
+
         loop do
           sleep 0.01
           break if $stop_que_executable || locker.stopping?
         end
 
-        output.puts ''
-        output.puts "Finishing Que's current jobs before exiting..."
+        output.puts "\nFinishing Que's current jobs before exiting..."
 
         locker.stop!