delayed 0.1.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ab35af5acde370d84971fff4e2aad4a6903a790fc42787917c0ee018a227077
-  data.tar.gz: 792234868782d73f6960127f06293020cd11ad32680074b6bcabee2db7a8a383
+  metadata.gz: ec0bc05440d0ea5392480d83c4a3295aecfcad71a47fc48b16de19d356387e8d
+  data.tar.gz: 2a9b09c4a77f058e8fe322f9b80da8aed4b909b20e3ebbcc33da1277435407d0
 SHA512:
-  metadata.gz: 9af114801499f370343a41cffe87151509882d62973c61a0c7d82ecc4395ffbad35d15b1715309813dfacfb543d14b11e8d8ac829003fbf5892e1639dff7b387
-  data.tar.gz: c4e80bd8917d15eb9b4c67736571d349002945f9d8f621b5e7a2da5db179f6a7cbc18da09fa831af21cccbfacf1beec56bda3914d1d44c133d2fdb4858834c09
+  metadata.gz: 183b8ad1b96cbe2ce987a6a2faa449b90963a898ae2ffccb7f99eacbeb94be5cedae452bc2ed884414e6cfe2a8169481192d9269e2111b80b3be2d805a5cac83
+  data.tar.gz: 75ad14cf19505ee4b0152797cbee705dbe712939a5e5a0f3bd960a9ddad2c25756e0aedbc8745e70e40d5b634bdf96ef5d175c81f88a86308b524a1f97b2356c

data/README.md

@@ -13,9 +13,11 @@ It supports **postgres**, **mysql**, and **sqlite**, and is designed to be:
 - **Resilient**, with built-in retry mechanisms, exponential back-off, and failed job preservation
 - **Maintainable**, with robust instrumentation, continuous monitoring, and priority-based alerting
 
