delayed_job 4.0.3 → 4.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f8464e2a78c559301360d0c083d940e73f314406
-  data.tar.gz: 819bd2dc775364ed9e6311be0a82fb3bdc20d6a6
+  metadata.gz: 458beb66285efe46237b4f094fc7eadbbecf3e79
+  data.tar.gz: 85e801616a1d8ad319b705386adcd602e3045234
 SHA512:
-  metadata.gz: c7d9b76c5f6244b37e79f2df7f5d5d270bd0769366ab0d93967ca02bd9ff434b98801ed92032815d0e0dd1abba5f9617881dd64aeabf09ed0700066f59985a3f
-  data.tar.gz: 3f99c1bcddf3c835a4eea9cd200b559d1d284d169633016e79b0303549583be78cdfd888671139fe83ecec669b140171bb255d3f4bf03eaa9a4a45ed2c2bc7e2
+  metadata.gz: e375922727337f1aa87d578715f5679b1edddc3c15f3505cfb8d084ef063eeeace708ee32c85291bff340996662751640c0627babe0e8c0beb3bb55856e83432
+  data.tar.gz: 9da95592d2f8999d8ddb7365234791a117641bba32edb13361ec177b6a2f4d094a75707be4bdbee0eeacb0f7015fd7e4b072a222d2bb074b95497f0524eee3be

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+4.0.4 - 2014-09-24
+==================
+* Fix using options passed into delayed_job command
+* Add the ability to set a default queue for a custom job
+* Add the ability to override the max_run_time on a custom job. MUST be lower than worker setting
+* Psych YAML overrides are now exclusively used only when loading a job payload
+* SLEEP_DELAY and READ_AHEAD can be set for the rake task
+* Some updates for Rails 4.2 support
+
 4.0.3 - 2014-09-04
 ==================
 * Added --pools option to delayed_job command

data/README.md

@@ -242,9 +242,11 @@ NewsletterJob = Struct.new(:text, :emails) do
   end
 end
 
-Delayed::Job.enqueue NewsletterJob.new('lorem ipsum...', Customers.find(:all).collect(&:email))
+Delayed::Job.enqueue NewsletterJob.new('lorem ipsum...', Customers.pluck(:email))
 ```
+
 To set a per-job max attempts that overrides the Delayed::Worker.max_attempts you can define a max_attempts method on the job
+
 ```ruby
 NewsletterJob = Struct.new(:text, :emails) do
   def perform
@@ -252,10 +254,40 @@ NewsletterJob = Struct.new(:text, :emails) do
   end
 
   def max_attempts
-    return 3
+    3
   end
 end
-````
+```
+
+To set a per-job max run time that overrides the Delayed::Worker.max_run_time you can define a max_run_time method on the job
+
+NOTE: this can ONLY be used to set a max_run_time that is lower than Delayed::Worker.max_run_time. Otherwise the lock on the job would expire and another worker would start the working on the in progress job.
+
+```ruby
+NewsletterJob = Struct.new(:text, :emails) do
+  def perform
+    emails.each { |e| NewsletterMailer.deliver_text_to_email(text, e) }
+  end
+
+  def max_run_time
+    120 # seconds
+  end
+end
+```
+
+To set a default queue name for a custom job that overrides Delayed::Worker.default_queue_name, you can define a queue_name method on the job
+
+```ruby
+NewsletterJob = Struct.new(:text, :emails) do
+  def perform
+    emails.each { |e| NewsletterMailer.deliver_text_to_email(text, e) }
+  end
+
+  def queue_name
+    'newsletter_queue'
+  end
+end
+```
 
 
 Hooks
@@ -332,6 +364,8 @@ By default all jobs will be queued without a named queue. A default named queue
 
 It is possible to disable delayed jobs for testing purposes. Set `Delayed::Worker.delay_jobs = false` to execute all jobs realtime.
 
+You may need to raise exceptions on SIGTERM signals, `Delayed::Worker.raise_signal_exceptions = :term` will cause the worker to raise a `SignalException` causing the running job to abort and be unlocked, which makes the job available to other workers. The default for this option is false.
+
 Here is an example of changing job parameters in Rails:
 
 ```ruby
