que 1.4.1 → 2.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f274711739c76ae8ec986e367c39eb3e39cadeefa5be57bb685b3b34f86e3f8
-  data.tar.gz: be68db2fe99b2156c68cdc7470ec536c3d5f0104eb908298dad77f9cb41acaf2
+  metadata.gz: 382ef488f1aa4e91e0ef2b617ad03bdfee4001020a71ef31662cd99e52e34915
+  data.tar.gz: 1d59264e766fd94aeeec463d7ea7f4cf76c867bc356df553f7d9e7a705095da6
 SHA512:
-  metadata.gz: abda6691442a612777c9dbe8ddd60678a106526a40f9b9293c3f66adc70eb66448b2dc42359a6adc1d7cf7b142c8950fcb65a8b14b1eabee33fa209607bc1520
-  data.tar.gz: 69884364862c515b7f317cb05ea3b7f8ce3f367e0266405fc5d1cbc61471a7f6e378f55eb0a271c62b82833a9f7d2feb27ec0fe433e28d9ee855bb7239ab4745
+  metadata.gz: 03b72732163fc9d24fe91a5dcbc18986c7dead94fe0a8d28e66727cf93739e9a47c4ab9f39239ff3776b63f24339c2266becc2b00bd1d45efc15f3a064580466
+  data.tar.gz: 87d9701463b8e3ac5a7ba62cd376e4508a856de0c69b04e7dcdaf7d481746552d4d4762026b70efe4a910b6a7de9243dc98eeb6e43d4e7fbc3d1065b0b6a941e

data/.github/workflows/tests.yml

@@ -7,11 +7,19 @@ jobs:
     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" }
+        ruby_version: ['2.7', '3.0', '3.1']
+        rails_gemfile: ['6.0', '6.1']
+        postgres_version: ['14']
+        include:
+        # Postgres versions
+        - { ruby_version: '3.1', rails_gemfile: '6.1', postgres_version: '9' }
+        - { ruby_version: '3.1', rails_gemfile: '6.1', postgres_version: '10' }
+        - { ruby_version: '3.1', rails_gemfile: '6.1', postgres_version: '11' }
+        - { ruby_version: '3.1', rails_gemfile: '6.1', postgres_version: '12' }
+        - { ruby_version: '3.1', rails_gemfile: '6.1', postgres_version: '13' }
+        - { ruby_version: '3.1', rails_gemfile: '6.1', postgres_version: '14' }
+        exclude: []
+    name: "Test: Ruby ${{ matrix.ruby_version }}, Rails ${{ matrix.rails_gemfile }}, PostgreSQL ${{ matrix.postgres_version }}"
     services:
       db:
         image: postgres:${{ matrix.postgres_version }}
@@ -24,16 +32,16 @@ jobs:
           --health-timeout 5s
           --health-retries 5
     steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v2
     - name: Set up Ruby
-      uses: actions/setup-ruby@v1
+      uses: ruby/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 }}
+        BUNDLE_GEMFILE: spec/gemfiles/Gemfile-rails-${{ matrix.rails_gemfile }}
       run: |
         sudo apt-get -yqq install libpq-dev postgresql-client
         createdb que-test

data/.ruby-version

@@ -0,0 +1 @@
+3.1.1

data/CHANGELOG.md

@@ -2,7 +2,7 @@
 
 <!-- MarkdownTOC autolink=true -->
 
