activejob_backport 0.0.1

data/lib/active_job/enqueuing.rb

@@ -0,0 +1,75 @@
+require 'active_job/arguments'
+
+module ActiveJob
+  module Enqueuing
+    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 perform_later(*args)
+        job_or_instantiate(*args).enqueue
+      end
+
+      protected
+        def job_or_instantiate(*args)
+          args.first.is_a?(self) ? args.first : new(*args)
+        end
+    end
+
+    # Reschedule the job to be re-executed. This is usefull in combination
+    # with the +rescue_from+ option. When you rescue an exception from your job
+    # you can ask Active Job to retry performing your job.
+    #
+    # ==== Options
+    # * <tt>:wait</tt> - Enqueues the job with the specified delay
+    # * <tt>:wait_until</tt> - Enqueues the job at the time specified
+    # * <tt>:queue</tt> - Enqueues the job on the specified queue
+    #
+    # ==== Examples
+    #
+    #  class SiteScrapperJob < ActiveJob::Base
+    #    rescue_from(ErrorLoadingSite) do
+    #      retry_job queue: :low_priority
+    #    end
+    #    def perform(*args)
+    #      # raise ErrorLoadingSite if cannot scrape
+    #    end
+    #  end
+    def retry_job(options={})
+      enqueue options
+    end
+
+    # Equeue the job to be performed by the queue adapter.
+    #
+    # ==== Options
+    # * <tt>:wait</tt> - Enqueues the job with the specified delay
+    # * <tt>:wait_until</tt> - Enqueues the job at the time specified
+    # * <tt>:queue</tt> - Enqueues the job on the specified queue
+    #
+    # ==== Examples
+    #
+    #    my_job_instance.enqueue
+    #    my_job_instance.enqueue wait: 5.minutes
+    #    my_job_instance.enqueue queue: :important
+    #    my_job_instance.enqueue wait_until: Date.tomorrow.midnight
+    def enqueue(options={})
+      self.scheduled_at = options[:wait].seconds.from_now.to_f if options[:wait]
+      self.scheduled_at = options[:wait_until].to_f if options[:wait_until]
+      self.queue_name   = self.class.queue_name_from_part(options[:queue]) if options[:queue]
+      run_callbacks :enqueue do
+        if self.scheduled_at
+          self.class.queue_adapter.enqueue_at self, self.scheduled_at
+        else
+          self.class.queue_adapter.enqueue self
+        end
+      end
+      self
+    end
+  end
+end

data/lib/active_job/execution.rb

@@ -0,0 +1,41 @@
+require 'active_support/rescuable'
+require 'active_job/arguments'
+
+module ActiveJob
+  module Execution
+    extend ActiveSupport::Concern
+    include ActiveSupport::Rescuable
+
+    module ClassMethods
+      # Performs the job immediately.
+      #
+      #   MyJob.perform_now("mike")
+      #
+      def perform_now(*args)
+        job_or_instantiate(*args).perform_now
+      end
+
+      def execute(job_data) #:nodoc:
+        job = deserialize(job_data)
+        job.perform_now
+      end
+    end
+
+    # Performs the job immediately. The job is not sent to the queueing adapter
+    # and will block the execution until it's finished.
+    #
+    #   MyJob.new(*args).perform_now
+    def perform_now
+      deserialize_arguments_if_needed
+      run_callbacks :perform do
+        perform(*arguments)
+      end
+    rescue => exception
+      rescue_with_handler(exception) || raise(exception)
+    end
+
+    def perform(*)
+      fail NotImplementedError
+    end
+  end
+end

data/lib/active_job/gem_version.rb

@@ -0,0 +1,15 @@
+module ActiveJob
+  # Returns the version of the currently loaded Active Job as a <tt>Gem::Version</tt>
+  def self.gem_version
+    Gem::Version.new VERSION::STRING
+  end
+
+  module VERSION
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 1
+    PRE   = nil
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+  end
+end

data/lib/active_job/logging.rb

