delayed_job 1.8.4 → 1.8.5

data/README.textile

@@ -17,8 +17,7 @@ h2. Installation
 To install as a gem, add the following to @config/environment.rb@:
 
 <pre>
-config.gem 'collectiveidea-delayed_job', :lib => 'delayed_job',
-  :source => 'http://gems.github.com'
+config.gem 'delayed_job'
 </pre>
 
 Rake tasks are not automatically loaded from gems, so you'll need to add the following to your Rakefile:
@@ -118,7 +117,7 @@ The library evolves around a delayed_jobs table which looks as follows:
     table.integer  :attempts, :default => 0      # Provides for retries, but still fail eventually.
     table.text     :handler                      # YAML-encoded string of the object that will do work
     table.text   :last_error                   # reason for last failure (See Note below)
-    table.datetime :run_at                       # When to run. Could be Time.now for immediately, or sometime in the future.
+    table.datetime :run_at                       # When to run. Could be Time.zone.now for immediately, or sometime in the future.
     table.datetime :locked_at                    # Set when a client is working on this object
     table.datetime :failed_at                    # Set when all retries have failed (actually, by default, the record is deleted instead)
     table.string   :locked_by                    # Who is working on this object (if locked)
@@ -127,10 +126,10 @@ The library evolves around a delayed_jobs table which looks as follows:
 
 On failure, the job is scheduled again in 5 seconds + N ** 4, where N is the number of retries.
 
-The default MAX_ATTEMPTS is 25. After this, the job either deleted (default), or left in the database with "failed_at" set.
+The default Job::max_attempts is 25. After this, the job either deleted (default), or left in the database with "failed_at" set.
 With the default of 25 attempts, the last retry will be 20 days later, with the last interval being almost 100 hours.
 
-The default MAX_RUN_TIME is 4.hours. If your job takes longer than that, another computer could pick it up. It's up to you to
+The default Job::max_run_time is 4.hours. If your job takes longer than that, another computer could pick it up. It's up to you to
 make sure your job doesn't exceed this time. You should set this to the longest time you think the job could take.
 
 By default, it will delete failed jobs (and it always deletes successful jobs). If you want to keep failed jobs, set
@@ -142,8 +141,9 @@ Here is an example of changing job parameters in Rails:
 # config/initializers/delayed_job_config.rb
 Delayed::Job.destroy_failed_jobs = false
 silence_warnings do
-  Delayed::Job.const_set("MAX_ATTEMPTS", 3)
-  Delayed::Job.const_set("MAX_RUN_TIME", 5.minutes)
+  Delayed::Worker::sleep_delay = 60
+  Delayed::Job::max_attempts = 3
+  Delayed::Job::max_run_time = 5.minutes
 end
 </pre>
 

data/Rakefile

@@ -2,7 +2,7 @@
 begin
   require 'jeweler'
 rescue LoadError
-  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+  puts "Jeweler not available. Install it with: sudo gem install jeweler"
   exit 1
 end
 

data/VERSION

@@ -1 +1 @@
-1.8.4
+1.8.5

data/contrib/delayed_job.monitrc

@@ -10,5 +10,5 @@
 
 check process delayed_job
   with pidfile /var/www/apps/{app_name}/shared/pids/delayed_job.pid
-  start program = "RAILS_ENV=production /var/www/apps/{app_name}/current/script/delayed_job start"
-  stop program = "RAILS_ENV=production /var/www/apps/{app_name}/current/script/delayed_job stop"
+  start program = "/usr/bin/env RAILS_ENV=production /var/www/apps/{app_name}/current/script/delayed_job start"
+  stop program = "/usr/bin/env RAILS_ENV=production /var/www/apps/{app_name}/current/script/delayed_job stop"

data/delayed_job.gemspec

@@ -1,15 +1,15 @@
 # Generated by jeweler
-# DO NOT EDIT THIS FILE
-# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
   s.name = %q{delayed_job}
