delayed 0.1.0

data/lib/delayed/lifecycle.rb

@@ -0,0 +1,85 @@
+module Delayed
+  class InvalidCallback < RuntimeError; end
+
+  class Lifecycle
+    EVENTS = {
+      execute: [nil],
+      enqueue: [:job],
+      perform: %i(worker job),
+      error: %i(worker job),
+      failure: %i(worker job),
+      thread: %i(worker job),
+      invoke_job: [:job],
+    }.freeze
+
+    def initialize
+      @callbacks = EVENTS.keys.each_with_object({}) do |e, hash|
+        hash[e] = Callback.new
+      end
+    end
+
+    def before(event, &block)
+      add(:before, event, &block)
+    end
+
+    def after(event, &block)
+      add(:after, event, &block)
+    end
+
+    def around(event, &block)
+      add(:around, event, &block)
+    end
+
+    def run_callbacks(event, *args, &block)
+      missing_callback(event) unless @callbacks.key?(event)
+
+      unless EVENTS[event].size == args.size
+        raise ArgumentError, "Callback #{event} expects #{EVENTS[event].size} parameter(s): #{EVENTS[event].join(', ')}"
+      end
+
+      @callbacks[event].execute(*args, &block)
+    end
+
+    private
+
+    def add(type, event, &block)
+      missing_callback(event) unless @callbacks.key?(event)
+      @callbacks[event].add(type, &block)
+    end
+
+    def missing_callback(event)
+      raise InvalidCallback, "Unknown callback event: #{event}"
+    end
+  end
+
+  class Callback
+    def initialize
+      @before = []
+      @after = []
+
+      # Identity proc. Avoids special cases when there is no existing around chain.
+      @around = lambda { |*args, &block| block.call(*args) }
+    end
+
+    def execute(*args, &block)
+      @before.each { |c| c.call(*args) }
+      result = @around.call(*args, &block)
+      @after.each { |c| c.call(*args) }
+      result
+    end
+
+    def add(type, &callback)
+      case type
+        when :before
+          @before << callback
+        when :after
+          @after << callback
+        when :around
+          chain = @around # use a local variable so that the current chain is closed over in the following lambda
+          @around = lambda { |*a, &block| chain.call(*a) { |*b| callback.call(*b, &block) } }
+        else
+          raise InvalidCallback, "Invalid callback type: #{type}"
+      end
+    end
+  end
+end

data/lib/delayed/message_sending.rb

@@ -0,0 +1,65 @@
+require 'active_support/proxy_object'
+
+module Delayed
+  class DelayProxy < ActiveSupport::ProxyObject
+    def initialize(payload_class, target, options)
+      @payload_class = payload_class
+      @target = target
+      @options = options
+    end
+
+    def method_missing(method, *args)
+      Job.enqueue({ payload_object: @payload_class.new(@target, method.to_sym, args) }.merge(@options))
+    end
+  end
+
+  module MessageSending
+    def delay(options = {})
+      DelayProxy.new(PerformableMethod, self, options)
+    end
+    alias __delay__ delay
+
+    def send_later(method, *args)
+      warn '[DEPRECATION] `object.send_later(:method)` is deprecated. Use `object.delay.method'
+      __delay__.__send__(method, *args)
+    end
+
+    def send_at(time, method, *args)
+      warn '[DEPRECATION] `object.send_at(time, :method)` is deprecated. Use `object.delay(:run_at => time).method'
+      __delay__(run_at: time).__send__(method, *args)
+    end
+  end
+
+  module MessageSendingClassMethods
+    def handle_asynchronously(method, opts = {}) # rubocop:disable Metrics/PerceivedComplexity
+      aliased_method = method.to_s.sub(/([?!=])$/, '')
+      punctuation = $1 # rubocop:disable Style/PerlBackrefs
+      with_method = "#{aliased_method}_with_delay#{punctuation}"
+      without_method = "#{aliased_method}_without_delay#{punctuation}"
+      define_method(with_method) do |*args|
+        curr_opts = opts.clone
+        curr_opts.each_key do |key|
+          next unless (val = curr_opts[key]).is_a?(Proc)
+
+          curr_opts[key] = if val.arity == 1
+                             val.call(self)
+                           else
+                             val.call
+                           end
+        end
+        delay(curr_opts).__send__(without_method, *args)
+      end
+
+      alias_method without_method, method
+      alias_method method, with_method
+
+      if public_method_defined?(without_method)
+        public method
+      elsif protected_method_defined?(without_method)
+        protected method
+      elsif private_method_defined?(without_method)
+        private method
+      end
+    end
+  end
+end