@@ -343,6 +377,7 @@ Delayed::Worker.max_run_time = 5.minutes
 Delayed::Worker.read_ahead = 10
 Delayed::Worker.default_queue_name = 'default'
 Delayed::Worker.delay_jobs = !Rails.env.test?
+Delayed::Worker.raise_signal_exceptions = :term
 ```
 
 Cleaning up

data/delayed_job.gemspec

@@ -11,5 +11,5 @@ Gem::Specification.new do |spec|
   spec.require_paths  = ['lib']
   spec.summary        = 'Database-backed asynchronous priority queue system -- Extracted from Shopify'
   spec.test_files     = Dir.glob('spec/**/*')
-  spec.version        = '4.0.3'
+  spec.version        = '4.0.4'
 end

data/lib/delayed/backend/base.rb

@@ -7,13 +7,17 @@ module Delayed
 
       module ClassMethods
         # Add a job to the queue
-        def enqueue(*args)
-          options = {
-            :priority => Delayed::Worker.default_priority,
-            :queue => Delayed::Worker.default_queue_name
-          }.merge!(args.extract_options!)
-
+        def enqueue(*args) # rubocop:disable CyclomaticComplexity
+          options = args.extract_options!
           options[:payload_object] ||= args.shift
+          options[:priority]       ||= Delayed::Worker.default_priority
+
+          if options[:queue].nil?
+            if options[:payload_object].respond_to?(:queue_name)
+              options[:queue] = options[:payload_object].queue_name
+            end
+            options[:queue] ||= Delayed::Worker.default_queue_name
+          end
 
           if args.size > 0
             warn '[DEPRECATION] Passing multiple arguments to `#enqueue` is deprecated. Pass a hash with :priority and :run_at.'
@@ -25,16 +29,10 @@ module Delayed
             raise ArgumentError, 'Cannot enqueue items which do not respond to perform'
           end
 
-          if Delayed::Worker.delay_jobs
-            new(options).tap do |job|
-              Delayed::Worker.lifecycle.run_callbacks(:enqueue, job) do
-                job.hook(:enqueue)
-                job.save
-              end
-            end
-          else
-            Delayed::Job.new(:payload_object => options[:payload_object]).tap do |job|
-              job.invoke_job
+          new(options).tap do |job|
+            Delayed::Worker.lifecycle.run_callbacks(:enqueue, job) do
+              job.hook(:enqueue)
+              Delayed::Worker.delay_jobs ? job.save : job.invoke_job
             end
           end
         end
@@ -84,14 +82,8 @@ module Delayed
       end
 
       def payload_object
-        if YAML.respond_to?(:unsafe_load)
-          # See https://github.com/dtao/safe_yaml
-          # When the method is there, we need to load our YAML like this...
-          @payload_object ||= YAML.load(handler, :safe => false)
-        else
-          @payload_object ||= YAML.load(handler)
-        end
-      rescue TypeError, LoadError, NameError, ArgumentError => e
+        @payload_object ||= YAML.load_dj(handler)
+      rescue TypeError, LoadError, NameError, ArgumentError, SyntaxError, Psych::SyntaxError => e
         raise DeserializationError, "Job failed to load: #{e.message}. Handler: #{handler.inspect}"
       end
 
@@ -136,6 +128,17 @@ module Delayed
         payload_object.max_attempts if payload_object.respond_to?(:max_attempts)
       end
 
+      def max_run_time
+        return unless payload_object.respond_to?(:max_run_time)
+        return unless (run_time = payload_object.max_run_time)
+
+        if run_time > Delayed::Worker.max_run_time
+          Delayed::Worker.max_run_time
+        else
+          run_time
+        end
+      end
+
       def fail!
         update_attributes(:failed_at => self.class.db_time_now)
       end

data/lib/delayed/backend/shared_spec.rb

@@ -14,6 +14,7 @@ shared_examples_for 'a delayed_job backend' do
     Delayed::Worker.min_priority = nil
     Delayed::Worker.default_priority = 99
     Delayed::Worker.delay_jobs = true
+    Delayed::Worker.default_queue_name = 'default_tracking'
     SimpleJob.runs = 0
     described_class.delete_all
   end
