activejob 0 → 4.2.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ed055b7c1ce137d0b117867a22ba1ba004b74cbf
-  data.tar.gz: ea42dac65bcb13b4cc7b1897604c1f3b105c41ac
+  metadata.gz: f5b4155049f893704d35f9712dacadac5c6a63a3
+  data.tar.gz: c072445cde94c55babc2a55489e877ff7930529e
 SHA512:
-  metadata.gz: 14b4bf2e84d31918d860f075dcd556f494de8ef35e52ba4b864c3f7e5fbe9cd30470f89851b2d36a1a993a929de0c56b0693cac5833660b0d0393bfdcdc5eb97
-  data.tar.gz: cbf00f328f8149a6e52dc757c362cd46399b5931ef389e959a58b6e79c5e5581f75d2b4937cf3547cb8e4994e38674e9bf7dd65649f7ac25069da25eeb3e6851
+  metadata.gz: 563242f9567f12e8cb4ecb8204fc9a0956c93507ddea5eca3d3fe824157aca34afacfd47eff94e73aadadedbfb8972e058af16cb226f9ca53959cab3b8cf2de3
+  data.tar.gz: fbc34e79c27f8ce715d350c740b149b8fe02decf1d3175a6c1ab3a859b93caf963a094c1c5c5d01c6b22f8f5bb9cd093504f2263d10f4ca50b0319ef334f66c6

data/README.md

