queue_classic_plus 1.0.0 → 4.0.0.alpha9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 7d499c51f34d828e8abf2c5e405d82ea3ae49b19
-  data.tar.gz: 335713b0d79d1b54b9dc342a36c88c2008fccab2
+SHA256:
+  metadata.gz: 998da8f0e2f5f397e1125b9f47f447ba3cdb17908e79bb4eb9d34a5acb87f7d8
+  data.tar.gz: fb21b8b1175142d27792885d814597c145b68fe2e82e8541d6db78a000c30a86
 SHA512:
-  metadata.gz: a529d8ca6f1a179f186f6b57bc90543bec9607a2c87e700db996a87301bea7073b353880ade9796d93d733573112f5545ef1e22440c29156127bd11edeb87212
-  data.tar.gz: c23fde5d11939355a2c8a90a92001f336da6ecf3c422aca1bd11ebed5e55f019b0d8fc5720495ad65439a95b79c11f77cd00f4433533a8d7baf38b19f807fcc7
+  metadata.gz: 84850b2d1be63a0127adf54eab5d810b6fde5de1d9ee2826a2121f76343fc3442cac74de674858234fcf5ae1f25c418f70d578e242280f83485a892e935f13e3
+  data.tar.gz: 1e2e3b3ca6d2280c5aa445737b7179e2bd7f800c8c5a971d81fc3978f753189f437c99fe6ea81b7d69c079b631e4da41c1adf09032f9fe92863c8003e3fd8ee4

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,7 +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 )
@@ -163,3 +169,7 @@ require "queue_classic_plus/new_relic"
 ```
 createdb queue_classic_plus_test
 ```