-For an overview of how Betterment uses `delayed` to build resilience into distributed systems, check
-out the talk ✨[Can I break this?](https://www.youtube.com/watch?v=TuhS13rBoVY)✨ given at RailsConf
-2021!
+For an overview of how Betterment uses `delayed` to build resilience into distributed systems, read
+the
+[announcement blog post](https://www.betterment.com/resources/delayed-resilient-background-jobs-on-rails/),
+and/or check out the talk ✨[Can I break this?](https://www.youtube.com/watch?v=TuhS13rBoVY)✨
+given at RailsConf 2021!
 
 
 ### Why `Delayed`?

data/{lib → app/models}/delayed/job.rb

@@ -163,13 +163,19 @@ module Delayed
     def self.db_time_now
       if Time.zone
         Time.zone.now
-      elsif ::ActiveRecord::Base.default_timezone == :utc
+      elsif default_timezone == :utc
         Time.now.utc
       else
         Time.current
       end
     end
 
+    if ActiveRecord::VERSION::MAJOR >= 7
+      def self.default_timezone
+        ActiveRecord.default_timezone
+      end
+    end
+
     def self.worker_tags(worker)
       {
         min_priority: worker.min_priority,

data/lib/delayed/{railtie.rb → engine.rb}

@@ -1,5 +1,5 @@
 module Delayed
-  class Railtie < Rails::Railtie
+  class Engine < Rails::Engine
     rake_tasks do
       load 'delayed/tasks.rb'
     end

data/lib/delayed/message_sending.rb

@@ -8,8 +8,8 @@ module Delayed
       @options = options
     end
 
-    def method_missing(method, *args)
-      Job.enqueue({ payload_object: @payload_class.new(@target, method.to_sym, args) }.merge(@options))
+    def method_missing(method, *args, **kwargs)
+      Job.enqueue({ payload_object: @payload_class.new(@target, method.to_sym, args, kwargs) }.merge(@options))
     end
   end
 
@@ -18,16 +18,6 @@ module Delayed
       DelayProxy.new(PerformableMethod, self, options)
     end
     alias __delay__ delay
-
-    def send_later(method, *args)
-      warn '[DEPRECATION] `object.send_later(:method)` is deprecated. Use `object.delay.method'
-      __delay__.__send__(method, *args)
-    end
-
-    def send_at(time, method, *args)
-      warn '[DEPRECATION] `object.send_at(time, :method)` is deprecated. Use `object.delay(:run_at => time).method'
-      __delay__(run_at: time).__send__(method, *args)
-    end
   end
 
   module MessageSendingClassMethods
@@ -36,7 +26,7 @@ module Delayed
       punctuation = $1 # rubocop:disable Style/PerlBackrefs
       with_method = "#{aliased_method}_with_delay#{punctuation}"
       without_method = "#{aliased_method}_without_delay#{punctuation}"
-      define_method(with_method) do |*args|
+      define_method(with_method) do |*args, **kwargs|
         curr_opts = opts.clone
         curr_opts.each_key do |key|
           next unless (val = curr_opts[key]).is_a?(Proc)
@@ -47,7 +37,7 @@ module Delayed
                              val.call
                            end
         end
-        delay(curr_opts).__send__(without_method, *args)
+        delay(curr_opts).__send__(without_method, *args, **kwargs)
       end
 
       alias_method without_method, method

data/lib/delayed/performable_mailer.rb

@@ -3,7 +3,7 @@ require 'mail'
 module Delayed
   class PerformableMailer < PerformableMethod
     def perform
-      mailer = object.send(method_name, *args)
+      mailer = super
       mailer.respond_to?(:deliver_now) ? mailer.deliver_now : mailer.deliver
     end
   end

data/lib/delayed/performable_method.rb

@@ -1,8 +1,8 @@
 module Delayed
   class PerformableMethod
-    attr_accessor :object, :method_name, :args
+    attr_accessor :object, :method_name, :args, :kwargs
 
-    def initialize(object, method_name, args)
+    def initialize(object, method_name, args, kwargs)
       raise NoMethodError, "undefined method `#{method_name}' for #{object.inspect}" unless object.respond_to?(method_name, true)
 
       if !her_model?(object) && object.respond_to?(:persisted?) && !object.persisted?
@@ -11,6 +11,7 @@ module Delayed
 
       self.object       = object
       self.args         = args
+      self.kwargs       = kwargs
       self.method_name  = method_name.to_sym
     end
 
@@ -23,7 +24,13 @@ module Delayed
     end
 
     def perform
-      object.send(method_name, *args) if object
+      return unless object
+
+      if kwargs.nil? || (RUBY_VERSION < '2.7' && kwargs.empty?)
+        object.send(method_name, *args)
+      else
+        object.send(method_name, *args, **kwargs)
+      end
     end
 
     def method(sym)

data/lib/delayed/priority.rb

@@ -150,7 +150,7 @@ module Delayed
     private
 
     def respond_to_missing?(method_name, include_private = false)
-      method_name.to_s.end_with?('?') && self.class.names.key?(method_name.to_s[0..-2].to_sym) || super
+      (method_name.to_s.end_with?('?') && self.class.names.key?(method_name.to_s[0..-2].to_sym)) || super
     end
 
     def method_missing(method_name, *args)

data/lib/delayed/psych_ext.rb

@@ -6,6 +6,7 @@ module Delayed
         'object' => object,
         'method_name' => method_name,
         'args' => args,
+        'kwargs' => kwargs,
       }
     end
   end

data/lib/delayed/runnable.rb

@@ -21,7 +21,7 @@ module Delayed
     def on_exit!; end
 
     def interruptable_sleep(seconds)
-      IO.select([pipe[0]], nil, nil, seconds)
+      pipe[0].wait_readable(seconds)
     end
 
     def stop

data/lib/delayed.rb

@@ -14,11 +14,12 @@ require 'delayed/plugins/instrumentation'
 require 'delayed/backend/base'
 require 'delayed/backend/job_preparer'
 require 'delayed/worker'
-require 'delayed/railtie' if defined?(Rails::Railtie)
 
-ActiveSupport.on_load(:active_record) do
-  require 'delayed/serialization/active_record'
-  require 'delayed/job'
+if defined?(Rails::Engine)
+  require 'delayed/engine'
+else
+  require 'active_record'
+  require_relative '../app/models/delayed/job'
 end
 
 ActiveSupport.on_load(:active_job) do

data/spec/delayed/active_job_adapter_spec.rb

@@ -223,6 +223,25 @@ RSpec.describe Delayed::ActiveJobAdapter do
       end
     end
 
+    context 'when ActiveJob has both positional and keyword arguments' do
+      let(:job_class) do
+        Class.new(ActiveJob::Base) do # rubocop:disable Rails/ApplicationJob
+          cattr_accessor(:result)
+
+          def perform(arg, kwarg:)
+            self.class.result = [arg, kwarg]
+          end
+        end
+      end
+
+      it 'passes arguments through to the perform method' do
+        JobClass.perform_later('foo', kwarg: 'bar')
+
+        Delayed::Worker.new.work_off
+        expect(JobClass.result).to eq %w(foo bar)
+      end
+    end
+
     context 'when using the ActiveJob test adapter' do
       let(:queue_adapter) { :test }
 

data/spec/delayed/job_spec.rb

@@ -352,7 +352,7 @@ describe Delayed::Job do
   context 'large handler' do
     before do
       text = 'Lorem ipsum dolor sit amet. ' * 1000
-      @job = described_class.enqueue Delayed::PerformableMethod.new(text, :length, {})
+      @job = described_class.enqueue Delayed::PerformableMethod.new(text, :length, [], {})
     end
 
     it 'has an id' do
@@ -739,10 +739,16 @@ describe Delayed::Job do
     end
   end
 
+  if ActiveRecord::VERSION::MAJOR >= 7
+    delegate :default_timezone=, to: ActiveRecord
+  else
+    delegate :default_timezone=, to: ActiveRecord::Base
+  end
+
   context "db_time_now" do
     after do
       Time.zone = nil
-      ActiveRecord::Base.default_timezone = :local
+      self.default_timezone = :local
     end
 
     it "returns time in current time zone if set" do
@@ -752,13 +758,13 @@ describe Delayed::Job do
 
     it "returns UTC time if that is the AR default" do
       Time.zone = nil
-      ActiveRecord::Base.default_timezone = :utc
+      self.default_timezone = :utc
       expect(described_class.db_time_now.zone).to eq "UTC"
     end
 
     it "returns local time if that is the AR default" do
       Time.zone = "Arizona"
-      ActiveRecord::Base.default_timezone = :local
+      self.default_timezone = :local
       expect(described_class.db_time_now.zone).to eq("MST")
     end
   end

data/spec/helper.rb

@@ -139,8 +139,15 @@ RSpec.configure do |config|
   end
 end
 
-# Add this directory so the ActiveSupport autoloading works
-ActiveSupport::Dependencies.autoload_paths << File.dirname(__FILE__)
+if ActiveRecord::VERSION::MAJOR >= 7
+  require "zeitwerk"
+  loader = Zeitwerk::Loader.new
+  loader.push_dir File.dirname(__FILE__)
+  loader.setup
+else
+  # Add this directory so the ActiveSupport autoloading works
+  ActiveSupport::Dependencies.autoload_paths << File.dirname(__FILE__)
+end
 
 RSpec::Matchers.define :emit_notification do |expected_event_name|
   attr_reader :actual, :expected

data/spec/message_sending_spec.rb

@@ -7,24 +7,27 @@ describe Delayed::MessageSending do
   end
 
   describe 'handle_asynchronously' do
-    class Story
-      def tell!(_arg); end
-      handle_asynchronously :tell!
+    let(:test_class) do
+      Class.new do
+        def tell!(_arg, _kwarg:); end
+        handle_asynchronously :tell!
+      end
     end
 
     it 'aliases original method' do
-      expect(Story.new).to respond_to(:tell_without_delay!)
-      expect(Story.new).to respond_to(:tell_with_delay!)
+      expect(test_class.new).to respond_to(:tell_without_delay!)
+      expect(test_class.new).to respond_to(:tell_with_delay!)
     end
 
     it 'creates a PerformableMethod' do
-      story = Story.create
+      obj = test_class.new
       expect {
-        job = story.tell!(1)
+        job = obj.tell!('a', kwarg: 'b')
         expect(job.payload_object.class).to eq(Delayed::PerformableMethod)
         expect(job.payload_object.method_name).to eq(:tell_without_delay!)
-        expect(job.payload_object.args).to eq([1])
-      }.to(change { Delayed::Job.count })
+        expect(job.payload_object.args).to eq(['a'])
+        expect(job.payload_object.kwargs).to eq(kwarg: 'b')
+      }.to change { Delayed::Job.count }.by(1)
     end
 
     describe 'with options' do
@@ -64,26 +67,33 @@ describe Delayed::MessageSending do
   end
 
   context 'delay' do
-    class FairyTail
-      attr_accessor :happy_ending
+    let(:fairy_tail_class) do
+      Class.new do
+        attr_accessor :happy_ending
 
-      def self.princesses; end
+        def self.princesses; end
 
-      def tell
-        @happy_ending = true
+        def tell(arg, kwarg:)
+          @happy_ending = [arg, kwarg]
+        end
       end
     end
 
+    before do
+      stub_const('FairyTail', fairy_tail_class)
+    end
+
     after do
       Delayed::Worker.default_queue_name = nil
     end
 
     it 'creates a new PerformableMethod job' do
       expect {
-        job = 'hello'.delay.count('l')
+        job = FairyTail.new.delay.tell('arg', kwarg: 'kwarg')
         expect(job.payload_object.class).to eq(Delayed::PerformableMethod)
-        expect(job.payload_object.method_name).to eq(:count)
-        expect(job.payload_object.args).to eq(['l'])
+        expect(job.payload_object.method_name).to eq(:tell)
+        expect(job.payload_object.args).to eq(['arg'])
+        expect(job.payload_object.kwargs).to eq(kwarg: 'kwarg')
       }.to change { Delayed::Job.count }.by(1)
     end
 
@@ -111,8 +121,8 @@ describe Delayed::MessageSending do
       fairy_tail = FairyTail.new
       expect {
         expect {
-          fairy_tail.delay.tell
-        }.to change { fairy_tail.happy_ending }.from(nil).to(true)
+          fairy_tail.delay.tell('a', kwarg: 'b')
+        }.to change { fairy_tail.happy_ending }.from(nil).to %w(a b)
       }.not_to(change { Delayed::Job.count })
     end
 
@@ -121,7 +131,7 @@ describe Delayed::MessageSending do
       fairy_tail = FairyTail.new
       expect {
         expect {
-          fairy_tail.delay.tell
+          fairy_tail.delay.tell('a', kwarg: 'b')
         }.not_to change { fairy_tail.happy_ending }
       }.to change { Delayed::Job.count }.by(1)
     end
@@ -131,7 +141,7 @@ describe Delayed::MessageSending do
       fairy_tail = FairyTail.new
       expect {
         expect {
-          fairy_tail.delay.tell
+          fairy_tail.delay.tell('a', kwarg: 'b')
         }.not_to change { fairy_tail.happy_ending }
       }.to change { Delayed::Job.count }.by(1)
     end
@@ -141,8 +151,8 @@ describe Delayed::MessageSending do
       fairy_tail = FairyTail.new
       expect {
         expect {
-          fairy_tail.delay.tell
-        }.to change { fairy_tail.happy_ending }.from(nil).to(true)
+          fairy_tail.delay.tell('a', kwarg: 'b')
+        }.to change { fairy_tail.happy_ending }.from(nil).to %w(a b)
       }.not_to(change { Delayed::Job.count })
     end
   end