-  s.version = "1.8.4"
+  s.version = "1.8.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Brandon Keepers", "Tobias L\303\274tke"]
-  s.date = %q{2009-10-06}
+  s.date = %q{2010-03-15}
   s.description = %q{Delayed_job (or DJ) encapsulates the common pattern of asynchronously executing longer tasks in the background. It is a direct extraction from Shopify where the job table is responsible for a multitude of core tasks.}
   s.email = %q{tobi@leetsoft.com}
   s.extra_rdoc_files = [
@@ -64,3 +64,4 @@ Gem::Specification.new do |s|
   else
   end
 end
+

data/generators/delayed_job/templates/migration.rb

@@ -5,7 +5,7 @@ class CreateDelayedJobs < ActiveRecord::Migration
       table.integer  :attempts, :default => 0      # Provides for retries, but still fail eventually.
       table.text     :handler                      # YAML-encoded string of the object that will do work
       table.text     :last_error                   # reason for last failure (See Note below)
-      table.datetime :run_at                       # When to run. Could be Time.now for immediately, or sometime in the future.
+      table.datetime :run_at                       # When to run. Could be Time.zone.now for immediately, or sometime in the future.
       table.datetime :locked_at                    # Set when a client is working on this object
       table.datetime :failed_at                    # Set when all retries have failed (actually, by default, the record is deleted instead)
       table.string   :locked_by                    # Who is working on this object (if locked)

data/lib/delayed/command.rb

@@ -54,13 +54,16 @@ module Delayed
       # Re-open file handles
       @files_to_reopen.each do |file|
         begin
-          file.reopen File.join(RAILS_ROOT, 'log', 'delayed_job.log'), 'w+'
+          file.reopen File.join(RAILS_ROOT, 'log', 'delayed_job.log'), 'a+'
           file.sync = true
         rescue ::Exception
         end
       end
       
       Delayed::Worker.logger = Rails.logger
+      if Delayed::Worker.logger.respond_to? :auto_flushing=
+        Delayed::Worker.logger.auto_flushing = true
+      end
       ActiveRecord::Base.connection.reconnect!
       
       Delayed::Job.worker_name = "#{worker_name} #{Delayed::Job.worker_name}"

data/lib/delayed/job.rb

@@ -8,8 +8,11 @@ module Delayed
   # A job object that is persisted to the database.
   # Contains the work object as a YAML field.
   class Job < ActiveRecord::Base
-    MAX_ATTEMPTS = 25
-    MAX_RUN_TIME = 4.hours
+    @@max_attempts = 25
+    @@max_run_time = 4.hours
+    
+    cattr_accessor :max_attempts, :max_run_time
+    
     set_table_name :delayed_jobs
 
     # By default failed jobs are destroyed after too many attempts.
@@ -21,8 +24,24 @@ module Delayed
     # Every worker has a unique name which by default is the pid of the process.
     # There are some advantages to overriding this with something which survives worker retarts:
     # Workers can safely resume working on tasks which are locked by themselves. The worker will assume that it crashed before.
-    cattr_accessor :worker_name
-    self.worker_name = "host:#{Socket.gethostname} pid:#{Process.pid}" rescue "pid:#{Process.pid}"
+    @@worker_name = nil
+
+    def self.worker_name
+      return @@worker_name unless @@worker_name.nil?
+      "host:#{Socket.gethostname} pid:#{Process.pid}" rescue "pid:#{Process.pid}"
+    end
+
+    def self.worker_name=(val)
+      @@worker_name = val
+    end
+
+    def worker_name
+      self.class.worker_name
+    end
+
+    def worker_name=(val)
+      @@worker_name = val
+    end
 
     NextTaskSQL         = '(run_at <= ? AND (locked_at IS NULL OR locked_at < ?) OR (locked_by = ?)) AND failed_at IS NULL'
     NextTaskOrder       = 'priority DESC, run_at ASC'
@@ -65,16 +84,17 @@ module Delayed
     # Reschedule the job in the future (when a job fails).
     # Uses an exponential scale depending on the number of failed attempts.
     def reschedule(message, backtrace = [], time = nil)
-      if (self.attempts += 1) < MAX_ATTEMPTS
+      self.last_error   = message + "\n" + backtrace.join("\n")
+
+      if (self.attempts += 1) < max_attempts
         time ||= Job.db_time_now + (attempts ** 4) + 5
 
         self.run_at       = time
-        self.last_error   = message + "\n" + backtrace.join("\n")
         self.unlock
         save!
       else
-        logger.info "* [JOB] PERMANENTLY removing #{self.name} because of #{attempts} consequetive failures."
-        destroy_failed_jobs ? destroy : update_attribute(:failed_at, Time.now)
+        logger.info "* [JOB] PERMANENTLY removing #{self.name} because of #{attempts} consecutive failures."
+        destroy_failed_jobs ? destroy : update_attribute(:failed_at, Delayed::Job.db_time_now)
       end
     end
 
@@ -118,7 +138,7 @@ module Delayed
     end
 
     # Find a few candidate jobs to run (in case some immediately get locked by others).
-    def self.find_available(limit = 5, max_run_time = MAX_RUN_TIME)
+    def self.find_available(limit = 5, max_run_time = max_run_time)
 
       time_now = db_time_now
 
@@ -145,7 +165,7 @@ module Delayed
 
     # Run the next job we can get an exclusive lock on.
     # If no jobs are left we return nil
-    def self.reserve_and_run_one_job(max_run_time = MAX_RUN_TIME)
+    def self.reserve_and_run_one_job(max_run_time = max_run_time)
 
       # We get up to 5 jobs from the db. In case we cannot get exclusive access to a job we try the next.
       # this leads to a more even distribution of jobs across the worker processes
@@ -247,7 +267,7 @@ module Delayed
     # Note: This does not ping the DB to get the time, so all your clients
     # must have syncronized clocks.
     def self.db_time_now
-      (ActiveRecord::Base.default_timezone == :utc) ? Time.now.utc : Time.now
+      (ActiveRecord::Base.default_timezone == :utc) ? Time.now.utc : Time.zone.now
     end
 
   protected

data/lib/delayed/performable_method.rb

@@ -4,7 +4,7 @@ module Delayed
     AR_STRING_FORMAT    = /^AR\:([A-Z][\w\:]+)\:(\d+)$/
 
     def initialize(object, method, args)
-      raise NoMethodError, "undefined method `#{method}' for #{self.inspect}" unless object.respond_to?(method)
+      raise NoMethodError, "undefined method `#{method}' for #{object.inspect}" unless object.respond_to?(method)
 
       self.object = dump(object)
       self.args   = args.map { |a| dump(a) }

data/lib/delayed/recipes.rb

@@ -9,19 +9,23 @@
 
 Capistrano::Configuration.instance.load do
   namespace :delayed_job do
+    def rails_env
+      fetch(:rails_env, false) ? "RAILS_ENV=#{fetch(:rails_env)}" : ''
+    end
+    
     desc "Stop the delayed_job process"
     task :stop, :roles => :app do
-      run "cd #{current_path}; RAILS_ENV=#{rails_env} script/delayed_job stop"
+      run "cd #{current_path};#{rails_env} script/delayed_job stop"
     end
 
     desc "Start the delayed_job process"
     task :start, :roles => :app do
-      run "cd #{current_path}; RAILS_ENV=#{rails_env} script/delayed_job start"
+      run "cd #{current_path};#{rails_env} script/delayed_job start"
     end
 
     desc "Restart the delayed_job process"
     task :restart, :roles => :app do
-      run "cd #{current_path}; RAILS_ENV=#{rails_env} script/delayed_job restart"
+      run "cd #{current_path};#{rails_env} script/delayed_job restart"
     end
   end
 end

data/lib/delayed/worker.rb

@@ -1,6 +1,8 @@
 module Delayed
   class Worker
-    SLEEP = 5
+    @@sleep_delay = 5
+    
+    cattr_accessor :sleep_delay
 
     cattr_accessor :logger
     self.logger = if defined?(Merb::Logger)
@@ -33,7 +35,7 @@ module Delayed
         break if $exit
 
         if count.zero?
-          sleep(SLEEP)
+          sleep(@@sleep_delay)
         else
           say "#{count} jobs processed at %.4f j/s, %d failed ..." % [count / realtime, result.last]
         end

data/spec/database.rb

@@ -11,6 +11,7 @@ require 'spec'
 ActiveRecord::Base.logger = Logger.new('/tmp/dj.log')
 ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => '/tmp/jobs.sqlite')
 ActiveRecord::Migration.verbose = false