-- [1.4.1 \(2022-07-24\)](#141-2022-07-24)
+- [2.0.0.beta1 \(2022-03-24\)](#200beta1-2022-03-24)
 - [1.4.0 \(2022-03-23\)](#140-2022-03-23)
 - [1.3.1 \(2022-02-25\)](#131-2022-02-25)
 - [1.3.0 \(2022-02-25\)](#130-2022-02-25)
@@ -52,10 +52,58 @@
 
 <!-- /MarkdownTOC -->
 
-## 1.4.1 (2022-07-24)
+## 2.0.0.beta1 (2022-03-24)
 
-- **Added**
-    + Added Ruby version requirement of < 3. For Ruby 3 compatibility, upgrade to Que 2 - [upgrade process](https://github.com/que-rb/que/blob/master/CHANGELOG.md#200beta1-2022-03-24)
+**Preliminary release of Ruby 3 support**
+
+**Notable changes**:
+
+* Support for Ruby 3 introduced
+* Database schema has changed to split the job arguments `args` column into `args` and `kwargs` columns, for reliable args and kwargs splitting for Ruby 3.
+    - The job schema version is now 2. Note that job schema version is distinct from database schema version and Que version. The `job_schema_version` column of the `que_jobs` table no longer defaults and has a not null constraint, so when manually inserting jobs into the table, this must be specified as `2`. If you have a gem that needs to support multiple Que versions, best not to blindly use the value of `Que.job_schema_version`; instead have different code paths depending on the value of `Que.job_schema_version`. You could also use this to know whether keyword arguments are in `args` or `kwargs`.
+* Passing a hash literal as the last job argument to be splatted into job keyword arguments is no longer supported.
+* Dropped support for providing job options as top-level keyword arguments to `Job.enqueue`, i.e. `queue`, `priority`, `run_at`, `job_class`, and `tags`. Job options now need to be nested under the `job_options` keyword argument instead. See [#336](https://github.com/que-rb/que/pull/336)
+* Dropped support for Ruby < 2.7
+* Dropped support for Rails < 6.0
+* The `#by_args` method on the Job model (for both Sequel and ActiveRecord) now searches based on both args and kwargs, but it performs a subset match instead of an exact match. For instance, if your job was scheduled with `'a', 'b', 'c', foo: 'bar', baz: 1`, `by_args('a', 'b', baz: 1)` would find and return the job.
+* This release contains a database migration. You will need to migrate Que to the latest database schema version (6). For example, on ActiveRecord and Rails 6:
+
+```ruby
+class UpdateQueTablesToVersion6 < ActiveRecord::Migration[6.0]
+  def up
+    Que.migrate!(version: 6)
+  end
+
+  def down
+    Que.migrate!(version: 5)
+  end
+end
+```
+
+**Recommended upgrade process**:
+
+When using Que 2.x, a job enqueued with Ruby 2.7 will run as expected on Ruby 3. We recommend:
+
+1. Upgrade your project to the latest 1.x version of Que (1.3.1+)
+    - IMPORTANT: adds support for zero downtime upgrade to Que 2.x, see changelog below
+2. Upgrade your project to Ruby 2.7 and Rails 6.x if it is not already
+3. Upgrade your project to Que 2.x but stay on Ruby 2.7
+    - IMPORTANT: You will need to continue to run Que 1.x workers until all jobs enqueued using Que 1.x (i.e. with a `job_schema_version` of `1`) have been finished. See below
+4. Upgrade your project to Ruby 3
+
+*NOTES:*
+
+* If you were already running Ruby 2.7 and were not passing a hash literal as the last job argument, you *may* be able to upgrade a running system without draining the queue, though this is not recommended.
+* For all other cases, you will need to follow the recommended process above or first completely drain the queue (stop enqueuing new jobs and finish processing any jobs in the database, including cleaning out any expired jobs) before upgrading.
+
+**Deploying Que 1.x and 2.x workers simultaneously**:
+
+To run workers with two different versions of Que, you'll probably need to temporarily duplicate your gem bundle, with the Que version being the only difference. e.g.:
+
+- Copy your `Gemfile` and `Gemfile.lock` into a directory called `que-1-gemfile`
+- Set a suitable Que version in each `Gemfile`
+- Update the bundle at `que-1-gemfile/Gemfile.lock` using `BUNDLE_GEMFILE=que-1-gemfile/Gemfile bundle`
+- Create a second deployment of Que, but with your `que` command prefixed with `BUNDLE_GEMFILE=que-1-gemfile/Gemfile`
 
 ## 1.4.0 (2022-03-23)
 
@@ -67,7 +115,7 @@
         * It became used in 1.0.0.beta4, and that changelog entry has been updated to reflect this.
 - **Documentation**:
     + Reformatted the changelog to be more consistent, including adding links to all issue/PR numbers. [#347](https://github.com/que-rb/que/pull/347)
-
+    + 
 ## 1.3.1 (2022-02-25)
 
 Unfortunately, v1.3.0 was broken. Follow its upgrade instructions, but use this version instead.

data/Dockerfile

@@ -1,4 +1,4 @@
-FROM ruby:2.7.5-slim-buster@sha256:4cbbe2fba099026b243200aa8663f56476950cc64ccd91d7aaccddca31e445b5 AS base
+FROM ruby:3.1.1-slim-buster@sha256:2ada3e4fe7b1703c9333ad4eb9fc12c1d4d60bce0f981281b2151057e928d9ad AS base
 
 # Install libpq-dev in our base layer, as it's needed in all environments
 RUN apt-get update \

data/README.md

@@ -1,6 +1,6 @@
 # Que ![tests](https://github.com/que-rb/que/workflows/tests/badge.svg)
 
-**This README and the rest of the docs on the master branch all refer to Que 1.0. 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).**
+**This README and the rest of the docs on the master branch all refer to Que 2.x. For older versions, please refer to the docs on the respective branches: [1.x](https://github.com/que-rb/que/tree/1.x), or [0.x](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.*
 
@@ -23,9 +23,9 @@ Que's secondary goal is performance. The worker process is multithreaded, so tha
 
 Compatibility:
 
-- MRI Ruby 2.2+, < 3 (for Ruby 3, Que 2+ is required)
+- MRI Ruby 2.7+
 - PostgreSQL 9.5+
-- Rails 4.1+ (optional)
+- Rails 6.0+ (optional)
 
 **Please note** - Que's job table undergoes a lot of churn when it is under high load, and like any heavily-written table, is susceptible to bloat and slowness if Postgres isn't able to clean it up. The most common cause of this is long-running transactions, so it's recommended to try to keep all transactions against the database housing Que's job table as short as possible. This is good advice to remember for any high-activity database, but bears emphasizing when using tables that undergo a lot of writes.
 
@@ -54,12 +54,12 @@ gem install que
 First, create the queue schema in a migration. For example:
 
 ```ruby
-class CreateQueSchema < ActiveRecord::Migration[5.0]
+class CreateQueSchema < ActiveRecord::Migration[6.0]
   def up
     # Whenever you use Que in a migration, always specify the version you're
     # migrating to. If you're unsure what the current version is, check the
     # changelog.
-    Que.migrate!(version: 5)
+    Que.migrate!(version: 6)
   end
 
   def down
@@ -117,10 +117,10 @@ end
 You can also add options to run the job after a specific time, or with a specific priority:
 
 ```ruby
-ChargeCreditCard.enqueue card.id, user_id: current_user.id, run_at: 1.day.from_now, priority: 5
+ChargeCreditCard.enqueue(card.id, user_id: current_user.id, job_options: { 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. 
+In order to process jobs, you must start a separate worker process outside of your main server.
 
 ```bash
 bundle exec que
@@ -142,7 +142,7 @@ You may need to pass que a file path to require so that it can load your app. Qu
 
 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:
+Pre-1.0, the default queue name needed to be configured in order for Que to work out of the box with Rails. As of 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`:
 

data/bin/command_line_interface.rb

@@ -220,7 +220,7 @@ OUTPUT
 
         locker =
           begin
-            Que::Locker.new(options)
+            Que::Locker.new(**options)
           rescue => e
             output.puts(e.message)
             return 1

data/docker-compose.yml

@@ -10,13 +10,14 @@ services:
       - db
     volumes:
       - .:/work
-      - ruby-2.7.5-gem-cache:/usr/local/bundle
+      - ruby-3.1.1-gem-cache:/usr/local/bundle
       - ~/.docker-rc.d/:/.docker-rc.d/:ro
     working_dir: /work
     entrypoint: /work/scripts/docker-entrypoint
     command: bash
     environment:
       DATABASE_URL: postgres://que:que@db/que-test
+      USE_RAILS: ~
 
   db:
     image: "postgres:${POSTGRES_VERSION-13}"
@@ -43,4 +44,4 @@ services:
 
 volumes:
   db-data: ~
-  ruby-2.7.5-gem-cache: ~
+  ruby-3.1.1-gem-cache: ~

data/docs/README.md

@@ -128,8 +128,8 @@ There are other docs to read if you're using [Sequel](#using-sequel) or [plain P
 After you've connected Que to the database, you can manage the jobs table. You'll want to migrate to a specific version in a migration file, to ensure that they work the same way even when you upgrade Que in the future:
 
 ```ruby
-# Update the schema to version #5.
-Que.migrate!(version: 5)
+# Update the schema to version #6.
+Que.migrate!(version: 6)
 
 # Remove Que's jobs table entirely.
 Que.migrate!(version: 0)
@@ -441,7 +441,7 @@ que -q default -q credit_cards
 Then you can set jobs to be enqueued in that queue specifically:
 
 ```ruby
-ProcessCreditCard.enqueue current_user.id, queue: 'credit_cards'
+ProcessCreditCard.enqueue(current_user.id, job_options: { queue: 'credit_cards' })
 
 # Or:
 
@@ -455,7 +455,7 @@ end
 In some cases, the ProcessCreditCard class may not be defined in the application that is enqueueing the job. In that case, you can specify the job class as a string:
 
 ```ruby
-Que.enqueue current_user.id, job_class: 'ProcessCreditCard', queue: 'credit_cards'
+Que.enqueue(current_user.id, job_options: { job_class: 'ProcessCreditCard', queue: 'credit_cards' })
 ```
 
 ## Shutting Down Safely
@@ -549,7 +549,7 @@ require 'que'
 Sequel.migration do
   up do
     Que.connection = self
-    Que.migrate!(version: 5)
+    Que.migrate!(version: 6)
   end
   down do
     Que.connection = self
@@ -585,7 +585,7 @@ Sequel automatically wraps model persistance actions (create, update, destroy) i
 
 ## Using Que With ActiveJob
 
-You can include `Que::ActiveJob::JobExtensions` into your `ApplicationJob` subclass to get support for all of Que's 
+You can include `Que::ActiveJob::JobExtensions` into your `ApplicationJob` subclass to get support for all of Que's
 [helper methods](#job-helper-methods). These methods will become no-ops if you use a queue adapter that isn't Que, so if you like to use a different adapter in development they shouldn't interfere.
 
 Additionally, including `Que::ActiveJob::JobExtensions` lets you define a run() method that supports keyword arguments.

data/lib/que/active_job/extensions.rb

@@ -12,8 +12,10 @@ module Que
       end
 
       def perform(*args)
+        args, kwargs = Que.split_out_ruby2_keywords(args)
+
         Que.internal_log(:active_job_perform, self) do
-          {args: args}
+          {args: args, kwargs: kwargs}
         end
 
         _run(
@@ -21,7 +23,12 @@ module Que
             que_filter_args(
               args.map { |a| a.is_a?(Hash) ? a.deep_symbolize_keys : a }
             )
-          )
+          ),
+          kwargs: Que.recursively_freeze(
+            que_filter_args(
+              kwargs.deep_symbolize_keys,
+            )
+          ),
         )
       end
 
@@ -53,37 +60,46 @@ module Que
     # A module that we mix into ActiveJob's wrapper for Que::Job, to maintain
     # backwards-compatibility with internal changes we make.
     module WrapperExtensions
-      # The Rails adapter (built against a pre-1.0 version of this gem)
-      # assumes that it can access a job's id via job.attrs["job_id"]. So,
-      # oblige it.
-      def attrs
-        {"job_id" => que_attrs[:id]}
+      module ClassMethods
+        # We've dropped support for job options supplied as top-level keywords, but ActiveJob's QueAdapter still uses them. So we have to move them into the job_options hash ourselves.
+        def enqueue(args, priority:, queue:, run_at: nil)
+          super(args, job_options: { priority: priority, queue: queue, run_at: run_at })
+        end
       end
 
-      def run(args)
-        # Our ActiveJob extensions expect to be able to operate on the actual
-        # job object, but there's no way to access it through ActiveJob. So,
-        # scope it to the current thread. It's a bit messy, but it's the best
-        # option under the circumstances (doesn't require hacking ActiveJob in
-        # any more extensive way).
+      module InstanceMethods
+        # The Rails adapter (built against a pre-1.0 version of this gem)
+        # assumes that it can access a job's id via job.attrs["job_id"]. So,
+        # oblige it.
+        def attrs
+          {"job_id" => que_attrs[:id]}
+        end
+
+        def run(args)
+          # Our ActiveJob extensions expect to be able to operate on the actual
+          # job object, but there's no way to access it through ActiveJob. So,
+          # scope it to the current thread. It's a bit messy, but it's the best
+          # option under the circumstances (doesn't require hacking ActiveJob in
+          # any more extensive way).
 
-        # There's no reason this logic should ever nest, because it wouldn't
-        # make sense to run a worker inside of a job, but even so, assert that
-        # nothing absurd is going on.
-        Que.assert NilClass, Thread.current[:que_current_job]
+          # There's no reason this logic should ever nest, because it wouldn't
+          # make sense to run a worker inside of a job, but even so, assert that
+          # nothing absurd is going on.
+          Que.assert NilClass, Thread.current[:que_current_job]
 
-        begin
-          Thread.current[:que_current_job] = self
+          begin
+            Thread.current[:que_current_job] = self
 
-          # We symbolize the args hash but ActiveJob doesn't like that :/
-          super(args.deep_stringify_keys)
-        ensure
-          # Also assert that the current job state was only removed now, but
-          # unset the job first so that an assertion failure doesn't mess up
-          # the state any more than it already has.
-          current = Thread.current[:que_current_job]
-          Thread.current[:que_current_job] = nil
-          Que.assert(self, current)
+            # We symbolize the args hash but ActiveJob doesn't like that :/
+            super(args.deep_stringify_keys)
+          ensure
+            # Also assert that the current job state was only removed now, but
+            # unset the job first so that an assertion failure doesn't mess up
+            # the state any more than it already has.
+            current = Thread.current[:que_current_job]
+            Thread.current[:que_current_job] = nil
+            Que.assert(self, current)
+          end
         end
       end
     end
@@ -92,6 +108,7 @@ end
 
 class ActiveJob::QueueAdapters::QueAdapter
   class JobWrapper < Que::Job
-    prepend Que::ActiveJob::WrapperExtensions
+    extend Que::ActiveJob::WrapperExtensions::ClassMethods
+    prepend Que::ActiveJob::WrapperExtensions::InstanceMethods
   end
 end

data/lib/que/active_record/model.rb

@@ -39,8 +39,8 @@ module Que
           where("que_jobs.data @> ?", JSON.dump(tags: [tag]))
         end
 
-        def by_args(*args)
-          where("que_jobs.args @> ?", JSON.dump(args))
+        def by_args(*args, **kwargs)
+          where("que_jobs.args @> ? AND que_jobs.kwargs @> ?", JSON.dump(args), JSON.dump(kwargs))
         end
       end
     end

data/lib/que/job.rb

@@ -12,7 +12,7 @@ module Que
     SQL[:insert_job] =
       %{
         INSERT INTO public.que_jobs
-        (queue, priority, run_at, job_class, args, data, job_schema_version)
+        (queue, priority, run_at, job_class, args, kwargs, data, job_schema_version)
         VALUES
         (
           coalesce($1, 'default')::text,
@@ -21,6 +21,7 @@ module Que
           $4::text,
           coalesce($5, '[]')::jsonb,
           coalesce($6, '{}')::jsonb,
+          coalesce($7, '{}')::jsonb,
           #{Que.job_schema_version}
         )
         RETURNING *
@@ -56,13 +57,10 @@ module Que
         :priority,
         :run_at
 
-      def enqueue(
-        *args,
-        job_options: {},
-        **arg_opts
-      )
-        arg_opts, job_options = _extract_job_options(arg_opts, job_options.dup)
-        args << arg_opts if arg_opts.any?
+      def enqueue(*args)
+        args, kwargs = Que.split_out_ruby2_keywords(args)
+
+        job_options = kwargs.delete(:job_options) || {}
 
         if job_options[:tags]
           if job_options[:tags].length > MAXIMUM_TAGS_COUNT
@@ -81,6 +79,7 @@ module Que
           priority: job_options[:priority] || resolve_que_setting(:priority),
           run_at:   job_options[:run_at]   || resolve_que_setting(:run_at),
           args:     Que.serialize_json(args),
+          kwargs:   Que.serialize_json(kwargs),
           data:     job_options[:tags] ? Que.serialize_json(tags: job_options[:tags]) : "{}",
           job_class: \
             job_options[:job_class] || name ||
@@ -89,27 +88,31 @@ module Que
 
         if attrs[:run_at].nil? && resolve_que_setting(:run_synchronously)
           attrs[:args] = Que.deserialize_json(attrs[:args])
+          attrs[:kwargs] = Que.deserialize_json(attrs[:kwargs])
           attrs[:data] = Que.deserialize_json(attrs[:data])
           _run_attrs(attrs)
         else
           values =
             Que.execute(
               :insert_job,
-              attrs.values_at(:queue, :priority, :run_at, :job_class, :args, :data),
+              attrs.values_at(:queue, :priority, :run_at, :job_class, :args, :kwargs, :data),
             ).first
-
           new(values)
         end
       end
+      ruby2_keywords(:enqueue) if respond_to?(:ruby2_keywords, true)
 
       def run(*args)
         # Make sure things behave the same as they would have with a round-trip
         # to the DB.
+        args, kwargs = Que.split_out_ruby2_keywords(args)
         args = Que.deserialize_json(Que.serialize_json(args))
+        kwargs = Que.deserialize_json(Que.serialize_json(kwargs))
 
         # Should not fail if there's no DB connection.
-        _run_attrs(args: args)
+        _run_attrs(args: args, kwargs: kwargs)
       end
+      ruby2_keywords(:run) if respond_to?(:ruby2_keywords, true)
 
       def resolve_que_setting(setting, *args)
         value = send(setting) if respond_to?(setting)
@@ -136,27 +139,6 @@ module Que
           end
         end
       end
-
-      def _extract_job_options(arg_opts, job_options)
-        deprecated_job_option_names = []
-
-        %i[queue priority run_at job_class tags].each do |option_name|
-          next unless arg_opts.key?(option_name) && job_options[option_name].nil?
-
-          job_options[option_name] = arg_opts.delete(option_name)
-          deprecated_job_option_names << option_name
-        end
-
-        _log_job_options_deprecation(deprecated_job_option_names)
-
-        [arg_opts, job_options]
-      end
-
-      def _log_job_options_deprecation(deprecated_job_option_names)
-        return unless deprecated_job_option_names.any?
-
-        warn "Passing job options like (#{deprecated_job_option_names.join(', ')}) to `JobClass.enqueue` as top level keyword args has been deprecated and will be removed in version 2.0. Please wrap job options in an explicit `job_options` keyword arg instead."
-      end
     end
 
     # Set up some defaults.

data/lib/que/job_methods.rb

@@ -39,12 +39,16 @@ module Que
     # Run the job with error handling and cleanup logic. Optionally support
     # overriding the args, because it's necessary when jobs are invoked from
     # ActiveJob.
-    def _run(args: nil, reraise_errors: false)
+    def _run(args: nil, kwargs: nil, reraise_errors: false)
       if args.nil? && que_target
         args = que_target.que_attrs.fetch(:args)
       end
 
-      run(*args)
+      if kwargs.nil? && que_target
+        kwargs = que_target.que_attrs.fetch(:kwargs)
+      end
+
+      run(*args, **kwargs)
       default_resolve_action if que_target && !que_target.que_resolved
     rescue => error
       raise error unless que_target

data/lib/que/migrations/6/down.sql

@@ -0,0 +1,8 @@
+DROP INDEX que_jobs_kwargs_gin_idx;
+ALTER TABLE que_jobs DROP COLUMN kwargs;
+
+ALTER INDEX que_poll_idx RENAME TO que_poll_idx_with_job_schema_version;
+CREATE INDEX que_poll_idx ON que_jobs (queue, priority, run_at, id) WHERE (finished_at IS NULL AND expired_at IS NULL);
+
+ALTER TABLE que_jobs ALTER COLUMN job_schema_version SET DEFAULT 1;
+ALTER TABLE que_jobs ALTER COLUMN job_schema_version DROP NOT NULL;

data/lib/que/migrations/6/up.sql

@@ -0,0 +1,8 @@
+ALTER TABLE que_jobs ADD COLUMN kwargs JSONB NOT NULL DEFAULT '{}';
+CREATE INDEX que_jobs_kwargs_gin_idx ON que_jobs USING gin (kwargs jsonb_path_ops);
+
+DROP INDEX que_poll_idx;
+ALTER INDEX que_poll_idx_with_job_schema_version RENAME TO que_poll_idx;
+
+ALTER TABLE que_jobs ALTER COLUMN job_schema_version DROP DEFAULT;
+ALTER TABLE que_jobs ALTER COLUMN job_schema_version SET NOT NULL;

data/lib/que/migrations.rb

@@ -4,7 +4,7 @@ module Que
   module Migrations
     # In order to ship a schema change, add the relevant up and down sql files
     # to the migrations directory, and bump the version here.
-    CURRENT_VERSION = 5
+    CURRENT_VERSION = 6
 
     class << self
       def migrate!(version:)

data/lib/que/sequel/model.rb

@@ -40,8 +40,11 @@ module Que
           where(QUALIFIED_TABLE[:data].pg_jsonb.contains(JSON.dump(tags: [tag])))
         end
 
-        def by_args(*args)
-          where(QUALIFIED_TABLE[:args].pg_jsonb.contains(JSON.dump(args)))
+        def by_args(*args, **kwargs)
+          where(
+            QUALIFIED_TABLE[:args].pg_jsonb.contains(JSON.dump(args)) &
+            QUALIFIED_TABLE[:kwargs].pg_jsonb.contains(JSON.dump(kwargs))
+          ) 
         end
       end
     end

data/lib/que/utils/ruby2_keywords.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Temporary module allowing ruby2 keyword args to be extracted from an *args splat
+# Allows us to ensure consistent behaviour when running on ruby 2 vs ruby 3
+# We can remove this if/when we drop support for ruby 2
+
+require 'json'
+
+module Que
+  module Utils
+    module Ruby2Keywords
+      def split_out_ruby2_keywords(args)
+        return [args, {}] unless args.last&.is_a?(Hash) && Hash.ruby2_keywords_hash?(args.last)
+
+        [args[0..-2], args.last]
+      end
+    end
+  end
+end

data/lib/que/version.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 module Que
-  VERSION = '1.4.1'
+  VERSION = '2.0.0.beta1'
 
   def self.job_schema_version
-    1
+    2
   end
 end

data/lib/que/worker.rb

@@ -125,7 +125,7 @@ module Que
           log_message[:event] = :job_worked
         end
 
-        Que.log(log_message)
+        Que.log(**log_message)
       end
 
       instance

data/lib/que.rb

@@ -29,6 +29,7 @@ module Que
   require_relative 'que/utils/logging'
   require_relative 'que/utils/middleware'
   require_relative 'que/utils/queue_management'
+  require_relative 'que/utils/ruby2_keywords'
   require_relative 'que/utils/transactions'
 
   require_relative 'que/version'
@@ -61,6 +62,7 @@ module Que
     include Utils::Logging
     include Utils::Middleware
     include Utils::QueueManagement
+    include Utils::Ruby2Keywords
     include Utils::Transactions
 
     extend Forwardable

data/que.gemspec

@@ -13,7 +13,7 @@ Gem::Specification.new do |spec|
   spec.homepage      = 'https://github.com/que-rb/que'
   spec.license       = 'MIT'
 
-  spec.required_ruby_version = '< 3'
+  spec.required_ruby_version = '>= 2.7.0'
 
   files_to_exclude = [
     /\A\.circleci/,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: que
 version: !ruby/object:Gem::Version
-  version: 1.4.1
+  version: 2.0.0.beta1
 platform: ruby
 authors:
 - Chris Hanks
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-07-24 00:00:00.000000000 Z
+date: 2022-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -34,6 +34,7 @@ extra_rdoc_files: []
 files:
 - ".github/workflows/tests.yml"
 - ".gitignore"
+- ".ruby-version"
 - CHANGELOG.md
 - Dockerfile
 - LICENSE.txt
@@ -71,6 +72,8 @@ files:
 - lib/que/migrations/4/up.sql
 - lib/que/migrations/5/down.sql
 - lib/que/migrations/5/up.sql
+- lib/que/migrations/6/down.sql
+- lib/que/migrations/6/up.sql
 - lib/que/poller.rb
 - lib/que/rails/railtie.rb
 - lib/que/result_queue.rb
@@ -84,6 +87,7 @@ files:
 - lib/que/utils/logging.rb
 - lib/que/utils/middleware.rb
 - lib/que/utils/queue_management.rb
+- lib/que/utils/ruby2_keywords.rb
 - lib/que/utils/transactions.rb
 - lib/que/version.rb
 - lib/que/worker.rb
@@ -100,16 +104,16 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - "<"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '3'
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: A PostgreSQL-based Job Queue