@@ -62,9 +63,19 @@ shared_examples_for 'a delayed_job backend' do
       end
 
       it 'is able to set queue' do
-        job = described_class.enqueue :payload_object => SimpleJob.new, :queue => 'tracking'
+        job = described_class.enqueue :payload_object => NamedQueueJob.new, :queue => 'tracking'
         expect(job.queue).to eq('tracking')
       end
+
+      it 'uses default queue' do
+        job = described_class.enqueue :payload_object => SimpleJob.new
+        expect(job.queue).to eq(Delayed::Worker.default_queue_name)
+      end
+
+      it "uses the payload object's queue" do
+        job = described_class.enqueue :payload_object => NamedQueueJob.new
+        expect(job.queue).to eq(NamedQueueJob.new.queue_name)
+      end
     end
 
     context 'with multiple arguments' do
@@ -175,9 +186,17 @@ shared_examples_for 'a delayed_job backend' do
 
     it 'raises a DeserializationError when the YAML.load raises argument error' do
       job = described_class.new :handler => '--- !ruby/struct:GoingToRaiseArgError {}'
-      expect(YAML).to receive(:load).and_raise(ArgumentError)
+      expect(YAML).to receive(:load_dj).and_raise(ArgumentError)
       expect { job.payload_object }.to raise_error(Delayed::DeserializationError)
     end
+
+    it 'raises a DeserializationError when the YAML.load raises syntax error' do
+      # only test with Psych since the other YAML parsers don't raise a SyntaxError
+      if YAML.parser.class.name !~ /syck|yecht/i
+        job = described_class.new :handler => 'message: "no ending quote'
+        expect { job.payload_object }.to raise_error(Delayed::DeserializationError)
+      end
+    end
   end
 
   describe 'reserve' do
@@ -398,25 +417,58 @@ shared_examples_for 'a delayed_job backend' do
       expect(@job.max_attempts).to be_nil
     end
 
-    it 'uses the max_retries value on the payload when defined' do
+    it 'uses the max_attempts value on the payload when defined' do
       expect(@job.payload_object).to receive(:max_attempts).and_return(99)
       expect(@job.max_attempts).to eq(99)
     end
   end
 
+  describe '#max_run_time' do
+    before(:each) { @job = described_class.enqueue SimpleJob.new }
+
+    it 'is not defined' do
+      expect(@job.max_run_time).to be_nil
+    end
+
+    it 'results in a default run time when not defined' do
+      expect(worker.max_run_time(@job)).to eq(Delayed::Worker::DEFAULT_MAX_RUN_TIME)
+    end
+
+    it 'uses the max_run_time value on the payload when defined' do
+      expect(@job.payload_object).to receive(:max_run_time).and_return(30.minutes)
+      expect(@job.max_run_time).to eq(30.minutes)
+    end
+
+    it 'results in an overridden run time when defined' do
+      expect(@job.payload_object).to receive(:max_run_time).and_return(45.minutes)
+      expect(worker.max_run_time(@job)).to eq(45.minutes)
+    end
+
+    it 'job set max_run_time can not exceed default max run time' do
+      expect(@job.payload_object).to receive(:max_run_time).and_return(Delayed::Worker::DEFAULT_MAX_RUN_TIME + 60)
+      expect(worker.max_run_time(@job)).to eq(Delayed::Worker::DEFAULT_MAX_RUN_TIME)
+    end
+  end
+
   describe 'yaml serialization' do
     context 'when serializing jobs' do
       it 'raises error ArgumentError for new records' do
         story = Story.new(:text => 'hello')
         if story.respond_to?(:new_record?)
-          expect { story.delay.tell }.to raise_error(ArgumentError, 'Jobs cannot be created for non-persisted records')
+          expect { story.delay.tell }.to raise_error(
+            ArgumentError,
+            "job cannot be created for non-persisted record: #{story.inspect}"
+          )
         end
       end
 
       it 'raises error ArgumentError for destroyed records' do
         story = Story.create(:text => 'hello')
         story.destroy