data/spec/performable_mailer_spec.rb

@@ -1,58 +1,41 @@
 require 'helper'
 
-class MyMailer < ActionMailer::Base
-  def signup(email)
-    mail to: email, subject: 'Delaying Emails', from: 'delayedjob@example.com', body: 'Delaying Emails Body'
-  end
-end
+describe Delayed::PerformableMailer do
+  let(:mailer_class) do
+    Class.new(ActionMailer::Base) do
+      cattr_accessor(:emails) { [] }
 
-describe ActionMailer::Base do
-  describe 'delay' do
-    it 'enqueues a PerformableEmail job' do
-      expect {
-        job = MyMailer.delay.signup('john@example.com')
-        expect(job.payload_object.class).to eq(Delayed::PerformableMailer)
-        expect(job.payload_object.method_name).to eq(:signup)
-        expect(job.payload_object.args).to eq(['john@example.com'])
-      }.to change { Delayed::Job.count }.by(1)
+      def signup(email, beta_tester: false)
+        mail to: email, subject: "Delaying Emails (beta: #{beta_tester})", from: 'delayedjob@example.com', body: 'Delaying Emails Body'
+      end
     end
   end
 
-  describe 'delay on a mail object' do
-    it 'raises an exception' do
-      expect {
-        MyMailer.signup('john@example.com').delay
-      }.to raise_error(RuntimeError)
-    end
+  before do
+    stub_const('MyMailer', mailer_class)
   end
 