+
+## Releasing
+
+Releasing is done in CircleCI via the `push_to_rubygems`, triggered by pushing a tagged commit. To do so, simply [create a new GitHub release](https://github.com/rainforestapp/queue_classic_plus/releases/new).

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/new_relic.rb

@@ -1,30 +1,29 @@
 require 'new_relic/agent/method_tracer'
 
-QueueClassicPlus::Base.class_eval do
-  class << self
-    include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+module QueueClassicNewRelic
+  include NewRelic::Agent::Instrumentation::ControllerInstrumentation
 
-    def new_relic_key
-      "Custom/QueueClassicPlus/#{librato_key}"
-    end
+  def new_relic_key
+    "Custom/QueueClassicPlus/#{librato_key}"
+  end
 
-    def _perform_with_new_relic(*args)
-      opts = {
-        name: 'perform',
-        class_name: self.name,
-        category: 'OtherTransaction/QueueClassicPlus',
-      }
+  def _perform(*args)
+    opts = {
+      name: 'perform',
+      class_name: self.name,
+      category: 'OtherTransaction/QueueClassicPlus',
+    }
 
-      perform_action_with_newrelic_trace(opts) do
-        if NewRelic::Agent.config[:'queue_classic_plus.capture_params']
-          NewRelic::Agent.add_custom_parameters(job_arguments: args)
-        end
-        _perform_without_new_relic *args
+    perform_action_with_newrelic_trace(opts) do
+      if NewRelic::Agent.config[:'queue_classic_plus.capture_params']
+        NewRelic::Agent.add_custom_parameters(job_arguments: args)
       end
-    end
 
-    alias_method_chain :_perform, :new_relic
+      super
+    end
   end
+
+  QueueClassicPlus::Base.singleton_class.send(:prepend, QueueClassicNewRelic)
 end
 
 QueueClassicPlus::CustomWorker.class_eval do

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.0.0"
+  VERSION = '4.0.0.alpha9'.freeze
 end

data/lib/queue_classic_plus/worker.rb

@@ -7,17 +7,8 @@ module QueueClassicPlus
     BACKOFF_WIDTH = 10
     FailedQueue = QC::Queue.new("failed_jobs")
 
-    def enqueue_failed(job, e)
-      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, job[:method], JSON.dump(job[:args]), last_error
-
-      QueueClassicPlus.exception_handler.call(e, job)
-      Metrics.increment("qc.errors", source: @q_name)
-    end
-
     def handle_failure(job, e)
-      QueueClassicPlus.logger.info "Handling exception #{e.message} for job #{job[:id]}"
+      QueueClassicPlus.logger.info "Handling exception #{e.class} - #{e.message} for job #{job[:id]}"
 
       force_retry = false
       if connection_error?(e)
@@ -33,52 +24,50 @@ module QueueClassicPlus
         force_retry = true
       end
 
-      klass = job_klass(job)
+      @failed_job = job
+      @raw_args = job[:args]
+      @failed_job_args = failed_job_class ? failed_job_class.deserialized(@raw_args) : @raw_args
 
-      if force_retry && !(klass.respond_to?(:disable_retries) && klass.disable_retries)
+      if force_retry && !(failed_job_class.respond_to?(:disable_retries) && failed_job_class.disable_retries)
         Metrics.increment("qc.force_retry", source: @q_name)
-
-        retry_with_remaining(klass, job, e, 0)
+        retry_with_remaining(e)
       # The mailers doesn't have a retries_on?
-      elsif klass && klass.respond_to?(:retries_on?) && klass.retries_on?(e)
+      elsif failed_job_class.respond_to?(:retries_on?) && failed_job_class.retries_on?(e)
         Metrics.increment("qc.retry", source: @q_name)
-
-        backoff = (max_retries(klass) - remaining_retries(klass, job)) * BACKOFF_WIDTH
-
-        retry_with_remaining(klass, job, e, backoff)
+        retry_with_remaining(e)
       else
-        enqueue_failed(job, e)
+        enqueue_failed(e)
       end
 
-      FailedQueue.delete(job[:id])
+      FailedQueue.delete(@failed_job[:id])
     end
 
     private
 
-    def retry_with_remaining(klass, job, e, backoff)
-      @remaining_retries = remaining_retries(klass, job)
-
-      if @remaining_retries > 0
-        klass.restart_in(backoff, @remaining_retries, *job[:args])
+    def retry_with_remaining(e)
+      if remaining_retries > 0
+        failed_job_class.restart_in(backoff, remaining_retries - 1, *@failed_job_args)
       else
-        enqueue_failed(job, e)
+        enqueue_failed(e)
       end
     end
 
-    def max_retries(klass)
-      klass.respond_to?(:max_retries) ? klass.max_retries : 5
+    def max_retries
+      failed_job_class.respond_to?(:max_retries) ? failed_job_class.max_retries : 5
     end
 
-    def remaining_retries(klass, job)
-      @remaining_retries ? @remaining_retries - 1 : (job[:remaining_retries] || max_retries(klass)).to_i - 1
+    def remaining_retries
+      (@failed_job[:remaining_retries] || max_retries).to_i
     end
 
-    def job_klass(job)
-      begin
-        Object.const_get(job[:method].split('.')[0])
-      rescue NameError
-        nil
-      end
+    def failed_job_class
+      Object.const_get(@failed_job[:method].split('.')[0])
+    rescue NameError
+      nil
+    end
+
+    def backoff
+      (max_retries - (remaining_retries - 1)) * BACKOFF_WIDTH
     end
 
     def connection_error?(e)
@@ -86,5 +75,15 @@ module QueueClassicPlus
         (e.respond_to?(:original_exception) &&
          CONNECTION_ERRORS.any? { |klass| e.original_exception.kind_of? klass })
     end
+
+    def enqueue_failed(e)
+      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(@raw_args), last_error
+
+      QueueClassicPlus.exception_handler.call(e, @failed_job)
+      Metrics.increment("qc.errors", source: @q_name)
+    end
   end
 end

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,7 +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_development_dependency "bundler", "~> 1.6"
+  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,45 @@ 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", rails: true do
+      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/new_relic_spec.rb

@@ -0,0 +1,26 @@
+describe 'requiring queue_classic_plus/new_relic' do
+  subject do
+    Class.new(QueueClassicPlus::Base) do
+      @queue = :test
+
+      def self.perform
+      end
+
+      def self.name
+        'Funky::Name'
+      end
+    end
+  end
+
+  it 'adds NewRelic profiling support' do
+    expect(subject).to receive(:perform_action_with_newrelic_trace).once.with({
+      name: 'perform',
+      class_name: 'Funky::Name',
+      category: 'OtherTransaction/QueueClassicPlus',
+    })
+
+    subject._perform
+    require 'queue_classic_plus/new_relic'
+    subject._perform
+  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
@@ -35,9 +35,9 @@ module Jobs
 
     class TestJob < QueueClassicPlus::Base
       @queue = :low
-      retry! on: SomeException, max: 5
+      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,14 @@ 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
+
+  config.before(:each, rails: true) do
+    require 'active_job'
+    require 'active_job/arguments'
+
+    stub_const('Rails', Struct.new(:logger).new(Logger.new(STDOUT)))
   end
 end

data/spec/worker_spec.rb

@@ -9,22 +9,42 @@ 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
+
+    context 'when Rails is defined', rails: true do
+      let(:job_type) { Jobs::Tests::TestJobNoRetry }
+      let(:queue) { job_type.queue }
+
+      it 'properly serializes arguments for jobs in the failed queue' do
+        job_type.enqueue_perform(:raise)
+        expect(failed_queue.count).to eq(0)
+        worker.work
+
+        expect(failed_queue.count).to eq(1)
+        job = QueueClassicMatchers::QueueClassicRspec.find_by_args(
+          'failed_jobs',
+          'Jobs::Tests::TestJobNoRetry._perform',
+          [:raise]).first
+
+        expect(job).to_not be_nil
+        expect(job['last_error']).to_not be_nil
+      end
     end
   end
 
@@ -42,28 +62,62 @@ 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', rails: true do
+      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 +125,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
 
@@ -88,6 +142,19 @@ describe QueueClassicPlus::CustomWorker do
       end
     end
 
+    context 'with a custom exception having max: 1 retry' do
+      before { Jobs::Tests::TestJob.enqueue_perform(true) }
+
+      it 'retries' do
+        expect(QueueClassicPlus::Metrics).to receive(:increment).with('qc.retry', source: nil )
+        Timecop.freeze do
+          worker.work
+          expect(failed_queue.count).to eq 0
+          expect(QueueClassicMatchers::QueueClassicRspec.find_by_args('low', 'Jobs::Tests::TestJob._perform', [true]).first['remaining_retries']).to eq "0"
+        end
+      end
+    end
+
     context 'with non-connection based PG jobs' do
       before { Jobs::Tests::UniqueViolationTestJob.enqueue_perform }
 
@@ -113,16 +180,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.0.0
+  version: 4.0.0.alpha9
 platform: ruby
 authors:
 - Simon Mathieu
@@ -10,36 +10,36 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-18 00:00:00.000000000 Z
+date: 2021-10-27 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
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rake
   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,8 +119,10 @@ 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
 - spec/queue_classic/queue_spec.rb
 - spec/sample_jobs.rb
 - spec/spec_helper.rb
@@ -111,19 +143,20 @@ 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.6.13
+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
 - spec/queue_classic/queue_spec.rb
 - spec/sample_jobs.rb
 - spec/spec_helper.rb

data/.travis.yml

@@ -1,12 +0,0 @@
-language: ruby
-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