-        expect { story.delay.tell }.to raise_error(ArgumentError, 'Jobs cannot be created for non-persisted records')
+        expect { story.delay.tell }.to raise_error(
+          ArgumentError,
+          "job cannot be created for non-persisted record: #{story.inspect}"
+        )
       end
     end
 

data/lib/delayed/command.rb

@@ -109,7 +109,7 @@ module Delayed
       Delayed::Worker.before_fork
       Daemons.run_proc(process_name, :dir => options[:pid_dir], :dir_mode => :normal, :monitor => @monitor, :ARGV => @args) do |*_args|
         $0 = File.join(options[:prefix], process_name) if @options[:prefix]
-        run process_name
+        run process_name, options
       end
     end
 

data/lib/delayed/performable_mailer.rb

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

data/lib/delayed/performable_method.rb

@@ -10,7 +10,7 @@ module Delayed
       raise NoMethodError, "undefined method `#{method_name}' for #{object.inspect}" unless object.respond_to?(method_name, true)
 
       if object.respond_to?(:persisted?) && !object.persisted?
-        raise ArgumentError, 'Jobs cannot be created for non-persisted records'
+        raise(ArgumentError, "job cannot be created for non-persisted record: #{object.inspect}")
       end
 
       self.object       = object
@@ -19,7 +19,11 @@ module Delayed
     end
 
     def display_name
-      "#{object.class}##{method_name}"
+      if object.is_a?(Class)
+        "#{object}.#{method_name}"
+      else
+        "#{object.class}##{method_name}"
+      end
     end
 
     def perform

data/lib/delayed/psych_ext.rb

@@ -1,22 +1,3 @@
-if defined?(ActiveRecord)
-  ActiveRecord::Base.class_eval do
-    # rubocop:disable BlockNesting
-    if instance_methods.include?(:encode_with)
-      def encode_with_override(coder)
-        encode_with_without_override(coder)
-        coder.tag = "!ruby/ActiveRecord:#{self.class.name}" if coder.respond_to?(:tag=)
-      end
-      alias_method :encode_with_without_override, :encode_with
-      alias_method :encode_with, :encode_with_override
-    else
-      def encode_with(coder)
-        coder['attributes'] = attributes
-        coder.tag = "!ruby/ActiveRecord:#{self.class.name}" if coder.respond_to?(:tag=)
-      end
-    end
-  end
-end
-
 module Delayed
   class PerformableMethod
     # serialize to YAML
@@ -31,16 +12,41 @@ module Delayed
 end
 
 module Psych
-  module Visitors
-    class ToRuby
-      def visit_Psych_Nodes_Mapping_with_class(object) # rubocop:disable CyclomaticComplexity, MethodName
+  def self.load_dj(yaml)
+    result = parse(yaml)
+    result ? Delayed::PsychExt::ToRuby.create.accept(result) : result
+  end
+end
+
+module Delayed
+  module PsychExt
+    class ToRuby < Psych::Visitors::ToRuby
+      unless respond_to?(:create)
+        def self.create
+          new
+        end
+      end
+
+      def visit_Psych_Nodes_Mapping(object) # rubocop:disable CyclomaticComplexity, MethodName, PerceivedComplexity
         return revive(Psych.load_tags[object.tag], object) if Psych.load_tags[object.tag]
 
         case object.tag
+        when /^!ruby\/object/
+          result = super
+          if defined?(ActiveRecord::Base) && result.is_a?(ActiveRecord::Base)
+            begin
+              result.class.find(result[result.class.primary_key])
+            rescue ActiveRecord::RecordNotFound => error # rubocop:disable BlockNesting
+              raise Delayed::DeserializationError, "ActiveRecord::RecordNotFound, class: #{klass}, primary key: #{id} (#{error.message})"
+            end
+          else
+            result
+          end
         when /^!ruby\/ActiveRecord:(.+)$/
           klass = resolve_class(Regexp.last_match[1])
           payload = Hash[*object.children.map { |c| accept c }]
           id = payload['attributes'][klass.primary_key]
+          id = id.value if defined?(ActiveRecord::Attribute) && id.is_a?(ActiveRecord::Attribute)
           begin
             klass.unscoped.find(id)
           rescue ActiveRecord::RecordNotFound => error