data/lib/delayed/monitor.rb

@@ -0,0 +1,134 @@
+module Delayed
+  class Monitor
+    include Runnable
+
+    METRICS = %w(
+      count
+      future_count
+      locked_count
+      erroring_count
+      failed_count
+      max_lock_age
+      max_age
+      working_count
+      workable_count
+      alert_age_percent
+    ).freeze
+
+    cattr_accessor :sleep_delay, instance_writer: false, default: 60
+
+    def initialize
+      @jobs = Job.group(priority_case_statement).group(:queue)
+      @jobs = @jobs.where(queue: Worker.queues) if Worker.queues.any?
+    end
+
+    def run!
+      ActiveSupport::Notifications.instrument('delayed.monitor.run', default_tags) do
+        METRICS.each { |metric| emit_metric!(metric) }
+      end
+      interruptable_sleep(sleep_delay)
+    end
+
+    private
+
+    attr_reader :jobs
+
+    def emit_metric!(metric)
+      send("#{metric}_grouped").reverse_merge(default_results).each do |(priority, queue), value|
+        ActiveSupport::Notifications.instrument(
+          "delayed.job.#{metric}",
+          default_tags.merge(priority: Priority.new(priority).to_s, queue: queue, value: value),
+        )
+      end
+    end
+
+    def default_results
+      @default_results ||= Priority.names.values.flat_map { |priority|
+        (Worker.queues.presence || [Worker.default_queue_name]).map do |queue|
+          [[priority.to_i, queue], 0]
+        end
+      }.to_h
+    end
+
+    def say(message)
+      Delayed.say(message)
+    end
+
+    def default_tags
+      @default_tags ||= {
+        table: Job.table_name,
+        database: Job.database_name,
+        database_adapter: Job.database_adapter_name,
+      }
+    end
+
+    def count_grouped
+      jobs.count
+    end
+
+    def future_count_grouped
+      jobs.where("run_at > ?", Job.db_time_now).count
+    end
+
+    def locked_count_grouped
+      jobs.locked.count
+    end
+
+    def erroring_count_grouped
+      jobs.erroring.count
+    end
+
+    def failed_count_grouped
+      jobs.failed.count
+    end
+
+    def max_lock_age_grouped
+      oldest_locked_job_grouped.each_with_object({}) do |job, metrics|
+        metrics[[job.priority.to_i, job.queue]] = Job.db_time_now - job.locked_at
+      end
+    end
+
+    def max_age_grouped
+      oldest_workable_job_grouped.each_with_object({}) do |job, metrics|
+        metrics[[job.priority.to_i, job.queue]] = Job.db_time_now - job.run_at
+      end
+    end
+
+    def alert_age_percent_grouped
+      oldest_workable_job_grouped.each_with_object({}) do |job, metrics|
+        max_age = Job.db_time_now - job.run_at
+        metrics[[job.priority.to_i, job.queue]] = [max_age / job.priority.alert_age * 100, 100].min if job.priority.alert_age
+      end
+    end
+
+    def workable_count_grouped
+      jobs.workable(Job.db_time_now).count
+    end
+
+    def working_count_grouped
+      jobs.working.count
+    end
+
+    def oldest_locked_job_grouped
+      jobs.working.select("#{priority_case_statement} AS priority, queue, MIN(locked_at) AS locked_at")
+    end
+
+    def oldest_workable_job_grouped
+      jobs.workable(Job.db_time_now).select("(#{priority_case_statement}) AS priority, queue, MIN(run_at) AS run_at")
+    end
+
+    def priority_case_statement
+      [
+        'CASE',
+        Priority.ranges.values.map do |range|
+          [
+            "WHEN priority >= #{range.first.to_i}",
+            ("AND priority < #{range.last.to_i}" unless range.last.infinite?),
+            "THEN #{range.first.to_i}",
+          ].compact
+        end,
+        'END',
+      ].flatten.join(' ')
+    end
+  end
+end

data/lib/delayed/performable_mailer.rb

@@ -0,0 +1,22 @@
+require 'mail'
+
+module Delayed
+  class PerformableMailer < PerformableMethod
+    def perform
+      mailer = object.send(method_name, *args)
+      mailer.respond_to?(:deliver_now) ? mailer.deliver_now : mailer.deliver
+    end
+  end
+
+  module DelayMail
+    def delay(options = {})
+      DelayProxy.new(PerformableMailer, self, options)
+    end
+  end
+end
+
+Mail::Message.class_eval do
+  def delay(*_args)
+    raise 'Use MyMailer.delay.mailer_action(args) to delay sending of emails.'
+  end
+end