+ActiveRecord::Base.default_timezone = :utc if Time.zone.nil?
 
 ActiveRecord::Schema.define do
 

data/spec/job_spec.rb

@@ -58,7 +58,7 @@ describe Delayed::Job do
   end
 
   it "should be able to set run_at when enqueuing items" do
-    later = 5.minutes.from_now
+    later = (Delayed::Job.db_time_now+5.minutes)
     Delayed::Job.enqueue SimpleJob.new, 5, later
 
     # use be close rather than equal to because millisecond values cn be lost in DB round trip
@@ -111,6 +111,19 @@ describe Delayed::Job do
     job.run_at.should < Delayed::Job.db_time_now + 10.minutes
   end
 
+  it "should record last_error when destroy_failed_jobs = false, max_attempts = 1" do
+    Delayed::Job.destroy_failed_jobs = false
+    Delayed::Job::max_attempts = 1
+    job = Delayed::Job.enqueue ErrorJob.new
+    Delayed::Job.work_off
+    job.reload
+    job.last_error.should =~ /did not work/
+    job.last_error.should =~ /job_spec.rb/
+    job.attempts.should == 1
+
+    job.failed_at.should_not == nil
+  end
+
   it "should raise an DeserializationError when the job class is totally unknown" do
 
     job = Delayed::Job.new