@@ -66,17 +72,16 @@ module Psych
             raise Delayed::DeserializationError, "DataMapper::ObjectNotFoundError, class: #{klass} (#{error.message})"
           end
         else
-          visit_Psych_Nodes_Mapping_without_class(object)
+          super
         end
       end
-      alias_method_chain :visit_Psych_Nodes_Mapping, :class
 
-      def resolve_class_with_constantize(klass_name)
+      def resolve_class(klass_name)
+        return nil if !klass_name || klass_name.empty?
         klass_name.constantize
       rescue
-        resolve_class_without_constantize(klass_name)
+        super
       end
-      alias_method_chain :resolve_class, :constantize
     end
   end
 end

data/lib/delayed/railtie.rb

@@ -7,6 +7,12 @@ module Delayed
       ActiveSupport.on_load(:action_mailer) do
         ActionMailer::Base.extend(Delayed::DelayMail)
       end
+
+      Delayed::Worker.logger = if defined?(Rails)
+        Rails.logger
+      elsif defined?(RAILS_DEFAULT_LOGGER)
+        RAILS_DEFAULT_LOGGER
+      end
     end
 
     rake_tasks do

data/lib/delayed/recipes.rb

@@ -38,7 +38,7 @@ Capistrano::Configuration.instance.load do
 
     desc 'Stop the delayed_job process'
     task :stop, :roles => lambda { roles } do
-      run "cd #{current_path};#{rails_env} #{delayed_job_command} stop"
+      run "cd #{current_path};#{rails_env} #{delayed_job_command} stop #{args}"
     end
 
     desc 'Start the delayed_job process'

data/lib/delayed/syck_ext.rb

@@ -32,3 +32,11 @@ class Struct
     "Struct::#{ name }"
   end
 end
+
+module YAML
+  def load_dj(yaml)
+    # See https://github.com/dtao/safe_yaml
+    # When the method is there, we need to load our YAML like this...
+    respond_to?(:unsafe_load) ? load(yaml, :safe => false) : load(yaml)
+  end
+end

data/lib/delayed/tasks.rb

@@ -21,6 +21,9 @@ namespace :jobs do
       :queues => (ENV['QUEUES'] || ENV['QUEUE'] || '').split(','),
       :quiet => false
     }
+
+    @worker_options[:sleep_delay] = ENV['SLEEP_DELAY'].to_i if ENV['SLEEP_DELAY']
+    @worker_options[:read_ahead] = ENV['READ_AHEAD'].to_i if ENV['READ_AHEAD']
   end
 
   desc "Exit with error status if any jobs older than max_age seconds haven't been attempted yet."

data/lib/delayed/worker.rb

@@ -19,7 +19,8 @@ module Delayed
 
     cattr_accessor :min_priority, :max_priority, :max_attempts, :max_run_time,
                    :default_priority, :sleep_delay, :logger, :delay_jobs, :queues,
-                   :read_ahead, :plugins, :destroy_failed_jobs, :exit_on_complete
+                   :read_ahead, :plugins, :destroy_failed_jobs, :exit_on_complete,
+                   :default_log_level
 
     # Named queue into which jobs are enqueued by default
     cattr_accessor :default_queue_name
@@ -30,13 +31,14 @@ module Delayed
     attr_accessor :name_prefix
 
     def self.reset
-      self.sleep_delay      = DEFAULT_SLEEP_DELAY
-      self.max_attempts     = DEFAULT_MAX_ATTEMPTS
-      self.max_run_time     = DEFAULT_MAX_RUN_TIME
-      self.default_priority = DEFAULT_DEFAULT_PRIORITY
-      self.delay_jobs       = DEFAULT_DELAY_JOBS
-      self.queues           = DEFAULT_QUEUES
-      self.read_ahead       = DEFAULT_READ_AHEAD
+      self.default_log_level = DEFAULT_LOG_LEVEL
+      self.sleep_delay       = DEFAULT_SLEEP_DELAY
+      self.max_attempts      = DEFAULT_MAX_ATTEMPTS
+      self.max_run_time      = DEFAULT_MAX_RUN_TIME
+      self.default_priority  = DEFAULT_DEFAULT_PRIORITY
+      self.delay_jobs        = DEFAULT_DELAY_JOBS
+      self.queues            = DEFAULT_QUEUES
+      self.read_ahead        = DEFAULT_READ_AHEAD
     end
 
     reset