-  describe Delayed::PerformableMailer do
-    describe 'perform' do
-      it 'calls the method and #deliver on the mailer' do
-        email = double('email', deliver: true)
-        mailer_class = double('MailerClass', signup: email)
-        mailer = described_class.new(mailer_class, :signup, ['john@example.com'])
+  describe 'perform' do
+    it 'calls the method and #deliver on the mailer' do
+      mailer = MyMailer.new
+      email = double('email', deliver: true)
+      allow(mailer).to receive(:mail).and_return(email)
+      mailer_job = described_class.new(mailer, :signup, ['john@example.com'], {})
 
-        expect(mailer_class).to receive(:signup).with('john@example.com')
-        expect(email).to receive(:deliver)
-        mailer.perform
-      end
+      expect(email).to receive(:deliver)
+      mailer_job.perform
     end
   end
-end
 
-if defined?(ActionMailer::Parameterized::Mailer)
-  describe ActionMailer::Parameterized::Mailer do
+  describe ActionMailer::Base do
     describe 'delay' do
       it 'enqueues a PerformableEmail job' do
         expect {
-          job = MyMailer.with(foo: 1, bar: 2).delay.signup('john@example.com')
+          job = MyMailer.delay.signup('john@example.com', beta_tester: true)
           expect(job.payload_object.class).to eq(Delayed::PerformableMailer)
-          expect(job.payload_object.object.class).to eq(described_class)
-          expect(job.payload_object.object.instance_variable_get('@mailer')).to eq(MyMailer)
-          expect(job.payload_object.object.instance_variable_get('@params')).to eq(foo: 1, bar: 2)
           expect(job.payload_object.method_name).to eq(:signup)
           expect(job.payload_object.args).to eq(['john@example.com'])
+          expect(job.payload_object.kwargs).to eq(beta_tester: true)
         }.to change { Delayed::Job.count }.by(1)
       end
     end