data/lib/delayed/performable_method.rb

@@ -0,0 +1,47 @@
+module Delayed
+  class PerformableMethod
+    attr_accessor :object, :method_name, :args
+
+    def initialize(object, method_name, args)
+      raise NoMethodError, "undefined method `#{method_name}' for #{object.inspect}" unless object.respond_to?(method_name, true)
+
+      if !her_model?(object) && object.respond_to?(:persisted?) && !object.persisted?
+        raise(ArgumentError, "job cannot be created for non-persisted record: #{object.inspect}")
+      end
+
+      self.object       = object
+      self.args         = args
+      self.method_name  = method_name.to_sym
+    end
+
+    def display_name
+      if object.is_a?(Class)
+        "#{object}.#{method_name}"
+      else
+        "#{object.class}##{method_name}"
+      end
+    end
+
+    def perform
+      object.send(method_name, *args) if object
+    end
+
+    def method(sym)
+      object.method(sym)
+    end
+
+    def method_missing(symbol, *args)
+      object.send(symbol, *args)
+    end
+
+    def respond_to?(symbol, include_private = false)
+      super || object.respond_to?(symbol, include_private)
+    end
+
+    private
+
+    def her_model?(object)
+      object.class.respond_to?(:save_existing)
+    end
+  end
+end

data/lib/delayed/plugin.rb

@@ -0,0 +1,15 @@
+require 'active_support/core_ext/class/attribute'
+
+module Delayed
+  class Plugin
+    class_attribute :callback_block
+
+    def self.callbacks(&block)
+      self.callback_block = block
+    end
+
+    def initialize
+      self.class.callback_block.call(Delayed.lifecycle) if self.class.callback_block
+    end
+  end
+end

data/lib/delayed/plugins/connection.rb

@@ -0,0 +1,13 @@
+module Delayed
+  module Plugins
+    class Connection < Plugin
+      callbacks do |lifecycle|
+        lifecycle.around(:thread) do |worker, job, &block|
+          Job.connection_pool.with_connection do
+            block.call(worker, job)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/delayed/plugins/instrumentation.rb

@@ -0,0 +1,39 @@
+module Delayed
+  module Plugins
+    class Instrumentation < Plugin
+      callbacks do |lifecycle|
+        lifecycle.around(:enqueue) do |job, *args, &block|
+          ActiveSupport::Notifications.instrument('delayed.job.enqueue', active_support_notifications_tags(job)) do
+            block.call(job, *args)
+          end
+        end
+
+        lifecycle.around(:invoke_job) do |job, *args, &block|
+          ActiveSupport::Notifications.instrument('delayed.job.run', active_support_notifications_tags(job)) do
+            block.call(job, *args)
+          end
+        end
+
+        lifecycle.after(:error) do |_worker, job, *_args|
+          ActiveSupport::Notifications.instrument('delayed.job.error', active_support_notifications_tags(job))
+        end
+
+        lifecycle.after(:failure) do |_worker, job, *_args|
+          ActiveSupport::Notifications.instrument('delayed.job.failure', active_support_notifications_tags(job))
+        end
+      end
+
+      def self.active_support_notifications_tags(job)
+        {
+          job_name: job.name,
+          priority: job.priority,
+          queue: job.queue,
+          table: job.class.table_name,
+          database: job.class.database_name,
+          database_adapter: job.class.database_adapter_name,
+          job: job,
+        }
+      end
+    end
+  end
+end

data/lib/delayed/priority.rb