@@ -162,14 +175,14 @@ describe Delayed::Job do
         Delayed::Job.destroy_failed_jobs = true
       end
       
-      it "should be destroyed if it failed more than MAX_ATTEMPTS times" do
+      it "should be destroyed if it failed more than Job::max_attempts times" do
         @job.should_receive(:destroy)
-        Delayed::Job::MAX_ATTEMPTS.times { @job.reschedule 'FAIL' }
+        Delayed::Job::max_attempts.times { @job.reschedule 'FAIL' }
       end
       
-      it "should not be destroyed if failed fewer than MAX_ATTEMPTS times" do
+      it "should not be destroyed if failed fewer than Job::max_attempts times" do
         @job.should_not_receive(:destroy)
-        (Delayed::Job::MAX_ATTEMPTS - 1).times { @job.reschedule 'FAIL' }
+        (Delayed::Job::max_attempts - 1).times { @job.reschedule 'FAIL' }
       end
     end
     
@@ -178,21 +191,21 @@ describe Delayed::Job do
         Delayed::Job.destroy_failed_jobs = false
       end
       
-      it "should be failed if it failed more than MAX_ATTEMPTS times" do
+      it "should be failed if it failed more than Job::max_attempts times" do
         @job.reload.failed_at.should == nil
-        Delayed::Job::MAX_ATTEMPTS.times { @job.reschedule 'FAIL' }
+        Delayed::Job::max_attempts.times { @job.reschedule 'FAIL' }
         @job.reload.failed_at.should_not == nil
       end
 
-      it "should not be failed if it failed fewer than MAX_ATTEMPTS times" do
-        (Delayed::Job::MAX_ATTEMPTS - 1).times { @job.reschedule 'FAIL' }
+      it "should not be failed if it failed fewer than Job::max_attempts times" do
+        (Delayed::Job::max_attempts - 1).times { @job.reschedule 'FAIL' }
         @job.reload.failed_at.should == nil
       end
       
     end
   end
   
-  it "should fail after MAX_RUN_TIME" do
+  it "should fail after Job::max_run_time" do
     @job = Delayed::Job.create :payload_object => LongRunningJob.new
     Delayed::Job.reserve_and_run_one_job(1.second)
     @job.reload.last_error.should =~ /expired/
@@ -200,7 +213,7 @@ describe Delayed::Job do
   end
 
   it "should never find failed jobs" do
-    @job = Delayed::Job.create :payload_object => SimpleJob.new, :attempts => 50, :failed_at => Time.now
+    @job = Delayed::Job.create :payload_object => SimpleJob.new, :attempts => 50, :failed_at => Delayed::Job.db_time_now
     Delayed::Job.find_available(1).length.should == 0
   end
 
@@ -262,7 +275,7 @@ describe Delayed::Job do
     end
 
     it "should not allow a second worker to get exclusive access if failed to be processed by worker1 and run_at time is now in future (due to backing off behaviour)" do
-      @job.update_attributes(:attempts => 1, :run_at => Time.now + 1.day)
+      @job.update_attributes(:attempts => 1, :run_at => 1.day.from_now)
       @job_copy_for_worker_2.lock_exclusively!(4.hours, 'worker2').should == false
     end
   end
@@ -379,7 +392,7 @@ describe Delayed::Job do
   context "while running with locked and expired jobs, it" do
     before(:each) do
       Delayed::Job.worker_name = 'worker1'
-      exp_time = Delayed::Job.db_time_now - (1.minutes + Delayed::Job::MAX_RUN_TIME)
+      exp_time = Delayed::Job.db_time_now - (1.minutes + Delayed::Job::max_run_time)
       Delayed::Job.create(:payload_object => SimpleJob.new, :locked_by => 'worker1', :locked_at => exp_time)
       Delayed::Job.create(:payload_object => SimpleJob.new, :locked_by => 'worker2', :locked_at => (Delayed::Job.db_time_now - 1.minutes))
       Delayed::Job.create(:payload_object => SimpleJob.new)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: delayed_job
 version: !ruby/object:Gem::Version 
-  version: 1.8.4
+  version: 1.8.5
 platform: ruby
 authors: 
 - Brandon Keepers
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-06 00:00:00 -04:00
+date: 2010-03-15 00:00:00 -05:00
 default_executable: 
 dependencies: []