@@ -60,9 +43,36 @@ if defined?(ActionMailer::Parameterized::Mailer)
     describe 'delay on a mail object' do
       it 'raises an exception' do
         expect {
-          MyMailer.with(foo: 1, bar: 2).signup('john@example.com').delay
+          MyMailer.signup('john@example.com').delay
         }.to raise_error(RuntimeError)
       end
     end
   end
+
+  if defined?(ActionMailer::Parameterized::Mailer)
+    describe ActionMailer::Parameterized::Mailer do
+      describe 'delay' do
+        it 'enqueues a PerformableEmail job' do
+          expect {
+            job = MyMailer.with(foo: 1, bar: 2).delay.signup('john@example.com', beta_tester: false)
+            expect(job.payload_object.class).to eq(Delayed::PerformableMailer)
+            expect(job.payload_object.object.class).to eq(described_class)
+            expect(job.payload_object.object.instance_variable_get('@mailer')).to eq(MyMailer)
+            expect(job.payload_object.object.instance_variable_get('@params')).to eq(foo: 1, bar: 2)
+            expect(job.payload_object.method_name).to eq(:signup)
+            expect(job.payload_object.args).to eq(['john@example.com'])
+            expect(job.payload_object.kwargs).to eq(beta_tester: false)
+          }.to change { Delayed::Job.count }.by(1)
+        end
+      end
+
+      describe 'delay on a mail object' do
+        it 'raises an exception' do
+          expect {
+            MyMailer.with(foo: 1, bar: 2).signup('john@example.com').delay
+          }.to raise_error(RuntimeError)
+        end
+      end
+    end
+  end
 end