@@ -0,0 +1,164 @@
+module Delayed
+  class Priority < Numeric
+    # A Delayed::Priority represents a value that exists within a named range.
+    # Here are the default ranges and their names:
+    #
+    #   0-9: interactive
+    # 10-19: user_visible
+    # 20-29: eventual
+    #   30+: reporting
+    #
+    # Ranges can be customized. They must be positive and must include a name for priority >= 0.
+    # The following config will produce ranges 0-99 (high), 100-499 (medium) and 500+ (low):
+    #
+    # > Delayed::Priority.names = { high: 0, medium: 100, low: 500 }
+
+    DEFAULT_NAMES = {
+      interactive: 0, # These jobs will actively hinder end-user interactions until they are complete, e.g. work behind a loading spinner
+      user_visible: 10, # These jobs have end-user-visible side effects that will not obviously impact customers, e.g. welcome emails
+      eventual: 20, # These jobs affect business process that are tolerant to some degree of queue backlog, e.g. syncing with other services
+      reporting: 30, # These jobs are for processes that can complete on a slower timeline, e.g. daily report generation
+    }.freeze
+
+    # Priorities can be mapped to alerting thresholds for job age (time since run_at), runtime, and attempts.
+    # These thresholds can be used to emit events or metrics. Here are the default values (for the default priorities):
+    #
+    # === Age Alerts ==========
+    #   interactive: 1 minute
+    #  user_visible: 3 minutes
+    #      eventual: 1.5 hours
+    #     reporting: 4 hours
+    #
+    # === Run Time Alerts ======
+    #   interactive: 30 seconds
+    #  user_visible: 90 seconds
+    #      eventual: 5 minutes
+    #     reporting: 10 minutes
+    #
+    # === Attempts Alerts =====
+    #   interactive: 3 attempts
+    #  user_visible: 5 attempts
+    #      eventual: 8 attempts
+    #     reporting: 8 attempts
+    #
+    # Alerting thresholds can be customized. The keys must match `Delayed::Priority.names`.
+    #
+    # Delayed::Priority.alerts = {
+    #   high: { age: 30.seconds, run_time: 15.seconds, attempts: 3 },
+    #   medium: { age: 2.minutes, run_time: 1.minute, attempts: 6 },
+    #   low: { age: 10.minutes, run_time: 2.minutes, attempts: 9 },
+    # }
+
+    DEFAULT_ALERTS = {
+      interactive: { age: 1.minute, run_time: 30.seconds, attempts: 3 },
+      user_visible: { age: 3.minutes, run_time: 90.seconds, attempts: 5 },
+      eventual: { age: 1.5.hours, run_time: 5.minutes, attempts: 8 },
+      reporting: { age: 4.hours, run_time: 10.minutes, attempts: 8 },
+    }.freeze
+
+    class << self
+      def names
+        @names || default_names
+      end
+
+      def alerts
+        @alerts || default_alerts
+      end
+
+      def names=(names)
+        raise "must include a name for priority >= 0" if names && !names.value?(0)
+
+        @ranges = nil
+        @alerts = nil
+        @names = names&.sort_by(&:last)&.to_h&.transform_values { |v| new(v) }
+      end
+
+      def alerts=(alerts)
+        if alerts
+          unknown_names = alerts.keys - names.keys
+          raise "unknown priority name(s): #{unknown_names}" if unknown_names.any?
+        end
+
+        @alerts = alerts&.sort_by { |k, _| names.keys.index(k) }&.to_h
+      end
+
+      def ranges
+        @ranges ||= names.zip(names.except(names.keys.first)).each_with_object({}) do |((name, lower), (_, upper)), obj|
+          obj[name] = (lower...(upper || Float::INFINITY))
+        end
+      end
+
+      private
+
+      def default_names
+        @default_names ||= DEFAULT_NAMES.transform_values { |v| new(v) }
+      end
+
+      def default_alerts
+        @names ? {} : DEFAULT_ALERTS
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        names.key?(method_name) || super
+      end
+
+      def method_missing(method_name, *args)
+        if names.key?(method_name) && args.none?
+          names[method_name]
+        else
+          super
+        end
+      end
+    end
+
+    attr_reader :value
+
+    delegate :to_i, to: :value
+    delegate :to_s, to: :name
+
+    def initialize(value)
+      super()
+      value = self.class.names[value] if value.is_a?(Symbol)
+      @value = value.to_i
+    end
+
+    def name
+      @name ||= self.class.ranges.find { |(_, r)| r.include?(to_i) }&.first
+    end
+
+    def alert_age
+      self.class.alerts.dig(name, :age)
+    end
+
+    def alert_run_time
+      self.class.alerts.dig(name, :run_time)
+    end
+
+    def alert_attempts
+      self.class.alerts.dig(name, :attempts)
+    end
+
+    def coerce(other)
+      [self.class.new(other), self]
+    end
+
+    def <=>(other)
+      other = other.to_i if other.is_a?(self.class)
+      to_i <=> other
+    end
+
+    private
+
+    def respond_to_missing?(method_name, include_private = false)
+      method_name.to_s.end_with?('?') && self.class.names.key?(method_name.to_s[0..-2].to_sym) || super
+    end
+
+    def method_missing(method_name, *args)
+      if method_name.to_s.end_with?('?') && self.class.names.key?(method_name.to_s[0..-2].to_sym)
+        method_name.to_s[0..-2] == to_s
+      else
+        super
+      end
+    end
+  end
+end