queue_classic_plus 1.1.0 → 4.0.0.alpha8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88536cc93e084fd7a3921cbd10ab31843882e42eef8979222528ed550ea18033
-  data.tar.gz: c2b1ae63963c66c44d2c86e33441edd2ca90b03800cb76528e477205afc652a4
+  metadata.gz: 69af5e1cbbcc08c7cd0acad4c0f06e112a9fff09756a06c9ae2ffd80a71ab39a
+  data.tar.gz: cd3cc486050b9de66397099f81e0277aac83f5469bb925456527b331dec85a6a
 SHA512:
-  metadata.gz: 6cbadb6208bcb150fdf50bc6122ed99811cd7b92b0f336b337c57f03b8196a384b8e14b40ea6b67ef95d862771a266c62d2f892d8da49a6ff17b1e643281ec44
-  data.tar.gz: 3d2c44a3bb10a5a7c59cd8a22164e57074515ef221ce467a9fe6017d644ca6e14e0d23c0412b4fcb0eef52381e3bf21ecfc0fc327ed516958e051865bc7961c8
+  metadata.gz: 8d3980cb5a576ff5681812a2e5d7497c35ff98dc84934778f4dd3c867643e10e9d87a38499bad6850cc72d1c4cd519a91a2509011f8ad916e78b10be3c2e076e
+  data.tar.gz: c31d0baa284b76731b268e29ab21b3ae0e679f7404345d3b449fb755a34df11100d6f6790a6f9e0dfb373ed908a8fa365575d88184f96d28a079270be5e67605

data/.circleci/config.yml

@@ -0,0 +1,67 @@
+version: 2.1
+
+jobs:
+  test:
+    docker:
+      - image: circleci/ruby:2.7.4-node
+        auth:
+          username: $DOCKERHUB_USERNAME
+          password: $DOCKERHUB_TOKEN
+        environment:
+          DATABASE_URL: postgres://circleci:circleci@127.0.0.1:5432/queue_classic_plus_test
+      - image: circleci/postgres:9.6.6-alpine
+        auth:
+          username: $DOCKERHUB_USERNAME
+          password: $DOCKERHUB_TOKEN
+        environment:
+          POSTGRES_USER: circleci
+          POSTGRES_PASSWORD: circleci
+          POSTGRES_DB: queue_classic_plus_test
+    steps:
+      - checkout
+      - run:
+          name: run tests
+          command: |
+            bundle check --path=vendor/bundle || bundle install --path=vendor/bundle --jobs=4 --retry=3
+            bundle exec rspec
+
+  push_to_rubygems:
+    docker:
+      - image: circleci/ruby:2.7.4
+        auth:
+          username: $DOCKERHUB_USERNAME
+          password: $DOCKERHUB_TOKEN
+    steps:
+      - checkout
+      - run:
+          name: Create .gem/credentials file
+          command: |
+            mkdir ~/.gem
+            echo "---
+              :rubygems_api_key: $RUBYGEMS_API_KEY
+            " > ~/.gem/credentials
+            chmod 600 ~/.gem/credentials
+      - run:
+          name: Release to rubygems
+          command: |
+            gem build queue_classic_plus
+            gem push queue_classic_plus-*.gem
+
+workflows:
+  version: 2
+  gem_release:
+    jobs:
+      - test:
+          context:
+            - DockerHub
+
+      - push_to_rubygems:
+          filters:
+            branches:
+              ignore:
+                - /.*/
+            tags:
+              only:
+                - /^v.*/
+          context:
+            - DockerHub

data/.github/dependabot.yml

@@ -0,0 +1,8 @@
+version: 2
+updates:
+- package-ecosystem: bundler
+  directory: "/"
+  schedule:
+    interval: daily
+    time: "13:00"
+  open-pull-requests-limit: 10

data/.gitignore

@@ -1,6 +1,7 @@
 *.gem
 *.rbc
 .bundle
+.byebug_history
 .config
 .yardoc
 Gemfile.lock
@@ -9,6 +10,7 @@ _yardoc
 coverage
 doc/
 lib/bundler/man
+log/
 pkg
 rdoc
 spec/reports

data/Gemfile

@@ -12,8 +12,10 @@ group :development do
 end
 
 group :test do
+  gem 'byebug'
   gem 'rake'
   gem 'rspec'
   gem 'timecop'
   gem 'newrelic_rpm'
+  gem 'ddtrace'
 end

data/README.md

@@ -1,6 +1,6 @@
 # QueueClassicPlus
 