data/spec/performable_method_spec.rb

@@ -2,8 +2,18 @@ require 'helper'
 
 describe Delayed::PerformableMethod do
   describe 'perform' do
+    let(:test_class) do
+      Class.new do
+        cattr_accessor :result
+
+        def foo(arg, kwarg:)
+          self.class.result = [arg, kwarg]
+        end
+      end
+    end
+
     before do
-      @method = described_class.new('foo', :count, ['o'])
+      @method = described_class.new(test_class.new, :foo, ['a'], { kwarg: 'b' })
     end
 
     context 'with the persisted record cannot be found' do
@@ -17,14 +27,29 @@ describe Delayed::PerformableMethod do
     end
 
     it 'calls the method on the object' do
-      expect(@method.object).to receive(:count).with('o')
-      @method.perform
+      expect { @method.perform }
+        .to change { test_class.result }
+        .from(nil).to %w(a b)
+    end
+
+    if RUBY_VERSION < '3.0'
+      context 'when kwargs are nil (job was delayed via prior gem version)' do
+        before do
+          @method = described_class.new(test_class.new, :foo, ['a', { kwarg: 'b' }], nil)
+        end
+
+        it 'calls the method on the object' do
+          expect { @method.perform }
+            .to change { test_class.result }
+            .from(nil).to %w(a b)
+        end
+      end
     end
   end
 
   it "raises a NoMethodError if target method doesn't exist" do
     expect {
-      described_class.new(Object, :method_that_does_not_exist, [])
+      described_class.new(Object, :method_that_does_not_exist, [], {})
     }.to raise_error(NoMethodError)
   end
 
@@ -33,29 +58,29 @@ describe Delayed::PerformableMethod do
       def private_method; end
       private :private_method
     end
-    expect { described_class.new(clazz.new, :private_method, []) }.not_to raise_error
+    expect { described_class.new(clazz.new, :private_method, [], {}) }.not_to raise_error
   end
 
   context 'when it receives an object that is not persisted' do
     let(:object) { double(persisted?: false, expensive_operation: true) }
 
     it 'raises an ArgumentError' do
-      expect { described_class.new(object, :expensive_operation, []) }.to raise_error ArgumentError
+      expect { described_class.new(object, :expensive_operation, [], {}) }.to raise_error ArgumentError
     end
 
     it 'does not raise ArgumentError if the object acts like a Her model' do
       allow(object.class).to receive(:save_existing).and_return(true)
-      expect { described_class.new(object, :expensive_operation, []) }.not_to raise_error
+      expect { described_class.new(object, :expensive_operation, [], {}) }.not_to raise_error
     end
   end
 
   describe 'display_name' do
     it 'returns class_name#method_name for instance methods' do
-      expect(described_class.new('foo', :count, ['o']).display_name).to eq('String#count')
+      expect(described_class.new('foo', :count, ['o'], {}).display_name).to eq('String#count')
     end
 
     it 'returns class_name.method_name for class methods' do
-      expect(described_class.new(Class, :inspect, []).display_name).to eq('Class.inspect')
+      expect(described_class.new(Class, :inspect, [], {}).display_name).to eq('Class.inspect')
     end
   end
 
@@ -84,7 +109,7 @@ describe Delayed::PerformableMethod do
     end
 
     it 'delegates failure hook to object' do
-      method = described_class.new('object', :size, [])
+      method = described_class.new('object', :size, [], {})
       expect(method.object).to receive(:failure)
       method.failure
     end
@@ -114,7 +139,7 @@ describe Delayed::PerformableMethod do
       end
 
       it 'delegates failure hook to object' do
-        method = described_class.new('object', :size, [])
+        method = described_class.new('object', :size, [], {})
         expect(method.object).to receive(:failure)
         method.failure
       end

data/spec/psych_ext_spec.rb

@@ -11,6 +11,30 @@ describe 'Psych::Visitors::ToRuby', if: defined?(Psych::Visitors::ToRuby) do
     end
   end
 
