queue_classic_plus 1.0.1 → 4.0.0.alpha10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 2401a88a47f9dcc2752db9ed026982cb6724851b
-  data.tar.gz: cecd7627f4a663a4b89a7bf6bfeed08f240cea62
+SHA256:
+  metadata.gz: 14e8dfec194b5946e629568f8fc73041f0a9f546b737ab2926446cfa0bffe854
+  data.tar.gz: e45cbfdd17b764c9569f554ac989e3ab03948a237265f53605aba8032be28bd1
 SHA512:
-  metadata.gz: 4da76e72bfed26e9898a1094cc6cc719caaafcb0efb4cfd59d86f4aa02e716b2ecee592f9a384149e557ca4f67ce9583b22dc4555e09befcbd2bea5586ac40ed
-  data.tar.gz: 4c6e779b8546ca3c91e925aa0236623516ea009532a14a9e53bf7f0b895a47a6168ddc243fdf17b5cedb8a1dd2f36f97cccd60629b808ea3c1ad81725df01a58
+  metadata.gz: 6380f8e7aaacae04565c0d1ed2a6b0bb5a9257709f803efd015914a032d1aa35cf4757c4dee8c7639bf9ec03e92df8352a08dddd0ab1f53ccf85d18c7fa77685
+  data.tar.gz: eefd27dce5e3f9e6a5a1c33a5b6572890a29142b2acf9b65dc2802a125b6fa173dedd48e0f216f61f9384bfa10cf13651d6173b8ca1a0d07e4ad66f4201a3ea1

data/.circleci/config.yml

@@ -0,0 +1,67 @@
+version: 2.1
+
+jobs:
+  test:
+    docker:
+      - image: cimg/ruby:3.0.3
+        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: cimg/ruby:3.0.3
+        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 'rake'
+  gem 'byebug'
   gem 'rspec'
   gem 'timecop'
+  gem 'newrelic_rpm'
+  gem 'ddtrace'
+  gem 'simplecov', require: false
 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,10 +119,10 @@ 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)
+        ActiveRecord::Base.transaction(**options, &block)
       else
         begin
           execute "BEGIN"
@@ -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.1"
+  VERSION = '4.0.0.alpha10'.freeze
 end

data/lib/queue_classic_plus/worker.rb

@@ -25,12 +25,14 @@ module QueueClassicPlus
       end
 
       @failed_job = job
+      @raw_args = job[:args]
+      @failed_job_args = failed_job_class ? failed_job_class.deserialized(@raw_args) : @raw_args
 
       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(e)
       # The mailers doesn't have a retries_on?
-    elsif failed_job_class && failed_job_class.respond_to?(:retries_on?) && failed_job_class.retries_on?(e)
+      elsif failed_job_class.respond_to?(:retries_on?) && failed_job_class.retries_on?(e)
         Metrics.increment("qc.retry", source: @q_name)
         retry_with_remaining(e)
       else
@@ -44,7 +46,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
@@ -59,11 +61,9 @@ module QueueClassicPlus
     end
 
     def failed_job_class
-      begin
-        Object.const_get(@failed_job[:method].split('.')[0])
-      rescue NameError
-        nil
-      end
+      Object.const_get(@failed_job[:method].split('.')[0])
+    rescue NameError
+      nil
     end
 
     def backoff
@@ -77,9 +77,10 @@ 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(@raw_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,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

@@ -1,3 +1,5 @@
+require 'spec_helper'
+require 'active_record'
 
 describe QueueClassicPlus::Base do
   context "A child of QueueClassicPlus::Base" do
@@ -12,7 +14,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 +34,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 +53,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 +77,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 +96,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 +121,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,23 +150,73 @@ 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
 
+  context 'with ActiveRecord' 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
+
+    after do
+      @activerecord_conn.disconnect!
+      QC.default_conn_adapter = @old_conn_adapter
+    end
+
+    subject do
+      Class.new(QueueClassicPlus::Base) do
+        @queue = :test
+
+        def self.perform(foo, bar)
+        end
+      end
+    end
+
+    it 'works' do
+      expect { subject._perform(1, 2) }.not_to raise_error
+    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
@@ -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

@@ -1,11 +1,21 @@
+require 'simplecov'
+
+SimpleCov.start do
+  add_filter(%r/^\/spec\//)
+  enable_coverage(:branch)
+end
+
 require 'queue_classic_plus'
 require 'pg'
 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 +30,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
 
@@ -92,11 +146,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 +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.1
+  version: 4.0.0.alpha10
 platform: ruby
 authors:
 - Simon Mathieu
@@ -10,36 +10,36 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-14 00:00:00.000000000 Z
+date: 2022-01-03 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,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".circleci/config.yml"
+- ".github/dependabot.yml"
 - ".gitignore"
 - ".rspec"
-- ".rvmrc"
-- ".travis.yml"
 - Gemfile
 - Guardfile
 - LICENSE.txt
@@ -74,6 +102,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 +118,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 +142,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.2.32
 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/.rvmrc

@@ -1 +0,0 @@
-rvm use 2.1.3@queue_classic_plus --create

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