-[![Build Status](https://travis-ci.org/rainforestapp/queue_classic_plus.svg?branch=master)](https://travis-ci.org/rainforestapp/queue_classic_plus)
+[![rainforestapp](https://circleci.com/gh/rainforestapp/queue_classic_plus.svg?branch=master)](https://app.circleci.com/pipelines/github/rainforestapp/queue_classic_plus?branch=master)
 
 [queue_classic](https://github.com/QueueClassic/queue_classic) is a simple Postgresql backed DB queue. However, it's a little too simple to use it as the main queueing system of a medium to large app. This was developed at [Rainforest QA](https://www.rainforestqa.com/).
 
@@ -130,7 +130,7 @@ If you want to log exceptions in your favorite exception tracker. You can config
 
 ```ruby
 QueueClassicPlus.exception_handler = -> (exception, job) do
-  Raven.capture_exception(exception, extra: {job: job, env: ENV})
+  Sentry.capture_exception(exception, extra: { job: job, env: ENV })
 end
 ```
 
@@ -150,6 +150,12 @@ If you are using NewRelic and want to push performance data to it, you can add t
 require "queue_classic_plus/new_relic"
 ```
 
+To instrument DataDog monitoring add this to your QC initializer:
+
+```ruby
+require "queue_classic_plus/datadog"
+```
+
 ## Contributing
 
 1. Fork it ( https://github.com/[my-github-username]/queue_classic_plus/fork )

data/lib/queue_classic_plus/base.rb

@@ -67,7 +67,7 @@ module QueueClassicPlus
                )
              AS x"
 
-        result = QC.default_conn_adapter.execute(q, @queue, method, args.to_json)
+        result = QC.default_conn_adapter.execute(q, @queue, method, JSON.dump(serialized(args)))
         result['count'].to_i == 0
       else
         true
@@ -76,7 +76,7 @@ module QueueClassicPlus
 
     def self.enqueue(method, *args)
       if can_enqueue?(method, *args)
-        queue.enqueue(method, *args)
+        queue.enqueue(method, *serialized(args))
       end
     end
 
@@ -86,11 +86,11 @@ module QueueClassicPlus
 
     def self.enqueue_perform_in(time, *args)
       raise "Can't enqueue in the future for locked jobs" if locked?
-      queue.enqueue_in(time, "#{self.to_s}._perform", *args)
+      queue.enqueue_in(time, "#{self.to_s}._perform", *serialized(args))
     end
 
     def self.restart_in(time, remaining_retries, *args)
-      queue.enqueue_retry_in(time, "#{self.to_s}._perform", remaining_retries, *args)
+      queue.enqueue_retry_in(time, "#{self.to_s}._perform", remaining_retries, *serialized(args))
     end
 
     def self.do(*args)
@@ -102,13 +102,13 @@ module QueueClassicPlus
     def self._perform(*args)
       Metrics.timing("qu_perform_time", source: librato_key) do
         if skip_transaction
-          perform(*args)
+          perform(*deserialized(args))
         else
           transaction do
             # .to_i defaults to 0, which means no timeout in postgres
             timeout = ENV['POSTGRES_STATEMENT_TIMEOUT'].to_i * 1000
             execute "SET LOCAL statement_timeout = #{timeout}"
-            perform(*args)
+            perform(*deserialized(args))
           end
         end
       end
@@ -119,7 +119,7 @@ module QueueClassicPlus
     end
 
     def self.transaction(options = {}, &block)
-      if defined?(ActiveRecord)
+      if defined?(ActiveRecord) && ActiveRecord::Base.connected?
         # If ActiveRecord is loaded, we use it's own transaction mechanisn since
         # it has slightly different semanctics for rollback.
         ActiveRecord::Base.transaction(options, &block)
@@ -142,7 +142,26 @@ module QueueClassicPlus
       execute q
     end
 
+    protected
+
+    def self.serialized(args)
+      if defined?(Rails)
+        ActiveJob::Arguments.serialize(args)
+      else
+        args
+      end
+    end
+
+    def self.deserialized(args)
+      if defined?(Rails)
+        ActiveJob::Arguments.deserialize(args)
+      else
+        args
+      end
+    end
+
     private
+
     def self.execute(sql, *args)
       QC.default_conn_adapter.execute(sql, *args)
     end

data/lib/queue_classic_plus/datadog.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module QueueClassicDatadog
+  def _perform(*args)
+    Datadog.tracer.trace('qc.job', service_name: 'qc.job', resource: "#{name}#perform") do |_|
+      super
+    end
+  end
+
+  QueueClassicPlus::Base.singleton_class.send(:prepend, QueueClassicDatadog)
+end

data/lib/queue_classic_plus/queue_classic/queue.rb

@@ -3,7 +3,7 @@ module QC
 
     def enqueue_retry_in(seconds, method, remaining_retries, *args)
       QC.log_yield(:measure => 'queue.enqueue') do
-        s = "INSERT INTO #{TABLE_NAME} (q_name, method, args, scheduled_at, remaining_retries)
+        s = "INSERT INTO #{QC.table_name} (q_name, method, args, scheduled_at, remaining_retries)
              VALUES ($1, $2, $3, now() + interval '#{seconds.to_i} seconds', $4)"
 
         conn_adapter.execute(s, name, method, JSON.dump(args), remaining_retries)
@@ -12,16 +12,36 @@ module QC
 
     def lock
       QC.log_yield(:measure => 'queue.lock') do
-        s = "SELECT * FROM lock_head($1, $2)"
-        if r = conn_adapter.execute(s, name, top_bound)
+        s = <<~SQL
+          WITH selected_job AS (
+            SELECT id
+            FROM queue_classic_jobs
+            WHERE
+              locked_at IS NULL AND
+              q_name = $1 AND
+              scheduled_at <= now()
+            LIMIT 1
+            FOR NO KEY UPDATE SKIP LOCKED
+          )
+          UPDATE queue_classic_jobs
+          SET
+            locked_at = now(),
+            locked_by = pg_backend_pid()
+          FROM selected_job
+          WHERE queue_classic_jobs.id = selected_job.id
+          RETURNING *
+        SQL
+
+        if r = conn_adapter.execute(s, name)
           {}.tap do |job|
             job[:id] = r["id"]
             job[:q_name] = r["q_name"]
             job[:method] = r["method"]
             job[:args] = JSON.parse(r["args"])
-            job[:remaining_retries] = r["remaining_retries"]
+            job[:remaining_retries] = r["remaining_retries"]&.to_s
             if r["scheduled_at"]
-              job[:scheduled_at] = Time.parse(r["scheduled_at"])
+              # ActiveSupport may cast time strings to Time
+              job[:scheduled_at] = r["scheduled_at"].kind_of?(Time) ? r["scheduled_at"] : Time.parse(r["scheduled_at"])
               ttl = Integer((Time.now - job[:scheduled_at]) * 1000)
               QC.measure("time-to-lock=#{ttl}ms source=#{name}")
             end

data/lib/queue_classic_plus/tasks/work.rake

@@ -3,10 +3,15 @@ namespace :qc_plus do
   task :work  => :environment do
     puts "Starting up worker for queue #{ENV['QUEUE']}"
 
-    if defined? Raven
+    # ActiveRecord::RecordNotFound is ignored by Sentry by default,
+    # which shouldn't happen in background jobs.
+    if defined?(Sentry)
+      Sentry.init do |config|
+        config.excluded_exceptions = []
+        config.background_worker_threads = 0 if Gem::Version.new(Sentry::VERSION) >= Gem::Version.new('4.1.0')
+      end
+    elsif defined?(Raven)
       Raven.configure do |config|
-        # ActiveRecord::RecordNotFound is ignored by Raven by default,
-        # which shouldn't happen in background jobs.
         config.excluded_exceptions = []
       end
     end

data/lib/queue_classic_plus/version.rb

@@ -1,3 +1,3 @@
 module QueueClassicPlus
-  VERSION = "1.1.0"
+  VERSION = '4.0.0.alpha8'.freeze
 end

data/lib/queue_classic_plus/worker.rb

@@ -25,6 +25,7 @@ module QueueClassicPlus
       end
 
       @failed_job = job
+      @failed_job_args = failed_job_class ? failed_job_class.deserialized(job[:args]) : job[:args]
 
       if force_retry && !(failed_job_class.respond_to?(:disable_retries) && failed_job_class.disable_retries)
         Metrics.increment("qc.force_retry", source: @q_name)
@@ -44,7 +45,7 @@ module QueueClassicPlus
 
     def retry_with_remaining(e)
       if remaining_retries > 0
-        failed_job_class.restart_in(backoff, remaining_retries - 1, *@failed_job[:args])
+        failed_job_class.restart_in(backoff, remaining_retries - 1, *@failed_job_args)
       else
         enqueue_failed(e)
       end
@@ -77,9 +78,9 @@ module QueueClassicPlus
     end
 
     def enqueue_failed(e)
-      sql = "INSERT INTO #{QC::TABLE_NAME} (q_name, method, args, last_error) VALUES ('failed_jobs', $1, $2, $3)"
+      sql = "INSERT INTO #{QC.table_name} (q_name, method, args, last_error) VALUES ('failed_jobs', $1, $2, $3)"
       last_error = e.backtrace ? ([e.message] + e.backtrace ).join("\n") : e.message
-      QC.default_conn_adapter.execute sql, @failed_job[:method], JSON.dump(@failed_job[:args]), last_error
+      QC.default_conn_adapter.execute sql, @failed_job[:method], JSON.dump(@failed_job_args), last_error
 
       QueueClassicPlus.exception_handler.call(e, @failed_job)
       Metrics.increment("qc.errors", source: @q_name)

data/lib/queue_classic_plus.rb

@@ -14,13 +14,13 @@ module QueueClassicPlus
   require 'queue_classic_plus/railtie' if defined?(Rails)
 
   def self.migrate(c = QC::default_conn_adapter.connection)
-    conn = QC::ConnAdapter.new(c)
+    conn = QC::ConnAdapter.new(connection: c)
     conn.execute("ALTER TABLE queue_classic_jobs ADD COLUMN last_error TEXT")
     conn.execute("ALTER TABLE queue_classic_jobs ADD COLUMN remaining_retries INTEGER")
   end
 
   def self.demigrate(c = QC::default_conn_adapter.connection)
-    conn = QC::ConnAdapter.new(c)
+    conn = QC::ConnAdapter.new(connection: c)
     conn.execute("ALTER TABLE queue_classic_jobs DROP COLUMN last_error")
     conn.execute("ALTER TABLE queue_classic_jobs DROP COLUMN remaining_retries")
   end

data/queue_classic_plus.gemspec

@@ -18,11 +18,13 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "queue_classic", ">= 3.1.0"
+  spec.add_dependency "queue_classic", "4.0.0.pre.alpha1"
   if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.3.0')
     spec.add_development_dependency "bundler", "~> 1.6"
   else
     spec.add_development_dependency "bundler", "~> 2.0"
   end
   spec.add_development_dependency "rake"
+  spec.add_development_dependency "activerecord", "~> 6.0"
+  spec.add_development_dependency "activejob"
 end

data/spec/base_spec.rb

@@ -12,7 +12,19 @@ describe QueueClassicPlus::Base do
       it "does not allow multiple enqueues" do
         subject.do
         subject.do
-        subject.should have_queue_size_of(1)
+        expect(subject).to have_queue_size_of(1)
+      end
+
+      it "checks for an existing job using the same serializing as job enqueuing" do
+        # simulate a case where obj#to_json and JSON.dump(obj) do not match
+        require 'active_support/core_ext/date_time'
+        require 'active_support/json'
+        ActiveSupport::JSON::Encoding.use_standard_json_time_format = false
+
+        date = DateTime.new(2020, 11, 3)
+        subject.do(date)
+        subject.do(date)
+        expect(subject).to have_queue_size_of(1)
       end
 
       it "does allow multiple enqueues if something got locked for too long" do
@@ -20,7 +32,7 @@ describe QueueClassicPlus::Base do
         one_day_ago = Time.now - 60*60*24
         execute "UPDATE queue_classic_jobs SET locked_at = '#{one_day_ago}' WHERE q_name = 'test'"
         subject.do
-        subject.should have_queue_size_of(2)
+        expect(subject).to have_queue_size_of(2)
       end
     end
 
@@ -39,13 +51,15 @@ describe QueueClassicPlus::Base do
       end
 
       it "calls perform in a transaction" do
-        QueueClassicPlus::Base.should_receive(:transaction).and_call_original
+        expect(QueueClassicPlus::Base).to receive(:transaction).and_call_original
+
         subject._perform
       end
 
       it "measures the time" do
-        QueueClassicPlus::Metrics.should_receive(:timing).with("qu_perform_time", {source: "funky.name"}).and_call_original
-        subject._perform 
+        expect(QueueClassicPlus::Metrics).to receive(:timing).with("qu_perform_time", {source: "funky.name"}).and_call_original
+
+        subject._perform
       end
     end
 
@@ -61,7 +75,8 @@ describe QueueClassicPlus::Base do
       end
 
       it "calls perform outside of a transaction" do
-        QueueClassicPlus::Base.should_not_receive(:transaction)
+        expect(QueueClassicPlus::Base).to_not receive(:transaction)
+
         subject._perform
       end
     end
@@ -79,15 +94,15 @@ describe QueueClassicPlus::Base do
       end
 
       it "retries on specified exception" do
-        subject.retries_on?(SomeException.new).should be(true)
+        expect(subject.retries_on?(SomeException.new)).to be(true)
       end
 
       it "does not retry on unspecified exceptions" do
-        subject.retries_on?(RuntimeError).should be(false)
+        expect(subject.retries_on?(RuntimeError)).to be(false)
       end
 
       it "sets max retries" do
-        subject.max_retries.should == 5
+        expect(subject.max_retries).to eq(5)
       end
     end
 
@@ -104,16 +119,16 @@ describe QueueClassicPlus::Base do
       end
 
       it "retries on all specified exceptions" do
-        subject.retries_on?(SomeException.new).should be(true)
-        subject.retries_on?(SomeOtherException.new).should be(true)
+        expect(subject.retries_on?(SomeException.new)).to be(true)
+        expect(subject.retries_on?(SomeOtherException.new)).to be(true)
       end
 
       it "does not retry on unspecified exceptions" do
-        subject.retries_on?(RuntimeError).should be(false)
+        expect(subject.retries_on?(RuntimeError)).to be(false)
       end
 
       it "sets max retries" do
-        subject.max_retries.should == 5
+        expect(subject.max_retries).to eq(5)
       end
     end
 
@@ -133,22 +148,49 @@ describe QueueClassicPlus::Base do
       end
 
       it "retries on a subclass of a specified exception" do
-        subject.retries_on?(ServiceReallyUnavailable.new).should be(true)
+        expect(subject.retries_on?(ServiceReallyUnavailable.new)).to be(true)
       end
 
       it "does not retry on unspecified exceptions" do
-        subject.retries_on?(RuntimeError).should be(false)
+        expect(subject.retries_on?(RuntimeError)).to be(false)
       end
 
       it "sets max retries" do
-        subject.max_retries.should == 5
+        expect(subject.max_retries).to eq(5)
+      end
+    end
+
+    context "with Rails defined" do
+      require 'active_job/arguments'
+
+      before { stub_const('Rails', true) }
+
+      subject do
+        Class.new(QueueClassicPlus::Base) do
+          @queue = :test
+
+          def self.perform(foo, bar)
+          end
+        end
+      end
+
+      it "serializes parameters when enqueuing a job" do
+        expect(ActiveJob::Arguments).to receive(:serialize).with([42, true])
+
+        subject.do(42, true)
+      end
+
+      it "deserializes parameters when performing an enqueued job" do
+        expect(ActiveJob::Arguments).to receive(:deserialize).with([42, true]) { [42, true] }
+
+        subject._perform(42, true)
       end
     end
   end
 
   describe ".librato_key" do
     it "removes unsupported caracter from the classname" do
-      Jobs::Tests::TestJob.librato_key.should == 'jobs.tests.test_job'
+      expect(Jobs::Tests::TestJob.librato_key).to eq('jobs.tests.test_job')
     end
   end
 end

data/spec/datadog_spec.rb

@@ -0,0 +1,18 @@
+describe 'requiring queue_classic_plus/new_relic' do
+  class FunkyName < QueueClassicPlus::Base
+    @queue = :test
+
+    def self.perform
+    end
+  end
+
+  subject { FunkyName._perform }
+
+  it 'adds Datadog profiling support' do
+    require 'queue_classic_plus/datadog'
+    expect(Datadog.tracer).to receive(:trace).with(
+      'qc.job', service_name: 'qc.job', resource: 'FunkyName#perform'
+    )
+    subject
+  end
+end

data/spec/helpers.rb

@@ -4,6 +4,6 @@ module QcHelpers
   end
 
   def find_job(id)
-    execute("SELECT * FROM #{QC::TABLE_NAME} WHERE id = $1", id)
+    execute("SELECT * FROM #{QC.table_name} WHERE id = $1", id)
   end
 end

data/spec/queue_classic/queue_spec.rb

@@ -1,12 +1,23 @@
 require 'spec_helper'
+require 'active_record'
 
 describe QC do
-
   describe ".lock" do
+    context "with a connection from ActiveRecord that casts return types" do
+      before do
+        @old_conn_adapter = QC.default_conn_adapter
+        @activerecord_conn = ActiveRecord::Base.establish_connection(ENV["DATABASE_URL"])
+        QC.default_conn_adapter = QC::ConnAdapter.new(
+          connection: ActiveRecord::Base.connection.raw_connection
+        )
+      end
 
-    context "lock" do
+      after do
+        @activerecord_conn.disconnect!
+        QC.default_conn_adapter = @old_conn_adapter
+      end
 
-      it "should lock the job with remaining_retries" do
+      it "locks the job with remaining_retries" do
         QC.enqueue_retry_in(1, "puts", 5, 2)
         sleep 1
         job = QC.lock
@@ -18,6 +29,15 @@ describe QC do
       end
     end
 
-  end
+    it "locks the job with remaining_retries" do
+      QC.enqueue_retry_in(1, "puts", 5, 2)
+      sleep 1
+      job = QC.lock
 
+      expect(job[:q_name]).to eq("default")
+      expect(job[:method]).to eq("puts")
+      expect(job[:args][0]).to be(2)
+      expect(job[:remaining_retries]).to eq("5")
+    end
+  end
 end

data/spec/sample_jobs.rb

@@ -14,7 +14,7 @@ module Jobs
       @queue = :low
       retry! on: SomeException, max: 5
 
-      def self.perform should_raise
+      def self.perform(should_raise)
         raise SomeException if should_raise
       end
     end
@@ -27,7 +27,7 @@ module Jobs
 
       @queue = :low
 
-      def self.perform should_raise
+      def self.perform(should_raise)
         raise Custom if should_raise
       end
     end
@@ -37,7 +37,7 @@ module Jobs
       @queue = :low
       retry! on: SomeException, max: 1
 
-      def self.perform should_raise
+      def self.perform(should_raise)
         raise SomeException if should_raise
       end
     end

data/spec/spec_helper.rb

@@ -4,8 +4,11 @@ require 'timecop'
 require 'queue_classic_matchers'
 require_relative './sample_jobs'
 require_relative './helpers'
+require 'byebug'
 require 'pry'
+require 'ddtrace'
 
+ENV["QC_RAILS_DATABASE"] ||= "false" # test on QC::ConnAdapter by default
 ENV["DATABASE_URL"] ||= "postgres:///queue_classic_plus_test"
 
 RSpec.configure do |config|
@@ -20,5 +23,7 @@ RSpec.configure do |config|
 
   config.before(:each) do
     QC.default_conn_adapter.execute "TRUNCATE queue_classic_jobs;"
+    # Reset the default (memoized) queue instance between specs
+    QC.default_queue = nil
   end
 end

data/spec/worker_spec.rb

@@ -9,22 +9,22 @@ describe QueueClassicPlus::CustomWorker do
 
     it "record failures in the failed queue" do
       queue.enqueue("Kerklfadsjflaksj", 1, 2, 3)
-      failed_queue.count.should == 0
+      expect(failed_queue.count).to eq(0)
       worker.work
-      failed_queue.count.should == 1
+      expect(failed_queue.count).to eq(1)
       job = failed_queue.lock
-      job[:method].should == "Kerklfadsjflaksj"
-      job[:args].should == [1, 2, 3]
+      expect(job[:method]).to eq("Kerklfadsjflaksj")
+      expect(job[:args]).to eq([1, 2, 3])
       full_job = find_job(job[:id])
 
-      full_job['last_error'].should_not be_nil
+      expect(full_job['last_error']).to_not be_nil
     end
 
     it "records normal errors" do
       queue.enqueue("Jobs::Tests::TestJobNoRetry.perform", true)
-      failed_queue.count.should == 0
+      expect(failed_queue.count).to eq(0)
       worker.work
-      failed_queue.count.should == 1
+      expect(failed_queue.count).to eq(1)
     end
   end
 
@@ -42,28 +42,67 @@ describe QueueClassicPlus::CustomWorker do
         job_type.enqueue_perform(true)
       end.to change_queue_size_of(job_type).by(1)
 
-      Jobs::Tests::LockedTestJob.should have_queue_size_of(1)
-      failed_queue.count.should == 0
-      QueueClassicMatchers::QueueClassicRspec.find_by_args('low', 'Jobs::Tests::LockedTestJob._perform', [true]).first['remaining_retries'].should be_nil
+      expect(Jobs::Tests::LockedTestJob).to have_queue_size_of(1)
+      expect(failed_queue.count).to eq(0)
+      expect(QueueClassicMatchers::QueueClassicRspec.find_by_args('low', 'Jobs::Tests::LockedTestJob._perform', [true]).first['remaining_retries']).to be_nil
 
-      QueueClassicPlus::Metrics.should_receive(:increment).with('qc.retry', source: nil )
+      expect(QueueClassicPlus::Metrics).to receive(:increment).with('qc.retry', source: nil )
 
       Timecop.freeze do
         worker.work
 
-        failed_queue.count.should == 0 # not enqueued on Failed
-        QueueClassicMatchers::QueueClassicRspec.find_by_args('low', 'Jobs::Tests::LockedTestJob._perform', [true]).first['remaining_retries'].should eq "4"
-        Jobs::Tests::LockedTestJob.should have_scheduled(true).at(Time.now + described_class::BACKOFF_WIDTH) # should have scheduled a retry for later
+        expect(failed_queue.count).to eq(0) # not enqueued on Failed
+        expect(QueueClassicMatchers::QueueClassicRspec.find_by_args('low', 'Jobs::Tests::LockedTestJob._perform', [true]).first['remaining_retries']).to eq "4"
+        expect(Jobs::Tests::LockedTestJob).to have_scheduled(true).at(Time.now + described_class::BACKOFF_WIDTH) # should have scheduled a retry for later
       end
 
       Timecop.freeze(Time.now + (described_class::BACKOFF_WIDTH * 2)) do
         # the job should be re-enqueued with a decremented retry count
         jobs = QueueClassicMatchers::QueueClassicRspec.find_by_args('low', 'Jobs::Tests::LockedTestJob._perform', [true])
-        jobs.size.should == 1
+        expect(jobs.size).to eq(1)
         job = jobs.first
-        job['remaining_retries'].to_i.should == job_type.max_retries - 1
-        job['locked_by'].should be_nil
-        job['locked_at'].should be_nil
+        expect(job['remaining_retries'].to_i).to eq(job_type.max_retries - 1)
+        expect(job['locked_by']).to be_nil
+        expect(job['locked_at']).to be_nil
+      end
+    end
+
+    context 'when Rails is defined' do
+      require 'active_job'
+      require 'active_job/arguments'
+
+      before { stub_const('Rails', Struct.new(:logger).new(Logger.new(STDOUT))) }
+
+      it 'retries' do
+        expect do
+          job_type.enqueue_perform(:foo)
+        end.to change_queue_size_of(job_type).by(1)
+
+        expect(Jobs::Tests::LockedTestJob).to have_queue_size_of(1)
+        expect(failed_queue.count).to eq(0)
+        expect(QueueClassicMatchers::QueueClassicRspec.find_by_args('low', 'Jobs::Tests::LockedTestJob._perform', [:foo]).first['remaining_retries']).to be_nil
+
+        expect(QueueClassicPlus::Metrics).to receive(:increment).with('qc.retry', source: nil).twice
+
+        Timecop.freeze do
+          worker.work
+
+          expect(failed_queue.count).to eq(0) # not enqueued on Failed
+          expect(QueueClassicMatchers::QueueClassicRspec.find_by_args('low', 'Jobs::Tests::LockedTestJob._perform', [:foo]).first['remaining_retries']).to eq "4"
+          expect(Jobs::Tests::LockedTestJob).to have_scheduled(:foo).at(Time.now + described_class::BACKOFF_WIDTH) # should have scheduled a retry for later
+        end
+
+        Timecop.freeze(Time.now + (described_class::BACKOFF_WIDTH * 2)) do
+          # the job should be re-enqueued with a decremented retry count
+          jobs = QueueClassicMatchers::QueueClassicRspec.find_by_args('low', 'Jobs::Tests::LockedTestJob._perform', [:foo])
+          expect(jobs.size).to eq(1)
+          job = jobs.first
+          expect(job['remaining_retries'].to_i).to eq(job_type.max_retries - 1)
+          expect(job['locked_by']).to be_nil
+          expect(job['locked_at']).to be_nil
+        end
+
+        worker.work
       end
     end
 
@@ -71,11 +110,11 @@ describe QueueClassicPlus::CustomWorker do
       before { Jobs::Tests::ConnectionReapedTestJob.enqueue_perform }
 
       it 'retries' do
-        QueueClassicPlus::Metrics.should_receive(:increment).with('qc.force_retry', source: nil )
+        expect(QueueClassicPlus::Metrics).to receive(:increment).with('qc.force_retry', source: nil )
         Timecop.freeze do
           worker.work
           expect(failed_queue.count).to eq 0
-          QueueClassicMatchers::QueueClassicRspec.find_by_args('low', 'Jobs::Tests::ConnectionReapedTestJob._perform', []).first['remaining_retries'].should eq "4"
+          expect(QueueClassicMatchers::QueueClassicRspec.find_by_args('low', 'Jobs::Tests::ConnectionReapedTestJob._perform', []).first['remaining_retries']).to eq "4"
         end
       end
 
@@ -92,11 +131,11 @@ describe QueueClassicPlus::CustomWorker do
       before { Jobs::Tests::TestJob.enqueue_perform(true) }
 
       it 'retries' do
-        QueueClassicPlus::Metrics.should_receive(:increment).with('qc.retry', source: nil )
+        expect(QueueClassicPlus::Metrics).to receive(:increment).with('qc.retry', source: nil )
         Timecop.freeze do
           worker.work
           expect(failed_queue.count).to eq 0
-          QueueClassicMatchers::QueueClassicRspec.find_by_args('low', 'Jobs::Tests::TestJob._perform', [true]).first['remaining_retries'].should eq "0"
+          expect(QueueClassicMatchers::QueueClassicRspec.find_by_args('low', 'Jobs::Tests::TestJob._perform', [true]).first['remaining_retries']).to eq "0"
         end
       end
     end
@@ -126,16 +165,16 @@ describe QueueClassicPlus::CustomWorker do
           job_type.enqueue_perform(true)
         end.to change_queue_size_of(job_type).by(1)
 
-        Jobs::Tests::LockedTestJob.should have_queue_size_of(1)
-        failed_queue.count.should == 0
-        QueueClassicMatchers::QueueClassicRspec.find_by_args('low', 'Jobs::Tests::LockedTestJob._perform', [true]).first['remaining_retries'].should be_nil
+        expect(Jobs::Tests::LockedTestJob).to have_queue_size_of(1)
+        expect(failed_queue.count).to eq(0)
+        expect(QueueClassicMatchers::QueueClassicRspec.find_by_args('low', 'Jobs::Tests::LockedTestJob._perform', [true]).first['remaining_retries']).to be_nil
 
         Timecop.freeze do
           worker.work
 
-          QueueClassicMatchers::QueueClassicRspec.find_by_args('failed_jobs', 'Jobs::Tests::LockedTestJob._perform', [true]).first['remaining_retries'].should be_nil
-          failed_queue.count.should == 1 # not enqueued on Failed
-          Jobs::Tests::LockedTestJob.should_not have_scheduled(true).at(Time.now + described_class::BACKOFF_WIDTH) # should have scheduled a retry for later
+          expect(QueueClassicMatchers::QueueClassicRspec.find_by_args('failed_jobs', 'Jobs::Tests::LockedTestJob._perform', [true]).first['remaining_retries']).to be_nil
+          expect(failed_queue.count).to eq(1) # not enqueued on Failed
+          expect(Jobs::Tests::LockedTestJob).to_not have_scheduled(true).at(Time.now + described_class::BACKOFF_WIDTH) # should have scheduled a retry for later
         end
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: queue_classic_plus
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 4.0.0.alpha8
 platform: ruby
 authors:
 - Simon Mathieu
@@ -10,22 +10,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-19 00:00:00.000000000 Z
+date: 2021-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: queue_classic
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: 3.1.0
+        version: 4.0.0.pre.alpha1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: 3.1.0
+        version: 4.0.0.pre.alpha1
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -54,6 +54,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: activejob
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: ''
 email:
 - simon.math@gmail.com
@@ -63,10 +91,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".circleci/config.yml"
+- ".github/dependabot.yml"
 - ".gitignore"
 - ".rspec"
 - ".rvmrc"
-- ".travis.yml"
 - Gemfile
 - Guardfile
 - LICENSE.txt
@@ -74,6 +103,7 @@ files:
 - Rakefile
 - lib/queue_classic_plus.rb
 - lib/queue_classic_plus/base.rb
+- lib/queue_classic_plus/datadog.rb
 - lib/queue_classic_plus/inflector.rb
 - lib/queue_classic_plus/inheritable_attr.rb
 - lib/queue_classic_plus/metrics.rb
@@ -89,6 +119,7 @@ files:
 - lib/rails/generators/qc_plus_job/templates/job_spec.rb.erb
 - queue_classic_plus.gemspec
 - spec/base_spec.rb
+- spec/datadog_spec.rb
 - spec/helpers.rb
 - spec/inflector_spec.rb
 - spec/new_relic_spec.rb
@@ -112,17 +143,17 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: Useful extras for Queue Classic
 test_files:
 - spec/base_spec.rb
+- spec/datadog_spec.rb
 - spec/helpers.rb
 - spec/inflector_spec.rb
 - spec/new_relic_spec.rb

data/.travis.yml

@@ -1,14 +0,0 @@
-language: ruby
-services:
-  - postgresql
-before_install:
-  - gem update bundler
-install: bundle install --without development
-before_script:
-  - psql -c 'create database queue_classic_plus_test;' -U postgres
-
-rvm:
-  - 2.0.0
-  - 2.1.5
-  - 2.2.0
-  - 2.3.1