@@ -57,12 +59,6 @@ module Delayed
     cattr_accessor :raise_signal_exceptions
     self.raise_signal_exceptions = false
 
-    self.logger = if defined?(Rails)
-      Rails.logger
-    elsif defined?(RAILS_DEFAULT_LOGGER)
-      RAILS_DEFAULT_LOGGER
-    end
-
     def self.backend=(backend)
       if backend.is_a? Symbol
         require "delayed/serialization/#{backend}"
@@ -130,13 +126,13 @@ module Delayed
 
     def start # rubocop:disable CyclomaticComplexity, PerceivedComplexity
       trap('TERM') do
-        say 'Exiting...'
+        Thread.new { say 'Exiting...' }
         stop
         raise SignalException, 'TERM' if self.class.raise_signal_exceptions
       end
 
       trap('INT') do
-        say 'Exiting...'
+        Thread.new { say 'Exiting...' }
         stop
         raise SignalException, 'INT' if self.class.raise_signal_exceptions && self.class.raise_signal_exceptions != :term
       end
@@ -200,7 +196,7 @@ module Delayed
     def run(job)
       job_say job, 'RUNNING'
       runtime =  Benchmark.realtime do
-        Timeout.timeout(self.class.max_run_time.to_i, WorkerTimeout) { job.invoke_job }
+        Timeout.timeout(max_run_time(job).to_i, WorkerTimeout) { job.invoke_job }
         job.destroy
       end
       job_say job, format('COMPLETED after %.4f', runtime)
@@ -240,12 +236,12 @@ module Delayed
       end
     end
 
-    def job_say(job, text, level = DEFAULT_LOG_LEVEL)
+    def job_say(job, text, level = default_log_level)
       text = "Job #{job.name} (id=#{job.id}) #{text}"
       say text, level
     end
 
-    def say(text, level = DEFAULT_LOG_LEVEL)
+    def say(text, level = default_log_level)
       text = "[Worker(#{name})] #{text}"
       puts text unless @quiet
       return unless logger
@@ -260,6 +256,10 @@ module Delayed
       job.max_attempts || self.class.max_attempts
     end
 
+    def max_run_time(job)
+      job.max_run_time || self.class.max_run_time
+    end
+
   protected
 
     def handle_failed_job(job, error)

data/lib/generators/delayed_job/delayed_job_generator.rb

@@ -1,4 +1,4 @@
-require 'rails/generators'
+require 'rails/generators/base'
 require 'delayed/compatibility'
 
 class DelayedJobGenerator < Rails::Generators::Base

data/spec/helper.rb

@@ -20,9 +20,20 @@ require 'active_record'
 require 'delayed_job'
 require 'delayed/backend/shared_spec'
 
-Delayed::Worker.logger = Logger.new('/tmp/dj.log')
+if ENV['DEBUG_LOGS']
+  Delayed::Worker.logger = Logger.new(STDOUT)
+else
+  require 'tempfile'
+
+  tf = Tempfile.new('dj.log')
+  Delayed::Worker.logger = Logger.new(tf.path)
+  tf.unlink
+end
 ENV['RAILS_ENV'] = 'test'
 
+# Trigger AR to initialize
+ActiveRecord::Base # rubocop:disable Void
+
 module Rails
   def self.root
     '.'

data/spec/performable_method_spec.rb

@@ -37,6 +37,16 @@ describe Delayed::PerformableMethod do
     expect { Delayed::PerformableMethod.new(clazz.new, :private_method, []) }.not_to raise_error
   end
 
+  describe 'display_name' do
+    it 'returns class_name#method_name for instance methods' do
+      expect(Delayed::PerformableMethod.new('foo', :count, ['o']).display_name).to eq('String#count')
+    end
+
+    it 'returns class_name.method_name for class methods' do
+      expect(Delayed::PerformableMethod.new(Class, :inspect, []).display_name).to eq('Class.inspect')
+    end
+  end
+
   describe 'hooks' do
     %w[before after success].each do |hook|
       it "delegates #{hook} hook to object" do