+  context Delayed::PerformableMethod do
+    it 'serializes with object, method_name, args, and kwargs' do
+      Delayed::PerformableMethod.new(String, :new, ['hello'], capacity: 20).tap do |pm|
+        serialized = YAML.dump_dj(pm)
+        expect(serialized).to eq <<~YAML
+          --- !ruby/object:Delayed::PerformableMethod
+          object: !ruby/class 'String'
+          method_name: :new
+          args:
+          - hello
+          kwargs:
+            :capacity: 20
+        YAML
+
+        deserialized = YAML.load_dj(serialized)
+        expect(deserialized).to be_an_instance_of(Delayed::PerformableMethod)
+        expect(deserialized.object).to eq String
+        expect(deserialized.method_name).to eq :new
+        expect(deserialized.args).to eq ['hello']
+        expect(deserialized.kwargs).to eq(capacity: 20)
+      end
+    end
+  end
+
   context ActiveRecord::Base do
     it 'serializes and deserializes in a version-independent way' do
       Story.create.tap do |story|

data/spec/yaml_ext_spec.rb

@@ -25,7 +25,7 @@ describe 'YAML' do
   it 'autoloads the class of an anonymous struct' do
     expect {
       yaml = "--- !ruby/struct\nn: 1\n"
-      object = YAML.load(yaml)
+      object = load_with_delayed_visitor(yaml)
       expect(object).to be_kind_of(Struct)
       expect(object.n).to eq(1)
     }.not_to raise_error

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: delayed
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Nathan Griffith
@@ -19,7 +19,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-08-17 00:00:00.000000000 Z
+date: 2021-11-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -203,19 +203,27 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  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: |
-  ===== +Delayed+ is a multi-threaded, SQL-driven ActiveJob backend used at {Betterment}[https://betterment.com] to process millions of background jobs per day.
-
-  It supports *postgres*, *mysql*, and *sqlite*, and is designed to be:
-
-  - *Reliable*, with co-transactional job enqueues and guaranteed, at-least-once execution
-  - *Scalable*, with an optimized pickup query and concurrent job execution
-  - *Resilient*, with built-in retry mechanisms, exponential backoff, and failed job preservation
-  - *Maintainable*, with robust instrumentation, continuous monitoring, and priority-based alerting
-
-  For an overview of how Betterment uses +delayed+ to build resilience into distributed systems, check
-  out the talk ✨{Can I break this?}[https://www.youtube.com/watch?v=TuhS13rBoVY]✨ given at RailsConf
-  2021!
+  Delayed is a multi-threaded, SQL-driven ActiveJob backend used at Betterment to process millions
+  of background jobs per day. It supports postgres, mysql, and sqlite, and is designed to be
+  Reliable (with co-transactional job enqueues and guaranteed, at-least-once execution), Scalable
+  (with an optimized pickup query and concurrent job execution), Resilient (with built-in retry
+  mechanisms, exponential backoff, and failed job preservation), and Maintainable (with robust
+  instrumentation, continuous monitoring, and priority-based alerting).
 email:
 - nathan@betterment.com
 executables: []
@@ -225,12 +233,13 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- app/models/delayed/job.rb
 - lib/delayed.rb
 - lib/delayed/active_job_adapter.rb
 - lib/delayed/backend/base.rb
 - lib/delayed/backend/job_preparer.rb
+- lib/delayed/engine.rb
 - lib/delayed/exceptions.rb
-- lib/delayed/job.rb
 - lib/delayed/lifecycle.rb
 - lib/delayed/message_sending.rb
 - lib/delayed/monitor.rb
@@ -241,7 +250,6 @@ files:
 - lib/delayed/plugins/instrumentation.rb
 - lib/delayed/priority.rb
 - lib/delayed/psych_ext.rb
-- lib/delayed/railtie.rb
 - lib/delayed/runnable.rb
 - lib/delayed/serialization/active_record.rb
 - lib/delayed/syck_ext.rb
@@ -282,6 +290,7 @@ metadata:
   changelog_uri: https://github.com/betterment/delayed/blob/main/CHANGELOG.md
   bug_tracker_uri: https://github.com/betterment/delayed/issues
   source_code_uri: https://github.com/betterment/delayed
+  rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -297,7 +306,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.25
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: a multi-threaded, SQL-driven ActiveJob backend used at Betterment to process