@@ -0,0 +1,121 @@
+require 'active_support/core_ext/string/filters'
+require 'active_support/tagged_logging'
+require 'active_support/logger'
+
+module ActiveJob
+  module Logging
+    extend ActiveSupport::Concern
+
+    included do
+      cattr_accessor(:logger) { ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new(STDOUT)) }
+
+      if ActiveSupport::VERSION::MINOR > 0
+        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}
+            ActiveSupport::Notifications.instrument("perform_start.active_job", payload.dup)
+            ActiveSupport::Notifications.instrument("perform.active_job", payload) do
+              block.call
+            end
+          end
+        end
+      else
+        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}
+            ActiveSupport::Notifications.instrument("perform_start.active_job", payload.dup)
+            ActiveSupport::Notifications.instrument("perform.active_job", payload) do
+              block.call
+            end
+          end
+        end
+      end
+
+      before_enqueue do |job|
+        if job.scheduled_at
+          ActiveSupport::Notifications.instrument "enqueue_at.active_job",
+            adapter: job.class.queue_adapter, job: job
+        else
+          ActiveSupport::Notifications.instrument "enqueue.active_job",
+            adapter: job.class.queue_adapter, job: job
+        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)
+        p event.payload
+        info do
+          job = event.payload[:job]
+          "Enqueued #{job.class.name} (Job ID: #{job.job_id}) to #{queue_name(event)}" + args_info(job)
+        end
+      end
+
+      def enqueue_at(event)
+        info do
+          job = event.payload[:job]
+          "Enqueued #{job.class.name} (Job ID: #{job.job_id}) to #{queue_name(event)} at #{scheduled_at(event)}" + args_info(job)
+        end
+      end
+
+      def perform_start(event)
+        info do
+          job = event.payload[:job]
+          "Performing #{job.class.name} from #{queue_name(event)}" + args_info(job)
+        end
+      end
+
+      def perform(event)
+        info do
+          job = event.payload[:job]
+          "Performed #{job.class.name} from #{queue_name(event)} in #{event.duration.round(2).to_s}ms"
+        end
+      end
+
+      private
+        def queue_name(event)
+          event.payload[:adapter].name.demodulize.gsub('Adapter', '') + "(#{event.payload[:job].queue_name})"
+        end
+
+        def args_info(job)
+          job.arguments.any? ? " with arguments: #{job.arguments.map(&:inspect).join(", ")}" : ""
+        end
+
+        def scheduled_at(event)
+          Time.at(event.payload[:job].scheduled_at).utc
+        end
+
+        def logger
+          ActiveJob::Base.logger
+        end
+    end
+  end
+end
+
+ActiveJob::Logging::LogSubscriber.attach_to :active_job

data/lib/active_job/queue_adapter.rb

@@ -0,0 +1,29 @@
+require 'active_job/queue_adapters/inline_adapter'
+require 'active_support/core_ext/string/inflections'
+
+module ActiveJob
+  module QueueAdapter
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      mattr_reader(:queue_adapter) { ActiveJob::QueueAdapters::InlineAdapter }
+
+      def queue_adapter=(name_or_adapter)
+        @@queue_adapter = \
+          case name_or_adapter
+          when :test
+            ActiveJob::QueueAdapters::TestAdapter.new
+          when Symbol, String
+            load_adapter(name_or_adapter)
+          when Class
+            name_or_adapter
+          end
+      end
+
+      private
+        def load_adapter(name)
+          "ActiveJob::QueueAdapters::#{name.to_s.camelize}Adapter".constantize
+        end
+    end
+  end
+end

data/lib/active_job/queue_adapters.rb

@@ -0,0 +1,17 @@
+module ActiveJob
+  module QueueAdapters
+    extend ActiveSupport::Autoload
+
+    autoload :InlineAdapter
+    autoload :BackburnerAdapter
+    autoload :DelayedJobAdapter
+    autoload :QuAdapter
+    autoload :QueAdapter
+    autoload :QueueClassicAdapter
+    autoload :ResqueAdapter
+    autoload :SidekiqAdapter
+    autoload :SneakersAdapter
+    autoload :SuckerPunchAdapter
+    autoload :TestAdapter
+  end
+end

data/lib/active_job/queue_adapters/backburner_adapter.rb