data/spec/sample_jobs.rb

@@ -12,6 +12,12 @@ class SimpleJob
   end
 end
 
+class NamedQueueJob < SimpleJob
+  def queue_name
+    'job_tracking'
+  end
+end
+
 class ErrorJob
   cattr_accessor :runs
   @runs = 0

data/spec/worker_spec.rb

@@ -29,7 +29,15 @@ describe Delayed::Worker do
 
     it 'logs with job name and id' do
       expect(@worker).to receive(:say).
-        with('Job ExampleJob (id=123) message', Delayed::Worker::DEFAULT_LOG_LEVEL)
+        with('Job ExampleJob (id=123) message', Delayed::Worker.default_log_level)
+      @worker.job_say(@job, 'message')
+    end
+
+    it 'has a configurable default log level' do
+      Delayed::Worker.default_log_level = 'error'
+
+      expect(@worker).to receive(:say).
+        with('Job ExampleJob (id=123) message', 'error')
       @worker.job_say(@job, 'message')
     end
   end
@@ -140,10 +148,10 @@ describe Delayed::Worker do
       it_behaves_like 'a worker which logs on the correct severity', severity
     end
 
-    it "logs a message on the default log's level" do
+    it 'logs a message on the default log\'s level' do
       expect(@worker.logger).to receive(:send).
         with('info', "#{@expected_time}: #{@worker_name} #{@text}")
-      @worker.say(@text, Delayed::Worker::DEFAULT_LOG_LEVEL)
+      @worker.say(@text, Delayed::Worker.default_log_level)
     end
   end
 end

data/spec/yaml_ext_spec.rb

@@ -4,32 +4,45 @@ describe 'YAML' do
   it 'autoloads classes' do
     expect do
       yaml = "--- !ruby/class Autoloaded::Clazz\n"
-      expect(YAML.load(yaml)).to eq(Autoloaded::Clazz)
+      expect(load_with_delayed_visitor(yaml)).to eq(Autoloaded::Clazz)
     end.not_to raise_error
   end
 
   it 'autoloads the class of a struct' do
     expect do
       yaml = "--- !ruby/class Autoloaded::Struct\n"
-      expect(YAML.load(yaml)).to eq(Autoloaded::Struct)
+      expect(load_with_delayed_visitor(yaml)).to eq(Autoloaded::Struct)
     end.not_to raise_error
   end
 
   it 'autoloads the class for the instance of a struct' do
     expect do
       yaml = '--- !ruby/struct:Autoloaded::InstanceStruct {}'
-      expect(YAML.load(yaml).class).to eq(Autoloaded::InstanceStruct)
+      expect(load_with_delayed_visitor(yaml).class).to eq(Autoloaded::InstanceStruct)
+    end.not_to raise_error
+  end
+
+  it 'autoloads the class of an anonymous struct' do
+    expect do
+      yaml = "--- !ruby/struct\nn: 1\n"
+      object = YAML.load(yaml)
+      expect(object).to be_kind_of(Struct)
+      expect(object.n).to eq(1)
     end.not_to raise_error
   end
 
   it 'autoloads the class for the instance' do
     expect do
       yaml = "--- !ruby/object:Autoloaded::InstanceClazz {}\n"
-      expect(YAML.load(yaml).class).to eq(Autoloaded::InstanceClazz)
+      expect(load_with_delayed_visitor(yaml).class).to eq(Autoloaded::InstanceClazz)
     end.not_to raise_error
   end
 
   it 'does not throw an uninitialized constant Syck::Syck when using YAML.load with poorly formed yaml' do
     expect { YAML.load(YAML.dump('foo: *bar')) }.not_to raise_error
   end
+
+  def load_with_delayed_visitor(yaml)
+    YAML.load_dj(yaml)
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: delayed_job
 version: !ruby/object:Gem::Version
-  version: 4.0.3
+  version: 4.0.4
 platform: ruby
 authors:
 - Brandon Keepers
@@ -15,7 +15,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-04 00:00:00.000000000 Z
+date: 2014-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport