activejob 5.2.3

data/lib/active_job/execution.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "active_support/rescuable"
+require "active_job/arguments"
+
+module ActiveJob
+  module Execution
+    extend ActiveSupport::Concern
+    include ActiveSupport::Rescuable
+
+    # Includes methods for executing and performing jobs instantly.
+    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:
+        ActiveJob::Callbacks.run_callbacks(:execute) do
+          job = deserialize(job_data)
+          job.perform_now
+        end
+      end
+    end
+
+    # Performs the job immediately. The job is not sent to the queueing adapter
+    # but directly executed by blocking the execution of others until it's finished.
+    #
+    #   MyJob.new(*args).perform_now
+    def perform_now
+      # Guard against jobs that were persisted before we started counting executions by zeroing out nil counters
+      self.executions = (executions || 0) + 1
+
+      deserialize_arguments_if_needed
+      run_callbacks :perform do
+        perform(*arguments)
+      end
+    rescue => exception
+      rescue_with_handler(exception) || raise
+    end
+
+    def perform(*)
+      fail NotImplementedError
+    end
+  end
+end

data/lib/active_job/gem_version.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+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 = 5
+    MINOR = 2
+    TINY  = 3
+    PRE   = nil
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+  end
+end

data/lib/active_job/logging.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/transform_values"
+require "active_support/core_ext/string/filters"
+require "active_support/tagged_logging"
+require "active_support/logger"
+
+module ActiveJob
+  module Logging #:nodoc:
+    extend ActiveSupport::Concern
+
+    included do
+      cattr_accessor :logger, default: 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 }
+          ActiveSupport::Notifications.instrument("perform_start.active_job", payload.dup)
+          ActiveSupport::Notifications.instrument("perform.active_job", payload) do
+            block.call
+          end
+        end
+      end
+
+      after_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?
+          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 #:nodoc:
+        def enqueue(event)
+          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} (Job ID: #{job.job_id}) from #{queue_name(event)}" + args_info(job)
+          end
+        end
+
+        def perform(event)
+          job = event.payload[:job]
+          ex = event.payload[:exception_object]
+          if ex
+            error do
+              "Error performing #{job.class.name} (Job ID: #{job.job_id}) from #{queue_name(event)} in #{event.duration.round(2)}ms: #{ex.class} (#{ex.message}):\n" + Array(ex.backtrace).join("\n")
+            end
+          else
+            info do
+              "Performed #{job.class.name} (Job ID: #{job.job_id}) from #{queue_name(event)} in #{event.duration.round(2)}ms"
+            end
+          end
+        end
+
+        private
+          def queue_name(event)
+            event.payload[:adapter].class.name.demodulize.remove("Adapter") + "(#{event.payload[:job].queue_name})"
+          end
+
+          def args_info(job)
+            if job.arguments.any?
+              " with arguments: " +
+                job.arguments.map { |arg| format(arg).inspect }.join(", ")
+            else
+              ""
+            end
+          end
+
+          def format(arg)
+            case arg
+            when Hash
+              arg.transform_values { |value| format(value) }
+            when Array
+              arg.map { |value| format(value) }
+            when GlobalID::Identification
+              arg.to_global_id rescue arg
+            else
+              arg
+            end
+          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,60 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/inflections"
+
+module ActiveJob
+  # The <tt>ActiveJob::QueueAdapter</tt> module is used to load the
+  # correct adapter. The default queue adapter is the +:async+ queue.
+  module QueueAdapter #:nodoc:
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :_queue_adapter_name, instance_accessor: false, instance_predicate: false
+      class_attribute :_queue_adapter, instance_accessor: false, instance_predicate: false
+      self.queue_adapter = :async
+    end
+
+    # Includes the setter method for changing the active queue adapter.
+    module ClassMethods
+      # Returns the backend queue provider. The default queue adapter
+      # is the +:async+ queue. See QueueAdapters for more information.
+      def queue_adapter
+        _queue_adapter
+      end
+
+      def queue_adapter_name
+        _queue_adapter_name
+      end
+
+      # Specify the backend queue provider. The default queue adapter
+      # is the +:async+ queue. See QueueAdapters for more
+      # information.
+      def queue_adapter=(name_or_adapter)
+        case name_or_adapter
+        when Symbol, String
+          queue_adapter = ActiveJob::QueueAdapters.lookup(name_or_adapter).new
+          assign_adapter(name_or_adapter.to_s, queue_adapter)
+        else
+          if queue_adapter?(name_or_adapter)
+            adapter_name = "#{name_or_adapter.class.name.demodulize.remove('Adapter').underscore}"
+            assign_adapter(adapter_name, name_or_adapter)
+          else
+            raise ArgumentError
+          end
+        end
+      end
+
+      private
+        def assign_adapter(adapter_name, queue_adapter)
+          self._queue_adapter_name = adapter_name
+          self._queue_adapter = queue_adapter
+        end
+
+        QUEUE_ADAPTER_METHODS = [:enqueue, :enqueue_at].freeze
+
+        def queue_adapter?(object)
+          QUEUE_ADAPTER_METHODS.all? { |meth| object.respond_to?(meth) }
+        end
+    end
+  end
+end

data/lib/active_job/queue_adapters.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  # == Active Job adapters
+  #
+  # Active Job has adapters for the following queueing backends:
+  #
+  # * {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]
+  # * {queue_classic}[https://github.com/QueueClassic/queue_classic]
+  # * {Resque}[https://github.com/resque/resque]
+  # * {Sidekiq}[http://sidekiq.org]
+  # * {Sneakers}[https://github.com/jondot/sneakers]
+  # * {Sucker Punch}[https://github.com/brandonhilkert/sucker_punch]
+  # * {Active Job Async Job}[http://api.rubyonrails.org/classes/ActiveJob/QueueAdapters/AsyncAdapter.html]
+  # * {Active Job Inline}[http://api.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]
+  #
+  # === Backends Features
+  #
+  #   |                   | Async | Queues | Delayed    | Priorities | Timeout | Retries |
+  #   |-------------------|-------|--------|------------|------------|---------|---------|
+  #   | Backburner        | Yes   | Yes    | Yes        | Yes        | Job     | Global  |
+  #   | Delayed Job       | Yes   | Yes    | Yes        | Job        | Global  | Global  |
+  #   | Qu                | Yes   | Yes    | No         | No         | No      | Global  |
+  #   | Que               | Yes   | Yes    | Yes        | Job        | No      | Job     |
+  #   | queue_classic     | Yes   | Yes    | Yes*       | No         | No      | No      |
+  #   | Resque            | Yes   | Yes    | Yes (Gem)  | Queue      | Global  | Yes     |
+  #   | Sidekiq           | Yes   | Yes    | Yes        | Queue      | No      | Job     |
+  #   | Sneakers          | Yes   | Yes    | No         | Queue      | Queue   | No      |
+  #   | Sucker Punch      | Yes   | Yes    | Yes        | No         | No      | No      |
+  #   | Active Job Async  | Yes   | Yes    | Yes        | No         | No      | No      |
+  #   | Active Job Inline | No    | Yes    | N/A        | N/A        | N/A     | N/A     |
+  #
+  # ==== Async
+  #
+  # Yes: The Queue Adapter has the ability to run the job in a non-blocking manner.
+  # It either runs on a separate or forked process, or on a different thread.
+  #
+  # No: The job is run in the same process.
+  #
+  # ==== Queues
+  #
+  # Yes: Jobs may set which queue they are run in with queue_as or by using the set
+  # method.
+  #
+  # ==== Delayed
+  #
+  # Yes: The adapter will run the job in the future through perform_later.
+  #
+  # (Gem): An additional gem is required to use perform_later with this adapter.
+  #
+  # No: The adapter will run jobs at the next opportunity and cannot use perform_later.
+  #
+  # N/A: The adapter does not support queueing.
+  #
+  # NOTE:
+  # queue_classic supports job scheduling since version 3.1.
+  # For older versions you can use the queue_classic-later gem.
+  #
+  # ==== Priorities
+  #
+  # The order in which jobs are processed can be configured differently depending
+  # on the adapter.
+  #
+  # Job: Any class inheriting from the adapter may set the priority on the job
+  # object relative to other jobs.
+  #
+  # Queue: The adapter can set the priority for job queues, when setting a queue
+  # with Active Job this will be respected.
+  #
+  # Yes: Allows the priority to be set on the job object, at the queue level or
+  # as default configuration option.
+  #
+  # No: Does not allow the priority of jobs to be configured.
+  #
+  # N/A: The adapter does not support queueing, and therefore sorting them.
+  #
+  # ==== Timeout
+  #
+  # When a job will stop after the allotted time.
+  #
+  # Job: The timeout can be set for each instance of the job class.
+  #
+  # Queue: The timeout is set for all jobs on the queue.
+  #
+  # Global: The adapter is configured that all jobs have a maximum run time.
+  #
+  # N/A: This adapter does not run in a separate process, and therefore timeout
+  # is unsupported.
+  #
+  # ==== Retries
+  #
+  # Job: The number of retries can be set per instance of the job class.
+  #
+  # Yes: The Number of retries can be configured globally, for each instance or
+  # on the queue. This adapter may also present failed instances of the job class
+  # that can be restarted.
+  #
+  # Global: The adapter has a global number of retries.
+  #
+  # N/A: The adapter does not run in a separate process, and therefore doesn't
+  # support retries.
+  #
+  # === Async and Inline Queue Adapters
+  #
+  # Active Job has two built-in queue adapters intended for development and
+  # testing: +:async+ and +:inline+.
+  module QueueAdapters
+    extend ActiveSupport::Autoload
+
+    autoload :AsyncAdapter
+    autoload :InlineAdapter
+    autoload :BackburnerAdapter
+    autoload :DelayedJobAdapter
+    autoload :QuAdapter
+    autoload :QueAdapter
+    autoload :QueueClassicAdapter
+    autoload :ResqueAdapter
+    autoload :SidekiqAdapter
+    autoload :SneakersAdapter
+    autoload :SuckerPunchAdapter
+    autoload :TestAdapter
+
+    ADAPTER = "Adapter".freeze
+    private_constant :ADAPTER
+
+    class << self
+      # Returns adapter for specified name.
+      #
+      #   ActiveJob::QueueAdapters.lookup(:sidekiq)
+      #   # => ActiveJob::QueueAdapters::SidekiqAdapter
+      def lookup(name)
+        const_get(name.to_s.camelize << ADAPTER)
+      end
+    end
+  end
+end

data/lib/active_job/queue_adapters/async_adapter.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "concurrent/scheduled_task"
+require "concurrent/executor/thread_pool_executor"
+require "concurrent/utility/processor_counter"
+
+module ActiveJob
+  module QueueAdapters
+    # == Active Job Async adapter
+    #
+    # The Async adapter runs jobs with an in-process thread pool.
+    #
+    # This is the default queue adapter. It's well-suited for dev/test since
+    # it doesn't need an external infrastructure, but it's a poor fit for
+    # production since it drops pending jobs on restart.
+    #
+    # To use this adapter, set queue adapter to +:async+:
+    #
+    #   config.active_job.queue_adapter = :async
+    #
+    # To configure the adapter's thread pool, instantiate the adapter and
+    # pass your own config:
+    #
+    #   config.active_job.queue_adapter = ActiveJob::QueueAdapters::AsyncAdapter.new \
+    #     min_threads: 1,
+    #     max_threads: 2 * Concurrent.processor_count,
+    #     idletime: 600.seconds
+    #
+    # The adapter uses a {Concurrent Ruby}[https://github.com/ruby-concurrency/concurrent-ruby] thread pool to schedule and execute
+    # jobs. Since jobs share a single thread pool, long-running jobs will block
+    # short-lived jobs. Fine for dev/test; bad for production.
+    class AsyncAdapter
+      # See {Concurrent::ThreadPoolExecutor}[https://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ThreadPoolExecutor.html] for executor options.
+      def initialize(**executor_options)
+        @scheduler = Scheduler.new(**executor_options)
+      end
+
+      def enqueue(job) #:nodoc:
+        @scheduler.enqueue JobWrapper.new(job), queue_name: job.queue_name
+      end
+
+      def enqueue_at(job, timestamp) #:nodoc:
+        @scheduler.enqueue_at JobWrapper.new(job), timestamp, queue_name: job.queue_name
+      end
+
+      # Gracefully stop processing jobs. Finishes in-progress work and handles
+      # any new jobs following the executor's fallback policy (`caller_runs`).
+      # Waits for termination by default. Pass `wait: false` to continue.
+      def shutdown(wait: true) #:nodoc:
+        @scheduler.shutdown wait: wait
+      end
+
+      # Used for our test suite.
+      def immediate=(immediate) #:nodoc:
+        @scheduler.immediate = immediate
+      end
+
+      # Note that we don't actually need to serialize the jobs since we're
+      # performing them in-process, but we do so anyway for parity with other
+      # adapters and deployment environments. Otherwise, serialization bugs
+      # may creep in undetected.
+      class JobWrapper #:nodoc:
+        def initialize(job)
+          job.provider_job_id = SecureRandom.uuid
+          @job_data = job.serialize
+        end
+
+        def perform
+          Base.execute @job_data
+        end
+      end
+
+      class Scheduler #:nodoc:
+        DEFAULT_EXECUTOR_OPTIONS = {
+          min_threads:     0,
+          max_threads:     Concurrent.processor_count,
+          auto_terminate:  true,
+          idletime:        60, # 1 minute
+          max_queue:       0, # unlimited
+          fallback_policy: :caller_runs # shouldn't matter -- 0 max queue
+        }.freeze
+
+        attr_accessor :immediate
+
+        def initialize(**options)
+          self.immediate = false
+          @immediate_executor = Concurrent::ImmediateExecutor.new
+          @async_executor = Concurrent::ThreadPoolExecutor.new(DEFAULT_EXECUTOR_OPTIONS.merge(options))
+        end
+
+        def enqueue(job, queue_name:)
+          executor.post(job, &:perform)
+        end
+
+        def enqueue_at(job, timestamp, queue_name:)
+          delay = timestamp - Time.current.to_f
+          if delay > 0
+            Concurrent::ScheduledTask.execute(delay, args: [job], executor: executor, &:perform)
+          else
+            enqueue(job, queue_name: queue_name)
+          end
+        end
+
+        def shutdown(wait: true)
+          @async_executor.shutdown
+          @async_executor.wait_for_termination if wait
+        end
+
+        def executor
+          immediate ? @immediate_executor : @async_executor
+        end
+      end
+    end
+  end
+end