@@ -0,0 +1,26 @@
+require 'backburner'
+
+module ActiveJob
+  module QueueAdapters
+    class BackburnerAdapter
+      class << self
+        def enqueue(job)
+          Backburner::Worker.enqueue JobWrapper, [ job.serialize ], queue: job.queue_name
+        end
+
+        def enqueue_at(job, timestamp)
+          delay = timestamp - Time.current.to_f
+          Backburner::Worker.enqueue JobWrapper, [ job.serialize ], queue: job.queue_name, delay: delay
+        end
+      end
+
+      class JobWrapper
+        class << self
+          def perform(job_data)
+            Base.execute job_data
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_job/queue_adapters/delayed_job_adapter.rb

@@ -0,0 +1,23 @@
+require 'delayed_job'
+
+module ActiveJob
+  module QueueAdapters
+    class DelayedJobAdapter
+      class << self
+        def enqueue(job)
+          JobWrapper.new.delay(queue: job.queue_name).perform(job.serialize)
+        end
+
+        def enqueue_at(job, timestamp)
+          JobWrapper.new.delay(queue: job.queue_name, run_at: Time.at(timestamp)).perform(job.serialize)
+        end
+      end
+
+      class JobWrapper
+        def perform(job_data)
+          Base.execute(job_data)
+        end
+      end
+    end
+  end
+end

data/lib/active_job/queue_adapters/inline_adapter.rb

@@ -0,0 +1,15 @@
+module ActiveJob
+  module QueueAdapters
+    class InlineAdapter
+      class << self
+        def enqueue(job)
+          Base.execute(job.serialize)
+        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

data/lib/active_job/queue_adapters/qu_adapter.rb

@@ -0,0 +1,29 @@
+require 'qu'
+
+module ActiveJob
+  module QueueAdapters
+    class QuAdapter
+      class << self
+        def enqueue(job, *args)
+          Qu::Payload.new(klass: JobWrapper, args: [job.serialize]).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_data)
+          @job_data  = job_data
+        end
+
+        def perform
+          Base.execute @job_data
+        end
+      end
+    end
+  end
+end

data/lib/active_job/queue_adapters/que_adapter.rb

@@ -0,0 +1,23 @@
+require 'que'
+
+module ActiveJob
+  module QueueAdapters
+    class QueAdapter
+      class << self
+        def enqueue(job)
+          JobWrapper.enqueue job.serialize, queue: job.queue_name
+        end
+
+        def enqueue_at(job, timestamp)
+          JobWrapper.enqueue job.serialize, queue: job.queue_name, run_at: Time.at(timestamp)
+        end
+      end
+
+      class JobWrapper < Que::Job
+        def run(job_data)
+          Base.execute job_data
+        end
+      end
+    end
+  end
+end

data/lib/active_job/queue_adapters/queue_classic_adapter.rb

@@ -0,0 +1,40 @@
+require 'queue_classic'
+
+module ActiveJob
+  module QueueAdapters
+    class QueueClassicAdapter
+      class << self
+        def enqueue(job)
+          build_queue(job.queue_name).enqueue("#{JobWrapper.name}.perform", job.serialize)
+        end
+
+        def enqueue_at(job, timestamp)
+          queue = build_queue(job.queue_name)
+          unless queue.respond_to?(:enqueue_at)
+            raise NotImplementedError, 'To be able to schedule jobs with Queue Classic ' \
+              'the QC::Queue needs to respond to `enqueue_at(timestamp, method, *args)`. '
+              'You can implement this yourself or you can use the queue_classic-later gem.'
+          end
+          queue.enqueue_at(timestamp, "#{JobWrapper.name}.perform", job.serialize)
+        end
+
+        # Builds a <tt>QC::Queue</tt> object to schedule jobs on.
+        #
+        # If you have a custom <tt>QC::Queue</tt> subclass you'll need to suclass
+        # <tt>ActiveJob::QueueAdapters::QueueClassicAdapter</tt> and override the
+        # <tt>build_queue</tt> method.
+        def build_queue(queue_name)
+          QC::Queue.new(queue_name)
+        end
+      end
+
+      class JobWrapper
+        class << self
+          def perform(job_data)
+            Base.execute job_data
+          end
+        end
+      end
+    end
+  end
+end