@@ -0,0 +1,141 @@
+# Active Job -- Make work happen later
+
+Active Job is a framework for declaring jobs and making them run on a variety
+of queueing backends. These jobs can be everything from regularly scheduled
+clean-ups, billing charges, or mailings. Anything that can be chopped up into
+small units of work and run in parallel, really.
+
+It also serves as the backend for ActionMailer's #deliver_later functionality
+that makes it easy to turn any mailing into a job for running later. That's
+one of the most common jobs in a modern web application: Sending emails outside
+of the request-response cycle, so the user doesn't have to wait on it.
+
+The main point is to ensure that all Rails apps will have a job infrastructure
+in place, even if it's in the form of an "immediate runner". We can then have
+framework features and other gems build on top of that, without having to worry
+about API differences between Delayed Job and Resque. Picking your queuing
+backend becomes more of an operational concern, then. And you'll be able to
+switch between them without having to rewrite your jobs.
+
+
+## Usage
+
+Set the queue adapter for Active Job:
+
+``` ruby
+ActiveJob::Base.queue_adapter = :inline # default queue adapter
+# Adapters currently supported: :backburner, :delayed_job, :qu, :que, :queue_classic,
+#                               :resque, :sidekiq, :sneakers, :sucker_punch
+```
+
+Declare a job like so:
+
+```ruby
+class MyJob < ActiveJob::Base
+  queue_as :my_jobs
+
+  def perform(record)
+    record.do_work
+  end
+end
+```
+
+Enqueue a job like so:
+
+```ruby
+MyJob.enqueue record  # Enqueue a job to be performed as soon the queueing system is free.
+```
+
+```ruby
+MyJob.enqueue_at Date.tomorrow.noon, record  # Enqueue a job to be performed tomorrow at noon.
+```
+
+```ruby
+MyJob.enqueue_in 1.week, record # Enqueue a job to be performed 1 week from now.
+```
+
+That's it!
+
+
+## GlobalID support
+
+Active Job supports [GlobalID serialization](https://github.com/rails/globalid/) for parameters. This makes it possible
+to pass live Active Record objects to your job instead of class/id pairs, which
+you then have to manually deserialize. Before, jobs would look like this:
+
+```ruby
+class TrashableCleanupJob
+  def perform(trashable_class, trashable_id, depth)
+    trashable = trashable_class.constantize.find(trashable_id)
+    trashable.cleanup(depth)
+  end
+end
+```
+
+Now you can simply do:
+
+```ruby
+class TrashableCleanupJob
+  def perform(trashable, depth)
+    trashable.cleanup(depth)
+  end
+end
+```
+
+This works with any class that mixes in GlobalID::Identification, which
+by default has been mixed into Active Record classes.
+
+
+## Supported queueing systems
+
+We currently have adapters for:
+
+* [Backburner](https://github.com/nesquena/backburner)
+* [Delayed Job](https://github.com/collectiveidea/delayed_job)
+* [Qu](https://github.com/bkeepers/qu)
+* [Que](https://github.com/chanks/que)
+* [QueueClassic](https://github.com/ryandotsmith/queue_classic)
+* [Resque 1.x](https://github.com/resque/resque)
+* [Sidekiq](https://github.com/mperham/sidekiq)
+* [Sneakers](https://github.com/jondot/sneakers)
+* [Sucker Punch](https://github.com/brandonhilkert/sucker_punch)
+
+
+## Auxiliary gems
+
+* [activejob-stats](https://github.com/seuros/activejob-stats)
+
+## Download and installation
+
+The latest version of Active Job can be installed with RubyGems:
+
+```
+  % [sudo] gem install activejob
+```
+
+Source code can be downloaded as part of the Rails project on GitHub
+
+* https://github.com/rails/rails/tree/master/activejob
+
+## License
+
+ActiveJob is released under the MIT license:
+
+* http://www.opensource.org/licenses/MIT
+
+
+## Support
+
+API documentation is at
+
+* http://api.rubyonrails.org
+
+Bug reports can be filed for the Ruby on Rails project here:
+
+* https://github.com/rails/rails/issues
+
+Feature requests should be discussed on the rails-core mailing list here:
+
+* https://groups.google.com/forum/?fromgroups#!forum/rubyonrails-core
+
+

data/lib/active_job.rb

@@ -23,8 +23,8 @@
 
 require 'active_support'
 require 'active_support/rails'
-
 require 'active_job/version'
+require 'global_id'
 
 module ActiveJob
   extend ActiveSupport::Autoload

data/lib/active_job/arguments.rb

@@ -0,0 +1,62 @@
+module ActiveJob
+  class DeserializationError < StandardError
+    attr_reader :original_exception
+
+    def initialize(e)
+      super ("Error while trying to deserialize arguments: #{e.message}")
+      @original_exception = e
+      set_backtrace e.backtrace
+    end
+  end
+
+  module Arguments
+    extend self
+    TYPE_WHITELIST = [ NilClass, Fixnum, Float, String, TrueClass, FalseClass, Bignum ]
+
+    def serialize(arguments)
+      arguments.map { |argument| serialize_argument(argument) }
+    end
+
+    def deserialize(arguments)
+      arguments.map { |argument| deserialize_argument(argument) }
+    end
+
+    private
+      def serialize_argument(argument)
+        case argument
+        when GlobalID::Identification
+          argument.global_id.to_s
+        when *TYPE_WHITELIST
+          argument
+        when Array
+          serialize(argument)
+        when Hash
+          Hash[ argument.map { |key, value| [ serialize_hash_key(key), serialize_argument(value) ] } ]
+        else
+          raise "Unsupported argument type: #{argument.class.name}"
+        end
+      end
+
+      def deserialize_argument(argument)
+        case argument
+        when Array
+          deserialize(argument)
+        when Hash
+          Hash[ argument.map { |key, value| [ key, deserialize_argument(value) ] } ].with_indifferent_access
+        else
+          GlobalID::Locator.locate(argument) || argument
+        end
+      rescue => e
+        raise DeserializationError.new(e)
+      end
+
+      def serialize_hash_key(key)
+        case key
+        when String, Symbol
+          key.to_s
+        else
+          raise "Unsupported hash key type: #{key.class.name}"
+        end
+      end
+  end
+end

data/lib/active_job/base.rb

@@ -1,13 +1,22 @@
 require 'active_job/queue_adapter'
 require 'active_job/queue_name'
 require 'active_job/enqueuing'
+require 'active_job/execution'
+require 'active_job/callbacks'
+require 'active_job/identifier'
 require 'active_job/logging'
 
 module ActiveJob
   class Base
     extend QueueAdapter
-    extend QueueName
-    extend Enqueuing
-    extend Logging
+
+    include QueueName
+    include Enqueuing
+    include Execution
+    include Callbacks
+    include Identifier
+    include Logging
+
+    ActiveSupport.run_load_hooks(:active_job, self)
   end
 end

data/lib/active_job/callbacks.rb

@@ -0,0 +1,144 @@
+require 'active_support/callbacks'
+
+module ActiveJob
+  # = Active Job Callbacks
+  #
+  # Active Job provides hooks during the lifecycle of a job. Callbacks allows you to trigger
+  # logic during the lifecycle of a job. Available callbacks:
+  #
+  # * <tt>before_enqueue</tt>
+  # * <tt>around_enqueue</tt>
+  # * <tt>after_enqueue</tt>
+  # * <tt>before_perform</tt>
+  # * <tt>around_perform</tt>
+  # * <tt>after_perform</tt>
+  #
+  module Callbacks
+    extend  ActiveSupport::Concern
+    include ActiveSupport::Callbacks
+
+    included do
+      define_callbacks :perform
+      define_callbacks :enqueue
+    end
+
+    module ClassMethods
+      # Defines a callback that will get called right before the
+      # job's perform method is executed.
+      #
+      #   class VideoProcessJob < ActiveJob::Base
+      #     queue_as :default
+      #
+      #     before_perform do |job|
+      #       UserMailer.notify_video_started_processing(job.arguments.first)
+      #     end
+      #
+      #     def perform(video_id)
+      #       Video.find(video_id).process
+      #     end
+      # end
+      #
+      def before_perform(*filters, &blk)
+        set_callback(:perform, :before, *filters, &blk)
+      end
+
+      # Defines a callback that will get called right after the
+      # job's perform method has finished.
+      #
+      #   class VideoProcessJob < ActiveJob::Base
+      #     queue_as :default
+      #
+      #     after_perform do |job|
+      #       UserMailer.notify_video_processed(job.arguments.first)
+      #     end
+      #
+      #     def perform(video_id)
+      #       Video.find(video_id).process
+      #     end
+      # end
+      #
+      def after_perform(*filters, &blk)
+        set_callback(:perform, :after, *filters, &blk)
+      end
+
+      # Defines a callback that will get called around the job's perform method.
+      #
+      #   class VideoProcessJob < ActiveJob::Base
+      #     queue_as :default
+      #
+      #     around_perform do |job, block|
+      #       UserMailer.notify_video_started_processing(job.arguments.first)
+      #       block.call
+      #       UserMailer.notify_video_processed(job.arguments.first)
+      #     end
+      #
+      #     def perform(video_id)
+      #       Video.find(video_id).process
+      #     end
+      # end
+      #
+      def around_perform(*filters, &blk)
+        set_callback(:perform, :around, *filters, &blk)
+      end
+
+      # Defines a callback that will get called right before the
+      # job is enqueued.
+      #
+      #   class VideoProcessJob < ActiveJob::Base
+      #     queue_as :default
+      #
+      #     before_enqueue do |job|
+      #       $statsd.increment "enqueue-video-job.try"
+      #     end
+      #
+      #     def perform(video_id)
+      #       Video.find(video_id).process
+      #     end
+      # end
+      #
+      def before_enqueue(*filters, &blk)
+        set_callback(:enqueue, :before, *filters, &blk)
+      end
+
+      # Defines a callback that will get called right after the
+      # job is enqueued.
+      #
+      #   class VideoProcessJob < ActiveJob::Base
+      #     queue_as :default
+      #
+      #     after_enqueue do |job|
+      #       $statsd.increment "enqueue-video-job.success"
+      #     end
+      #
+      #     def perform(video_id)
+      #       Video.find(video_id).process
+      #     end
+      # end
+      #
+      def after_enqueue(*filters, &blk)
+        set_callback(:enqueue, :after, *filters, &blk)
+      end
+
+      # Defines a callback that will get called before and after the
+      # job is enqueued.
+      #
+      #   class VideoProcessJob < ActiveJob::Base
+      #     queue_as :default
+      #
+      #     around_enqueue do |job, block|
+      #       $statsd.time "video-job.process" do
+      #         block.call
+      #       end
+      #     end
+      #
+      #     def perform(video_id)
+      #       Video.find(video_id).process
+      #     end
+      # end
+      #
+      def around_enqueue(*filters, &blk)
+        set_callback(:enqueue, :around, *filters, &blk)
+      end
+    end
+  end
+end

data/lib/active_job/enqueuing.rb

@@ -1,18 +1,71 @@
-require 'active_job/parameters'
+require 'active_job/arguments'
 
 module ActiveJob
   module Enqueuing
-    # Push a job onto the queue.  The arguments must be legal JSON types
-    # (string, int, float, nil, true, false, hash or array) or
-    # ActiveModel::GlobalIdentication instances.  Arbitrary Ruby objects
-    # are not supported.
-    #
-    # The return value is adapter-specific and may change in a future
-    # ActiveJob release.
-    def enqueue(*args)
-      serialized_args = Parameters.serialize(args)
-      ActiveSupport::Notifications.instrument "enqueue.active_job", adapter: queue_adapter, job: self, args: serialized_args
-      queue_adapter.queue self, *serialized_args
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Push a job onto the queue.  The arguments must be legal JSON types
+      # (string, int, float, nil, true, false, hash or array) or
+      # GlobalID::Identification instances.  Arbitrary Ruby objects
+      # are not supported.
+      #
+      # Returns an instance of the job class queued with args available in
+      # Job#arguments.
+      def enqueue(*args)
+        new(args).tap do |job|
+          job.run_callbacks :enqueue do
+            queue_adapter.enqueue self, job.job_id, *Arguments.serialize(args)
+          end
+        end
+      end
+
+      # Enqueue a job to be performed at +interval+ from now.
+      #
+      #   enqueue_in(1.week, "mike")
+      #
+      # Returns an instance of the job class queued with args available in
+      # Job#arguments and the timestamp in Job#enqueue_at.
+      def enqueue_in(interval, *args)
+        enqueue_at interval.seconds.from_now, *args
+      end
+
+      # Enqueue a job to be performed at an explicit point in time.
+      #
+      #   enqueue_at(Date.tomorrow.midnight, "mike")
+      #
+      # Returns an instance of the job class queued with args available in
+      # Job#arguments and the timestamp in Job#enqueue_at.
+      def enqueue_at(timestamp, *args)
+        new(args).tap do |job|
+          job.enqueued_at = timestamp
+
+          job.run_callbacks :enqueue do
+            queue_adapter.enqueue_at self, timestamp.to_f, job.job_id, *Arguments.serialize(args)
+          end
+        end
+      end
+    end
+
+    included do
+      attr_accessor :arguments
+      attr_accessor :enqueued_at
+    end
+
+    def initialize(arguments = nil)
+      @arguments = arguments
+    end
+
+    def retry_now
+      self.class.enqueue(*arguments)
+    end
+
+    def retry_in(interval)
+      self.class.enqueue_in interval, *arguments
+    end
+
+    def retry_at(timestamp)
+      self.class.enqueue_at timestamp, *arguments
     end
   end
 end

data/lib/active_job/execution.rb

@@ -0,0 +1,33 @@
+require 'active_support/rescuable'
+require 'active_job/arguments'
+
+module ActiveJob
+  module Execution
+    extend ActiveSupport::Concern
+
+    included do
+      include ActiveSupport::Rescuable
+    end
+
+    def execute(job_id, *serialized_args)
+      self.job_id    = job_id
+      self.arguments = deserialize_arguments(serialized_args)
+
+      run_callbacks :perform do
+        perform(*arguments)
+      end
+    rescue => exception
+      rescue_with_handler(exception) || raise(exception)
+    end
+
+    def perform(*)
+      fail NotImplementedError
+    end
+
+    private
+      def deserialize_arguments(serialized_args)
+        Arguments.deserialize(serialized_args)
+      end
+
+  end
+end

data/lib/active_job/gem_version.rb

@@ -8,7 +8,7 @@ module ActiveJob
     MAJOR = 4
     MINOR = 2
     TINY  = 0
-    PRE   = "alpha"
+    PRE   = "beta1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_job/identifier.rb

@@ -0,0 +1,15 @@
+require 'active_job/arguments'
+
+module ActiveJob
+  module Identifier
+    extend ActiveSupport::Concern
+
+    included do
+      attr_writer :job_id
+    end
+
+    def job_id
+      @job_id ||= SecureRandom.uuid
+    end
+  end
+end

data/lib/active_job/logging.rb

@@ -1,7 +1,90 @@
-require 'active_job/log_subscriber'
+require 'active_support/core_ext/string/filters'
+require 'active_support/tagged_logging'
+require 'active_support/logger'
 
 module ActiveJob
   module Logging
-    mattr_accessor(:logger) { ActiveSupport::Logger.new(STDOUT) }
+    extend ActiveSupport::Concern
+
+    included do
+      cattr_accessor(:logger) { ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new(STDOUT)) }
+
+      around_enqueue do |_, block, _|
+        tag_logger do
+          block.call
+        end
+      end
+
+      around_perform do |job, block, _|
+        tag_logger(job.class.name, job.job_id) do
+          payload = {adapter: job.class.queue_adapter, job: job.class, args: job.arguments}
+          ActiveSupport::Notifications.instrument("perform_start.active_job", payload.dup)
+          ActiveSupport::Notifications.instrument("perform.active_job", payload) do
+            block.call
+          end
+        end
+      end
+
+      before_enqueue do |job|
+        if job.enqueued_at
+          ActiveSupport::Notifications.instrument "enqueue_at.active_job",
+            adapter: job.class.queue_adapter, job: job.class, job_id: job.job_id, args: job.arguments, timestamp: job.enqueued_at
+        else
+          ActiveSupport::Notifications.instrument "enqueue.active_job",
+            adapter: job.class.queue_adapter, job: job.class, job_id: job.job_id, args: job.arguments
+        end
+      end
+    end
+
+    private
+      def tag_logger(*tags)
+        if logger.respond_to?(:tagged)
+          tags.unshift "ActiveJob" unless logger_tagged_by_active_job?
+          ActiveJob::Base.logger.tagged(*tags){ yield }
+        else
+          yield
+        end
+      end
+
+      def logger_tagged_by_active_job?
+        logger.formatter.current_tags.include?("ActiveJob")
+      end
+
+    class LogSubscriber < ActiveSupport::LogSubscriber
+      def enqueue(event)
+        info "Enqueued #{event.payload[:job].name} (Job ID: #{event.payload[:job_id]}) to #{queue_name(event)}" + args_info(event)
+      end
+
+      def enqueue_at(event)
+        info "Enqueued #{event.payload[:job].name} (Job ID: #{event.payload[:job_id]}) to #{queue_name(event)} at #{enqueued_at(event)}" + args_info(event)
+      end
+
+      def perform_start(event)
+        info "Performing #{event.payload[:job].name} from #{queue_name(event)}" + args_info(event)
+      end
+
+      def perform(event)
+        info "Performed #{event.payload[:job].name} from #{queue_name(event)} in #{event.duration.round(2).to_s}ms"
+      end
+
+      private
+        def queue_name(event)
+          event.payload[:adapter].name.demodulize.remove('Adapter') + "(#{event.payload[:job].queue_name})"
+        end
+
+        def args_info(event)
+          event.payload[:args].any? ? " with arguments: #{event.payload[:args].map(&:inspect).join(", ")}" : ""
+        end
+
+        def enqueued_at(event)
+          Time.at(event.payload[:timestamp]).utc
+        end
+
+        def logger
+          ActiveJob::Base.logger
+        end
+    end
   end
 end
+
+ActiveJob::Logging::LogSubscriber.attach_to :active_job

data/lib/active_job/queue_adapters/backburner_adapter.rb

@@ -4,15 +4,19 @@ module ActiveJob
   module QueueAdapters
     class BackburnerAdapter
       class << self
-        def queue(job, *args)
+        def enqueue(job, *args)
           Backburner::Worker.enqueue JobWrapper, [ job.name, *args ], queue: job.queue_name
         end
+
+        def enqueue_at(job, timestamp, *args)
+          raise NotImplementedError
+        end
       end
 
       class JobWrapper
         class << self
           def perform(job_name, *args)
-            job_name.constantize.new.perform *Parameters.deserialize(args)
+            job_name.constantize.new.execute(*args)
           end
         end
       end

data/lib/active_job/queue_adapters/delayed_job_adapter.rb

@@ -4,14 +4,18 @@ module ActiveJob
   module QueueAdapters
     class DelayedJobAdapter
       class << self
-        def queue(job, *args)
+        def enqueue(job, *args)
           JobWrapper.new.delay(queue: job.queue_name).perform(job, *args)
         end
+
+        def enqueue_at(job, timestamp, *args)
+          JobWrapper.new.delay(queue: job.queue_name, run_at: Time.at(timestamp)).perform(job, *args)
+        end
       end
-      
+
       class JobWrapper
         def perform(job, *args)
-          job.new.perform *Parameters.deserialize(args)
+          job.new.execute(*args)
         end
       end
     end

data/lib/active_job/queue_adapters/inline_adapter.rb

@@ -2,10 +2,14 @@ module ActiveJob
   module QueueAdapters
     class InlineAdapter
       class << self
-        def queue(job, *args)
-          job.new.perform *Parameters.deserialize(args)
+        def enqueue(job, *args)
+          job.new.execute(*args)
+        end
+
+        def enqueue_at(*)
+          raise NotImplementedError.new("Use a queueing backend to enqueue jobs in the future. Read more at https://github.com/rails/activejob")
         end
       end
     end
   end
-end
+end

data/lib/active_job/queue_adapters/qu_adapter.rb

@@ -0,0 +1,30 @@
+require 'qu'
+
+module ActiveJob
+  module QueueAdapters
+    class QuAdapter
+      class << self
+        def enqueue(job, *args)
+          Qu::Payload.new(klass: JobWrapper, args: [job.name, *args]).tap do |payload|
+            payload.instance_variable_set(:@queue, job.queue_name)
+          end.push
+        end
+
+        def enqueue_at(job, timestamp, *args)
+          raise NotImplementedError
+        end
+      end
+
+      class JobWrapper < Qu::Job
+        def initialize(job_name, *args)
+          @job  = job_name.constantize
+          @args = args
+        end
+
+        def perform
+          @job.new.execute(*@args)
+        end
+      end
+    end
+  end
+end

data/lib/active_job/queue_adapters/que_adapter.rb

@@ -4,14 +4,18 @@ module ActiveJob
   module QueueAdapters
     class QueAdapter
       class << self
-        def queue(job, *args)
-          JobWrapper.enqueue job, *args, queue: job.queue_name
+        def enqueue(job, *args)
+          JobWrapper.enqueue job.name, *args, queue: job.queue_name
+        end
+
+        def enqueue_at(job, timestamp, *args)
+          raise NotImplementedError
         end
       end
 
       class JobWrapper < Que::Job
-        def run(job, *args)
-          job.new.perform *Parameters.deserialize(args)
+        def run(job_name, *args)
+          job_name.constantize.new.execute(*args)
         end
       end
     end

data/lib/active_job/queue_adapters/queue_classic_adapter.rb

@@ -4,14 +4,20 @@ module ActiveJob
   module QueueAdapters
     class QueueClassicAdapter
       class << self
-        def queue(job, *args)
-          QC::Queue.new(job.queue_name).enqueue("#{JobWrapper.name}.perform", job, *args)
+        def enqueue(job, *args)
+          QC::Queue.new(job.queue_name).enqueue("#{JobWrapper.name}.perform", job.name, *args)
+        end
+
+        def enqueue_at(job, timestamp, *args)
+          raise NotImplementedError
         end
       end
 
       class JobWrapper
-        def self.perform(job, *args)
-          job.new.perform *Parameters.deserialize(args)
+        class << self
+          def perform(job_name, *args)
+            job_name.constantize.new.execute(*args)
+          end
         end
       end
     end

data/lib/active_job/queue_adapters/resque_adapter.rb

@@ -2,29 +2,39 @@ require 'resque'
 require 'active_support/core_ext/enumerable'
 require 'active_support/core_ext/array/access'
 
+begin
+  require 'resque-scheduler'
+rescue LoadError
+  begin
+    require 'resque_scheduler'
+  rescue LoadError
+    false
+  end
+end
+
 module ActiveJob
   module QueueAdapters
     class ResqueAdapter
       class << self
-        def queue(job, *args)
-          Resque.enqueue JobWrapper.new(job), job, *args
+        def enqueue(job, *args)
+          Resque.enqueue_to job.queue_name, JobWrapper, job.name, *args
+        end
+
+        def enqueue_at(job, timestamp, *args)
+          unless Resque.respond_to?(:enqueue_at_with_queue)
+            raise NotImplementedError, "To be able to schedule jobs with Resque you need the " \
+              "resque-scheduler gem. Please add it to your Gemfile and run bundle install"
+          end
+          Resque.enqueue_at_with_queue job.queue_name, timestamp, JobWrapper, job.name, *args
         end
       end
 
       class JobWrapper
         class << self
           def perform(job_name, *args)
-            job_name.constantize.new.perform *Parameters.deserialize(args)
+            job_name.constantize.new.execute(*args)
           end
         end
-
-        def initialize(job)
-          @queue = job.queue_name
-        end
-
-        def to_s
-          self.class.name
-        end
       end
     end
   end

data/lib/active_job/queue_adapters/sidekiq_adapter.rb

@@ -4,20 +4,30 @@ module ActiveJob
   module QueueAdapters
     class SidekiqAdapter
       class << self
-        def queue(job, *args)
+        def enqueue(job, *args)
+          #Sidekiq::Client does not support symbols as keys
           Sidekiq::Client.push \
             'class' => JobWrapper,
             'queue' => job.queue_name,
             'args'  => [ job, *args ],
             'retry' => true
         end
+
+        def enqueue_at(job, timestamp, *args)
+          Sidekiq::Client.push \
+            'class' => JobWrapper,
+            'queue' => job.queue_name,
+            'args'  => [ job, *args ],
+            'retry' => true,
+            'at'    => timestamp
+        end
       end
 
       class JobWrapper
         include Sidekiq::Worker
 
         def perform(job_name, *args)
-          job_name.constantize.new.perform *Parameters.deserialize(args)
+          job_name.constantize.new.execute(*args)
         end
       end
     end

data/lib/active_job/queue_adapters/sneakers_adapter.rb

@@ -4,22 +4,29 @@ require 'thread'
 module ActiveJob
   module QueueAdapters
     class SneakersAdapter
-      @mutex = Mutex.new
-        
+      @monitor = Monitor.new
+
       class << self
-        def queue(job, *args)
-          @mutex.synchronize do
+        def enqueue(job, *args)
+          @monitor.synchronize do
             JobWrapper.from_queue job.queue_name
-            JobWrapper.enqueue [ job, *args ]
+            JobWrapper.enqueue ActiveSupport::JSON.encode([ job.name, *args ])
           end
         end
+
+        def enqueue_at(job, timestamp, *args)
+          raise NotImplementedError
+        end
       end
 
       class JobWrapper
         include Sneakers::Worker
+        from_queue 'active_jobs_default'
 
-        def work(job, *args)
-          job.new.perform *Parameters.deserialize(args)
+        def work(msg)
+          job_name, *args = ActiveSupport::JSON.decode(msg)
+          job_name.constantize.new.execute(*args)
+          ack!
         end
       end
     end

data/lib/active_job/queue_adapters/sucker_punch_adapter.rb

@@ -4,8 +4,12 @@ module ActiveJob
   module QueueAdapters
     class SuckerPunchAdapter
       class << self
-        def queue(job, *args)
-          JobWrapper.new.async.perform(job, *args)
+        def enqueue(job, *args)
+          JobWrapper.new.async.perform job, *args
+        end
+
+        def enqueue_at(job, timestamp, *args)
+          raise NotImplementedError
         end
       end
 
@@ -13,7 +17,7 @@ module ActiveJob
         include SuckerPunch::Job
 
         def perform(job, *args)
-          job.new.perform *Parameters.deserialize(args)
+          job.new.execute(*args)
         end
       end
     end

data/lib/active_job/queue_name.rb

@@ -1,10 +1,21 @@
 module ActiveJob
   module QueueName
-    mattr_accessor(:queue_base_name) { "active_jobs" }
-    mattr_accessor(:queue_name)      { queue_base_name }
+    extend ActiveSupport::Concern
 
-    def queue_as(part_name)
-      self.queue_name = "#{queue_base_name}_#{part_name}"
+    module ClassMethods
+      mattr_accessor(:queue_name_prefix)
+      mattr_accessor(:default_queue_name) { "default" }
+
+      def queue_as(part_name)
+        queue_name = part_name.to_s.presence || default_queue_name
+        name_parts = [queue_name_prefix.presence, queue_name]
+        self.queue_name = name_parts.compact.join('_')
+      end
+    end
+
+    included do
+      class_attribute :queue_name
+      self.queue_name = default_queue_name
     end
   end
-end
+end

data/lib/active_job/railtie.rb

@@ -0,0 +1,23 @@
+require 'global_id/railtie'
+require 'active_job'
+
+module ActiveJob
+  # = Active Job Railtie
+  class Railtie < Rails::Railtie # :nodoc:
+    config.active_job = ActiveSupport::OrderedOptions.new
+
+    initializer 'active_job.logger' do
+      ActiveSupport.on_load(:active_job) { self.logger = ::Rails.logger }
+    end
+
+    initializer "active_job.set_configs" do |app|
+      options = app.config.active_job
+      options.queue_adapter ||= :inline
+
+      ActiveSupport.on_load(:active_job) do
+        options.each { |k,v| send("#{k}=", v) }
+      end
+    end
+
+  end
+end

data/lib/rails/generators/job/job_generator.rb

@@ -0,0 +1,22 @@
+require 'rails/generators/named_base'
+
+module Rails
+  module Generators # :nodoc:
+    class JobGenerator < Rails::Generators::NamedBase # :nodoc:
+      desc 'This generator creates an active job file at app/jobs'
+
+      class_option :queue, type: :string, default: 'default', desc: 'The queue name for the generated job'
+
+      def self.default_generator_root
+        File.dirname(__FILE__)
+      end
+
+      check_class_collision suffix: 'Job'
+
+      def create_job_file
+        template 'job.rb', File.join('app/jobs', class_path, "#{file_name}_job.rb")
+      end
+
+    end
+  end
+end

data/lib/rails/generators/job/templates/job.rb

@@ -0,0 +1,9 @@
+<% module_namespacing do -%>
+class <%= class_name %>Job < ActiveJob::Base
+  queue_as :<%= options[:queue] %>
+
+  def perform(*args)
+    # Do something later
+  end
+end
+<% end -%>

metadata

@@ -1,43 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: activejob
 version: !ruby/object:Gem::Version
-  version: '0'
+  version: 4.2.0.beta1
 platform: ruby
 authors:
 - David Heinemeier Hansson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-20 00:00:00.000000000 Z
+date: 2014-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: globalid
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.1.0
+        version: 0.2.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.1.0
-- !ruby/object:Gem::Dependency
-  name: activemodel-globalid
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.2.3
 description: Declare job classes that can be run by a variety of queueing backends.
 email: david@loudthinking.com
 executables: []
@@ -46,17 +32,21 @@ extra_rdoc_files: []
 files:
 - CHANGELOG.md
 - MIT-LICENSE
+- README.md
 - lib/active_job.rb
+- lib/active_job/arguments.rb
 - lib/active_job/base.rb
+- lib/active_job/callbacks.rb
 - lib/active_job/enqueuing.rb
+- lib/active_job/execution.rb
 - lib/active_job/gem_version.rb
-- lib/active_job/log_subscriber.rb
+- lib/active_job/identifier.rb
 - lib/active_job/logging.rb
-- lib/active_job/parameters.rb
 - lib/active_job/queue_adapter.rb
 - lib/active_job/queue_adapters/backburner_adapter.rb
 - lib/active_job/queue_adapters/delayed_job_adapter.rb
 - lib/active_job/queue_adapters/inline_adapter.rb
+- lib/active_job/queue_adapters/qu_adapter.rb
 - lib/active_job/queue_adapters/que_adapter.rb
 - lib/active_job/queue_adapters/queue_classic_adapter.rb
 - lib/active_job/queue_adapters/resque_adapter.rb
@@ -64,8 +54,10 @@ files:
 - lib/active_job/queue_adapters/sneakers_adapter.rb
 - lib/active_job/queue_adapters/sucker_punch_adapter.rb
 - lib/active_job/queue_name.rb
-- lib/active_job/railitie.rb
+- lib/active_job/railtie.rb
 - lib/active_job/version.rb
+- lib/rails/generators/job/job_generator.rb
+- lib/rails/generators/job/templates/job.rb
 homepage: http://www.rubyonrails.org
 licenses:
 - MIT
@@ -81,14 +73,13 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: Job framework with pluggable queues (will be part of Rails).
+summary: Job framework with pluggable queues.
 test_files: []
-has_rdoc: 

data/lib/active_job/log_subscriber.rb

@@ -1,19 +0,0 @@
-require 'active_support/core_ext/string/filters'
-
-module ActiveJob
-  class LogSubscriber < ActiveSupport::LogSubscriber
-    def enqueue(event)
-      queue_name = event.payload[:adapter].name.demodulize.remove('Adapter')
-      job_name   = event.payload[:job].name      
-      args       = event.payload[:args].any? ? ": #{event.payload[:args].inspect}" : ""
-
-      info "Enqueued #{job_name} to #{queue_name}" + args
-    end
-
-    def logger
-      ActiveJob::Base.logger
-    end
-  end
-end
-
-ActiveJob::LogSubscriber.attach_to :active_job

data/lib/active_job/parameters.rb

@@ -1,19 +0,0 @@
-require 'active_model/global_locator'
-require 'active_support/core_ext/object/try'
-
-module ActiveJob
-  class Parameters
-    TYPE_WHITELIST = [NilClass, Fixnum, Float, String, TrueClass, FalseClass, Hash, Array, Bignum]
-
-    def self.serialize(params)
-      params.collect do |param|
-        raise "Unsupported parameter type: #{param.class.name}" unless param.respond_to?(:global_id) || TYPE_WHITELIST.include?(param.class)
-        param.try(:global_id) || param
-      end
-    end
-
-    def self.deserialize(params)
-      params.collect { |param| ActiveModel::GlobalLocator.locate(param) || param }
-    end
-  end
-end

data/lib/active_job/railitie.rb

@@ -1,8 +0,0 @@
-module ActiveJob
-  # = Active Job Railtie
-  class Railtie < Rails::Railtie # :nodoc:
-    initializer 'active_job.logger' do
-      ActiveSupport.on_load(:active_job) { self.logger ||= ::Rails.logger }
-    end
-  end
-end