delayed 0.1.0

data/lib/delayed/psych_ext.rb

@@ -0,0 +1,135 @@
+module Delayed
+  class PerformableMethod
+    # serialize to YAML
+    def encode_with(coder)
+      coder.map = {
+        'object' => object,
+        'method_name' => method_name,
+        'args' => args,
+      }
+    end
+  end
+end
+
+module Psych
+  def self.load_dj(yaml)
+    result = parse(yaml)
+    result ? Delayed::PsychExt::ToRuby.create.accept(result) : result
+  end
+
+  def self.dump_dj(object)
+    visitor = Delayed::PsychExt::YAMLTree.create
+    visitor << object
+    visitor.tree.yaml
+  end
+end
+
+module Delayed
+  module PsychExt
+    class YAMLTree < Psych::Visitors::YAMLTree
+      def accept(target)
+        if defined?(ActiveRecord::Base) && target.is_a?(ActiveRecord::Base)
+          tag = ['!ruby/ActiveRecord', target.class.name].compact.join(':')
+          map = @emitter.start_mapping(nil, tag, false, Psych::Nodes::Mapping::BLOCK)
+          register(target, map)
+          @emitter.scalar('attributes', nil, nil, true, false, Psych::Nodes::Mapping::ANY)
+          accept target.attributes.slice(target.class.primary_key)
+
+          @emitter.end_mapping
+        else
+          super
+        end
+      end
+    end
+
+    class ToRuby < Psych::Visitors::ToRuby
+      unless respond_to?(:create)
+        def self.create
+          new
+        end
+      end
+
+      def accept(target)
+        super.tap do |value|
+          register(target, value) if value.class.include?(Singleton)
+        end
+      end
+
+      def visit_Psych_Nodes_Mapping(object) # rubocop:disable Metrics/CyclomaticComplexity, Naming/MethodName, Metrics/PerceivedComplexity
+        klass = Psych.load_tags[object.tag]
+        if klass
+          # Implementation changed here https://github.com/ruby/psych/commit/2c644e184192975b261a81f486a04defa3172b3f
+          # load_tags used to have class values, now the values are strings
+          klass = resolve_class(klass) if klass.is_a?(String)
+          return revive(klass, object)
+        end
+
+        case object.tag
+          when %r{^!ruby/object}
+            result = super
+            if jruby_is_seriously_borked && result.is_a?(ActiveRecord::Base)
+              klass = result.class
+              id = result[klass.primary_key]
+              begin
+                klass.unscoped.find(id)
+              rescue ActiveRecord::RecordNotFound => e
+                raise Delayed::DeserializationError, "ActiveRecord::RecordNotFound, class: #{klass}, primary key: #{id} (#{e.message})"
+              end
+            else
+              result
+            end
+          when %r{^!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 => e
+              raise Delayed::DeserializationError, "ActiveRecord::RecordNotFound, class: #{klass}, primary key: #{id} (#{e.message})"
+            end
+          when %r{^!ruby/Mongoid:(.+)$}
+            klass = resolve_class(Regexp.last_match[1])
+            payload = Hash[*object.children.map { |c| accept c }]
+            id = payload['attributes']['_id']
+            begin
+              klass.find(id)
+            rescue Mongoid::Errors::DocumentNotFound => e
+              raise Delayed::DeserializationError, "Mongoid::Errors::DocumentNotFound, class: #{klass}, primary key: #{id} (#{e.message})"
+            end
+          when %r{^!ruby/DataMapper:(.+)$}
+            klass = resolve_class(Regexp.last_match[1])
+            payload = Hash[*object.children.map { |c| accept c }]
+            begin
+              primary_keys = klass.properties.select(&:key?)
+              key_names = primary_keys.map { |p| p.name.to_s }
+              klass.get!(*key_names.map { |k| payload['attributes'][k] })
+            rescue DataMapper::ObjectNotFoundError => e
+              raise Delayed::DeserializationError, "DataMapper::ObjectNotFoundError, class: #{klass} (#{e.message})"
+            end
+          else
+            super
+        end
+      end
+
+      # defined? is triggering something really messed up in
+      # jruby causing both the if AND else clauses to execute,
+      # however if the check is run here, everything is fine
+      def jruby_is_seriously_borked
+        defined?(ActiveRecord::Base)
+      end
+
+      def resolve_class(klass_name)
+        return nil if klass_name.blank?
+
+        klass_name.constantize
+      rescue StandardError
+        super
+      end
+
+      def revive(klass, node)
+        klass.include?(Singleton) ? klass.instance : super
+      end
+    end
+  end
+end

data/lib/delayed/railtie.rb

@@ -0,0 +1,7 @@
+module Delayed
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load 'delayed/tasks.rb'
+    end
+  end
+end

data/lib/delayed/runnable.rb

@@ -0,0 +1,46 @@
+module Delayed
+  module Runnable
+    def start
+      trap('TERM') { quit! }
+      trap('INT') { quit! }
+
+      say "Starting #{self.class.name}"
+
+      Delayed.lifecycle.run_callbacks(:execute, nil) do
+        loop do
+          run!
+          break if stop?
+        end
+      end
+    ensure
+      on_exit!
+    end
+
+    private
+
+    def on_exit!; end
+
+    def interruptable_sleep(seconds)
+      IO.select([pipe[0]], nil, nil, seconds)
+    end
+
+    def stop
+      pipe[1].close
+    end
+
+    def stop?
+      pipe[1].closed?
+    end
+
+    def quit!
+      Thread.new { say 'Exiting...' }.tap do |t|
+        stop
+        t.join
+      end
+    end
+
+    def pipe
+      @pipe ||= IO.pipe
+    end
+  end
+end

data/lib/delayed/serialization/active_record.rb

@@ -0,0 +1,18 @@
+if defined?(ActiveRecord)
+  module ActiveRecord
+    class Base
+      yaml_tag 'tag:ruby.yaml.org,2002:ActiveRecord'
+
+      def self.yaml_new(klass, _tag, val)
+        klass.unscoped.find(val['attributes'][klass.primary_key])
+      rescue ActiveRecord::RecordNotFound
+        raise Delayed::DeserializationError,
+              "ActiveRecord::RecordNotFound, class: #{klass} , primary key: #{val['attributes'][klass.primary_key]}"
+      end
+
+      def to_yaml_properties
+        ['@attributes']
+      end
+    end
+  end
+end

data/lib/delayed/syck_ext.rb

@@ -0,0 +1,42 @@
+class Module
+  yaml_tag 'tag:ruby.yaml.org,2002:module'
+
+  def self.yaml_new(_klass, _tag, val)
+    val.constantize
+  end
+
+  def to_yaml(options = {})
+    YAML.quick_emit(nil, options) do |out|
+      out.scalar(taguri, name, :plain)
+    end
+  end
+
+  def yaml_tag_read_class(name)
+    # Constantize the object so that ActiveSupport can attempt
+    # its auto loading magic. Will raise LoadError if not successful.
+    name.constantize
+    name
+  end
+end
+
+class Class
+  yaml_tag 'tag:ruby.yaml.org,2002:class'
+  remove_method :to_yaml if respond_to?(:to_yaml) && method(:to_yaml).owner == Class # use Module's to_yaml
+end
+
+class Struct
+  def self.yaml_tag_read_class(name)
+    # Constantize the object so that ActiveSupport can attempt
+    # its auto loading magic. Will raise LoadError if not successful.
+    name.constantize
+    "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

@@ -0,0 +1,40 @@
+namespace :delayed do
+  task delayed_environment: :environment do
+    Delayed::Worker.min_priority = ENV['MIN_PRIORITY'].to_i if ENV.key?('MIN_PRIORITY')
+    Delayed::Worker.max_priority = ENV['MAX_PRIORITY'].to_i if ENV.key?('MAX_PRIORITY')
+    Delayed::Worker.queues = [ENV['QUEUE']] if ENV.key?('QUEUE')
+    Delayed::Worker.queues = ENV['QUEUES'].split(',') if ENV.key?('QUEUES')
+    Delayed::Worker.sleep_delay = ENV['SLEEP_DELAY'].to_i if ENV.key?('SLEEP_DELAY')
+    Delayed::Worker.read_ahead = ENV['READ_AHEAD'].to_i if ENV.key?('READ_AHEAD')
+    Delayed::Worker.max_claims = ENV['MAX_CLAIMS'].to_i if ENV.key?('MAX_CLAIMS')
+
+    next unless defined?(Rails.application.config)
+
+    # By default, Rails < 6.1 overrides eager_load to 'false' inside of rake tasks, which is not ideal in production environments.
+    # Additionally, the classic Rails autoloader is not threadsafe, so we do not want any autoloading after we start the worker.
+    # While the zeitwork autoloader technically does not need this workaround, we will still eager load for consistency's sake.
+    # We will use the cache_classes config as a proxy for determining if we should eager load before booting workers.
+    if !Rails.application.config.respond_to?(:rake_eager_load) && Rails.application.config.cache_classes
+      Rails.application.config.eager_load = true
+      Rails::Application::Finisher.initializers
+        .find { |i| i.name == :eager_load! }
+        .bind(Rails.application)
+        .run
+    end
+  end
+
+  desc 'start a delayed worker'
+  task work: :delayed_environment do
+    Delayed::Worker.new.start
+  end
+
+  desc 'monitor job queue and emit metrics at an interval'
+  task monitor: :delayed_environment do
+    Delayed::Monitor.new.start
+  end
+end
+
+# For backwards compatibility:
+namespace :jobs do
+  task work: %i(delayed:work)
+end

data/lib/delayed/worker.rb

@@ -0,0 +1,233 @@
+require 'timeout'
+require 'active_support/dependencies'
+require 'active_support/core_ext/numeric/time'
+require 'active_support/core_ext/class/attribute_accessors'
+require 'active_support/hash_with_indifferent_access'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'benchmark'
+require 'concurrent'
+
+module Delayed
+  class Worker
+    include Runnable
+
+    cattr_accessor :sleep_delay, instance_writer: false, default: 5
+    cattr_accessor :max_attempts, instance_writer: false, default: 25
+    cattr_accessor :max_claims, instance_writer: false, default: 5
+    cattr_accessor :max_run_time, instance_writer: false, default: 20.minutes
+    cattr_accessor :default_priority, instance_writer: false, default: 10
+    cattr_accessor :delay_jobs, instance_writer: false, default: true
+    cattr_accessor :queues, instance_writer: false, default: [].freeze
+    cattr_accessor :read_ahead, instance_writer: false, default: 5
+    cattr_accessor :destroy_failed_jobs, instance_writer: false, default: false
+
+    cattr_accessor :min_priority, :max_priority, instance_writer: false
+
+    # TODO: Remove this and rely on ActiveJob.queue_name when no queue is specified
+    cattr_accessor :default_queue_name, instance_writer: false, default: 'default'
+
+    # name_prefix is ignored if name is set directly
+    attr_accessor :name_prefix
+
+    class << self
+      delegate :lifecycle, :plugins, :plugins=, :logger, :logger=,
+               :default_log_level, :default_log_level=, to: Delayed
+    end
+
+    def self.delay_job?(job)
+      if delay_jobs.is_a?(Proc)
+        delay_jobs.arity == 1 ? delay_jobs.call(job) : delay_jobs.call
+      else
+        delay_jobs
+      end
+    end
+
+    def initialize
+      @failed_reserve_count = 0
+
+      # Reset lifecycle on the offhand chance that something lazily
+      # triggered its creation before all plugins had been registered.
+      Delayed.setup_lifecycle
+    end
+
+    # 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 restarts:  Workers can
+    # safely resume working on tasks which are locked by themselves. The worker will assume that
+    # it crashed before.
+    def name
+      return @name unless @name.nil?
+
+      begin
+        "#{@name_prefix}host:#{Socket.gethostname} pid:#{Process.pid}"
+      rescue StandardError
+        "#{@name_prefix}pid:#{Process.pid}"
+      end
+    end
+
+    # Sets the name of the worker.
+    # Setting the name to nil will reset the default worker name
+    attr_writer :name
+
+    def run!
+      @realtime = Benchmark.realtime do
+        @result = work_off
+      end
+
+      count = @result[0] + @result[1]
+
+      say format("#{count} jobs processed at %.4f j/s, %d failed", count / @realtime, @result.last) if count.positive?
+      interruptable_sleep(self.class.sleep_delay) if count < max_claims
+
+      reload! unless stop?
+    end
+
+    def on_exit!
+      Delayed::Job.clear_locks!(name)
+    end
+
+    # Do num jobs and return stats on success/failure.
+    # Exit early if interrupted.
+    def work_off(num = 100)
+      success = Concurrent::AtomicFixnum.new(0)
+      failure = Concurrent::AtomicFixnum.new(0)
+
+      num.times do
+        jobs = reserve_jobs
+        break if jobs.empty?
+
+        pool = Concurrent::FixedThreadPool.new(jobs.length)
+        jobs.each do |job|
+          pool.post do
+            run_thread_callbacks(job) do
+              if run_job(job)
+                success.increment
+              else
+                failure.increment
+              end
+            end
+          end
+        end
+
+        pool.shutdown
+        pool.wait_for_termination
+
+        break if stop? # leave if we're exiting
+      end
+
+      [success, failure].map(&:value)
+    end
+
+    def run_thread_callbacks(job, &block)
+      self.class.lifecycle.run_callbacks(:thread, self, job, &block)
+    end
+
+    def run(job)
+      metadata = {
+        status: 'RUNNING',
+        name: job.name,
+        run_at: job.run_at,
+        created_at: job.created_at,
+        priority: job.priority,
+        queue: job.queue,
+        attempts: job.attempts,
+        enqueued_for: (Time.current - job.created_at).round,
+      }
+      job_say job, metadata.to_json
+      run_time = Benchmark.realtime do
+        Timeout.timeout(max_run_time(job).to_i, WorkerTimeout) do
+          job.invoke_job
+        end
+        job.destroy
+      end
+      job_say job, format('COMPLETED after %.4f seconds', run_time)
+      true # did work
+    rescue DeserializationError => e
+      job_say job, "FAILED permanently with #{e.class.name}: #{e.message}", 'error'
+
+      job.error = e
+      failed(job)
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      self.class.lifecycle.run_callbacks(:error, self, job) { handle_failed_job(job, e) }
+      false # work failed
+    end
+
+    # Reschedule the job in the future (when a job fails).
+    # Uses an exponential scale depending on the number of failed attempts.
+    def reschedule(job, time = nil)
+      if (job.attempts += 1) < max_attempts(job)
+        time ||= job.reschedule_at
+        job.run_at = time
+        job.unlock
+        job.save!
+      else
+        job_say job, "FAILED permanently because of #{job.attempts} consecutive failures", 'error'
+        failed(job)
+      end
+    end
+
+    def failed(job)
+      self.class.lifecycle.run_callbacks(:failure, self, job) do
+        job.hook(:failure)
+      rescue StandardError => e
+        say "Error when running failure callback: #{e}", 'error'
+        say e.backtrace.join("\n"), 'error'
+      ensure
+        job.destroy_failed_jobs? ? job.destroy : job.fail!
+      end
+    end
+
+    def job_say(job, text, level = Delayed.default_log_level)
+      text = "Job #{job.name} (id=#{job.id})#{say_queue(job.queue)} #{text}"
+      say text, level
+    end
+
+    def say(text, level = Delayed.default_log_level)
+      text = "[Worker(#{name})] #{text}"
+      Delayed.say("#{Time.now.strftime('%FT%T%z')}: #{text}", level)
+    end
+
+    def max_attempts(job)
+      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 say_queue(queue)
+      " (queue=#{queue})" if queue
+    end
+
+    def handle_failed_job(job, error)
+      job.error = error
+      job_say job, "FAILED (#{job.attempts} prior attempts) with #{error.class.name}: #{error.message}", 'error'
+      reschedule(job)
+    end
+
+    def run_job(job)
+      self.class.lifecycle.run_callbacks(:perform, self, job) { run(job) }
+    end
+
+    # The backend adapter may return either a list or a single job
+    # In some backends, this can be controlled with the `max_claims` config
+    # Either way, we map this to an array of job instances
+    def reserve_jobs
+      jobs = [Delayed::Job.reserve(self)].compact.flatten(1)
+      @failed_reserve_count = 0
+      jobs
+    rescue ::Exception => e # rubocop:disable Lint/RescueException
+      say "Error while reserving job(s): #{e}"
+      Delayed::Job.recover_from(e)
+      @failed_reserve_count += 1
+      raise FatalBackendError if @failed_reserve_count >= 10
+
+      []
+    end
+
+    def reload!
+      Rails.application.reloader.reload! if defined?(Rails.application.reloader) && Rails.application.reloader.check!
+    end
+  end
+end