sr-sidekiq 4.1.6

data/lib/sidekiq/core_ext.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+begin
+  require 'active_support/core_ext/class/attribute'
+rescue LoadError
+
+  # A dumbed down version of ActiveSupport's
+  # Class#class_attribute helper.
+  class Class
+    def class_attribute(*attrs)
+      instance_writer = true
+
+      attrs.each do |name|
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def self.#{name}() nil end
+          def self.#{name}?() !!#{name} end
+
+          def self.#{name}=(val)
+            singleton_class.class_eval do
+              define_method(:#{name}) { val }
+            end
+
+            if singleton_class?
+              class_eval do
+                def #{name}
+                  defined?(@#{name}) ? @#{name} : singleton_class.#{name}
+                end
+              end
+            end
+            val
+          end
+
+          def #{name}
+            defined?(@#{name}) ? @#{name} : self.class.#{name}
+          end
+
+          def #{name}?
+            !!#{name}
+          end
+        RUBY
+
+        attr_writer name if instance_writer
+      end
+    end
+
+    private
+    def singleton_class?
+      ancestors.first != self
+    end
+  end
+end
+
+begin
+  require 'active_support/core_ext/hash/keys'
+  require 'active_support/core_ext/hash/deep_merge'
+rescue LoadError
+  class Hash
+    def stringify_keys
+      keys.each do |key|
+        self[key.to_s] = delete(key)
+      end
+      self
+    end if !{}.respond_to?(:stringify_keys)
+
+    def symbolize_keys
+      keys.each do |key|
+        self[(key.to_sym rescue key) || key] = delete(key)
+      end
+      self
+    end if !{}.respond_to?(:symbolize_keys)
+
+    def deep_merge(other_hash, &block)
+      dup.deep_merge!(other_hash, &block)
+    end if !{}.respond_to?(:deep_merge)
+
+    def deep_merge!(other_hash, &block)
+      other_hash.each_pair do |k,v|
+        tv = self[k]
+        if tv.is_a?(Hash) && v.is_a?(Hash)
+          self[k] = tv.deep_merge(v, &block)
+        else
+          self[k] = block && tv ? block.call(k, tv, v) : v
+        end
+      end
+      self
+    end if !{}.respond_to?(:deep_merge!)
+  end
+end
+
+begin
+  require 'active_support/core_ext/string/inflections'
+rescue LoadError
+  class String
+    def constantize
+      names = self.split('::')
+      names.shift if names.empty? || names.first.empty?
+
+      constant = Object
+      names.each do |name|
+        constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+      end
+      constant
+    end
+  end if !"".respond_to?(:constantize)
+end
+
+

data/lib/sidekiq/exception_handler.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+require 'sidekiq'
+
+module Sidekiq
+  module ExceptionHandler
+
+    class Logger
+      def call(ex, ctxHash)
+        Sidekiq.logger.warn(Sidekiq.dump_json(ctxHash)) if !ctxHash.empty?
+        Sidekiq.logger.warn "#{ex.class.name}: #{ex.message}"
+        Sidekiq.logger.warn ex.backtrace.join("\n") unless ex.backtrace.nil?
+      end
+
+      # Set up default handler which just logs the error
+      Sidekiq.error_handlers << Sidekiq::ExceptionHandler::Logger.new
+    end
+
+    def handle_exception(ex, ctxHash={})
+      Sidekiq.error_handlers.each do |handler|
+        begin
+          handler.call(ex, ctxHash)
+        rescue => ex
+          Sidekiq.logger.error "!!! ERROR HANDLER THREW AN ERROR !!!"
+          Sidekiq.logger.error ex
+          Sidekiq.logger.error ex.backtrace.join("\n") unless ex.backtrace.nil?
+        end
+      end
+    end
+
+  end
+end

data/lib/sidekiq/extensions/action_mailer.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+require 'sidekiq/extensions/generic_proxy'
+
+module Sidekiq
+  module Extensions
+    ##
+    # Adds 'delay', 'delay_for' and `delay_until` methods to ActionMailer to offload arbitrary email
+    # delivery to Sidekiq.  Example:
+    #
+    #    UserMailer.delay.send_welcome_email(new_user)
+    #    UserMailer.delay_for(5.days).send_welcome_email(new_user)
+    #    UserMailer.delay_until(5.days.from_now).send_welcome_email(new_user)
+    class DelayedMailer
+      include Sidekiq::Worker
+
+      def perform(yml)
+        (target, method_name, args) = YAML.load(yml)
+        msg = target.public_send(method_name, *args)
+        # The email method can return nil, which causes ActionMailer to return
+        # an undeliverable empty message.
+        if msg
+          deliver(msg)
+        else
+          raise "#{target.name}##{method_name} returned an undeliverable mail object"
+        end
+      end
+
+      private
+
+      def deliver(msg)
+        if msg.respond_to?(:deliver_now)
+          # Rails 4.2/5.0
+          msg.deliver_now
+        else
+          # Rails 3.2/4.0/4.1
+          msg.deliver
+        end
+      end
+    end
+
+    module ActionMailer
+      def sidekiq_delay(options={})
+        Proxy.new(DelayedMailer, self, options)
+      end
+      def sidekiq_delay_for(interval, options={})
+        Proxy.new(DelayedMailer, self, options.merge('at' => Time.now.to_f + interval.to_f))
+      end
+      def sidekiq_delay_until(timestamp, options={})
+        Proxy.new(DelayedMailer, self, options.merge('at' => timestamp.to_f))
+      end
+      alias_method :delay, :sidekiq_delay
+      alias_method :delay_for, :sidekiq_delay_for
+      alias_method :delay_until, :sidekiq_delay_until
+    end
+
+  end
+end

data/lib/sidekiq/extensions/active_record.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+require 'sidekiq/extensions/generic_proxy'
+
+module Sidekiq
+  module Extensions
+    ##
+    # Adds 'delay', 'delay_for' and `delay_until` methods to ActiveRecord to offload instance method
+    # execution to Sidekiq.  Examples:
+    #
+    # User.recent_signups.each { |user| user.delay.mark_as_awesome }
+    #
+    # Please note, this is not recommended as this will serialize the entire
+    # object to Redis.  Your Sidekiq jobs should pass IDs, not entire instances.
+    # This is here for backwards compatibility with Delayed::Job only.
+    class DelayedModel
+      include Sidekiq::Worker
+
+      def perform(yml)
+        (target, method_name, args) = YAML.load(yml)
+        target.__send__(method_name, *args)
+      end
+    end
+
+    module ActiveRecord
+      def sidekiq_delay(options={})
+        Proxy.new(DelayedModel, self, options)
+      end
+      def sidekiq_delay_for(interval, options={})
+        Proxy.new(DelayedModel, self, options.merge('at' => Time.now.to_f + interval.to_f))
+      end
+      def sidekiq_delay_until(timestamp, options={})
+        Proxy.new(DelayedModel, self, options.merge('at' => timestamp.to_f))
+      end
+      alias_method :delay, :sidekiq_delay
+      alias_method :delay_for, :sidekiq_delay_for
+      alias_method :delay_until, :sidekiq_delay_until
+    end
+
+  end
+end

data/lib/sidekiq/extensions/class_methods.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+require 'sidekiq/extensions/generic_proxy'
+
+module Sidekiq
+  module Extensions
+    ##
+    # Adds 'delay', 'delay_for' and `delay_until` methods to all Classes to offload class method
+    # execution to Sidekiq.  Examples:
+    #
+    # User.delay.delete_inactive
+    # Wikipedia.delay.download_changes_for(Date.today)
+    #
+    class DelayedClass
+      include Sidekiq::Worker
+
+      def perform(yml)
+        (target, method_name, args) = YAML.load(yml)
+        target.__send__(method_name, *args)
+      end
+    end
+
+    module Klass
+      def sidekiq_delay(options={})
+        Proxy.new(DelayedClass, self, options)
+      end
+      def sidekiq_delay_for(interval, options={})
+        Proxy.new(DelayedClass, self, options.merge('at' => Time.now.to_f + interval.to_f))
+      end
+      def sidekiq_delay_until(timestamp, options={})
+        Proxy.new(DelayedClass, self, options.merge('at' => timestamp.to_f))
+      end
+      alias_method :delay, :sidekiq_delay
+      alias_method :delay_for, :sidekiq_delay_for
+      alias_method :delay_until, :sidekiq_delay_until
+    end
+
+  end
+end
+
+Module.__send__(:include, Sidekiq::Extensions::Klass) unless defined?(::Rails)

data/lib/sidekiq/extensions/generic_proxy.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+require 'yaml'
+
+module Sidekiq
+  module Extensions
+    class Proxy < BasicObject
+      def initialize(performable, target, options={})
+        @performable = performable
+        @target = target
+        @opts = options
+      end
+
+      def method_missing(name, *args)
+        # Sidekiq has a limitation in that its message must be JSON.
+        # JSON can't round trip real Ruby objects so we use YAML to
+        # serialize the objects to a String.  The YAML will be converted
+        # to JSON and then deserialized on the other side back into a
+        # Ruby object.
+        obj = [@target, name, args]
+        @performable.client_push({ 'class' => @performable, 'args' => [::YAML.dump(obj)] }.merge(@opts))
+      end
+    end
+
+  end
+end

data/lib/sidekiq/fetch.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+require 'sidekiq'
+
+module Sidekiq
+  class BasicFetch
+    # We want the fetch operation to timeout every few seconds so the thread
+    # can check if the process is shutting down.
+    TIMEOUT = 2
+
+    UnitOfWork = Struct.new(:queue, :job) do
+      def acknowledge
+        # nothing to do
+      end
+
+      def queue_name
+        queue.sub(/.*queue:/, ''.freeze)
+      end
+
+      def requeue
+        Sidekiq.redis do |conn|
+          conn.rpush("queue:#{queue_name}", job)
+        end
+      end
+    end
+
+    def initialize(options)
+      @strictly_ordered_queues = !!options[:strict]
+      @queues = options[:queues].map { |q| "queue:#{q}" }
+      if @strictly_ordered_queues
+        @queues = @queues.uniq
+        @queues << TIMEOUT
+      end
+    end
+
+    def retrieve_work
+      work = Sidekiq.redis { |conn| conn.brpop(*queues_cmd) }
+      UnitOfWork.new(*work) if work
+    end
+
+    # Creating the Redis#brpop command takes into account any
+    # configured queue weights. By default Redis#brpop returns
+    # data from the first queue that has pending elements. We
+    # recreate the queue command each time we invoke Redis#brpop
+    # to honor weights and avoid queue starvation.
+    def queues_cmd
+      if @strictly_ordered_queues
+        @queues
+      else
+        queues = @queues.shuffle.uniq
+        queues << TIMEOUT
+        queues
+      end
+    end
+
+
+    # By leaving this as a class method, it can be pluggable and used by the Manager actor. Making it
+    # an instance method will make it async to the Fetcher actor
+    def self.bulk_requeue(inprogress, options)
+      return if inprogress.empty?
+
+      Sidekiq.logger.debug { "Re-queueing terminated jobs" }
+      jobs_to_requeue = {}
+      inprogress.each do |unit_of_work|
+        jobs_to_requeue[unit_of_work.queue_name] ||= []
+        jobs_to_requeue[unit_of_work.queue_name] << unit_of_work.job
+      end
+
+      Sidekiq.redis do |conn|
+        conn.pipelined do
+          jobs_to_requeue.each do |queue, jobs|
+            conn.rpush("queue:#{queue}", jobs)
+          end
+        end
+      end
+      Sidekiq.logger.info("Pushed #{inprogress.size} jobs back to Redis")
+    rescue => ex
+      Sidekiq.logger.warn("Failed to requeue #{inprogress.size} jobs: #{ex.message}")
+    end
+
+  end
+end

data/lib/sidekiq/launcher.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+# encoding: utf-8
+require 'sidekiq/manager'
+require 'sidekiq/fetch'
+require 'sidekiq/scheduled'
+
+module Sidekiq
+  # The Launcher is a very simple Actor whose job is to
+  # start, monitor and stop the core Actors in Sidekiq.
+  # If any of these actors die, the Sidekiq process exits
+  # immediately.
+  class Launcher
+    include Util
+
+    attr_accessor :manager, :poller, :fetcher
+
+    def initialize(options)
+      @manager = Sidekiq::Manager.new(options)
+      @poller = Sidekiq::Scheduled::Poller.new
+      @done = false
+      @options = options
+    end
+
+    def run
+      @thread = safe_thread("heartbeat", &method(:start_heartbeat))
+      @poller.start
+      @manager.start
+    end
+
+    # Stops this instance from processing any more jobs,
+    #
+    def quiet
+      @done = true
+      @manager.quiet
+      @poller.terminate
+    end
+
+    # Shuts down the process.  This method does not
+    # return until all work is complete and cleaned up.
+    # It can take up to the timeout to complete.
+    def stop
+      deadline = Time.now + @options[:timeout]
+
+      @done = true
+      @manager.quiet
+      @poller.terminate
+
+      @manager.stop(deadline)
+
+      # Requeue everything in case there was a worker who grabbed work while stopped
+      # This call is a no-op in Sidekiq but necessary for Sidekiq Pro.
+      strategy = (@options[:fetch] || Sidekiq::BasicFetch)
+      strategy.bulk_requeue([], @options)
+
+      clear_heartbeat
+    end
+
+    def stopping?
+      @done
+    end
+
+    private unless $TESTING
+
+    JVM_RESERVED_SIGNALS = ['USR1', 'USR2'] # Don't Process#kill if we get these signals via the API
+
+    def heartbeat(k, data, json)
+      results = Sidekiq::CLI::PROCTITLES.map {|x| x.(self, data) }
+      results.compact!
+      $0 = results.join(' ')
+
+      ❤(k, json)
+    end
+
+    def ❤(key, json)
+      fails = procd = 0
+      begin
+        Processor::FAILURE.update {|curr| fails = curr; 0 }
+        Processor::PROCESSED.update {|curr| procd = curr; 0 }
+
+        workers_key = "#{key}:workers".freeze
+        nowdate = Time.now.utc.strftime("%Y-%m-%d".freeze)
+        Sidekiq.redis do |conn|
+          conn.pipelined do
+            conn.incrby("stat:processed".freeze, procd)
+            conn.incrby("stat:processed:#{nowdate}", procd)
+            conn.incrby("stat:failed".freeze, fails)
+            conn.incrby("stat:failed:#{nowdate}", fails)
+            conn.del(workers_key)
+            Processor::WORKER_STATE.each_pair do |tid, hash|
+              conn.hset(workers_key, tid, Sidekiq.dump_json(hash))
+            end
+            conn.expire(workers_key, 60)
+          end
+        end
+        fails = procd = 0
+
+        _, _, _, msg = Sidekiq.redis do |conn|
+          conn.pipelined do
+            conn.sadd('processes', key)
+            conn.hmset(key, 'info', json, 'busy', Processor::WORKER_STATE.size, 'beat', Time.now.to_f, 'quiet', @done)
+            conn.expire(key, 60)
+            conn.rpop("#{key}-signals")
+          end
+        end
+
+        return unless msg
+
+        if JVM_RESERVED_SIGNALS.include?(msg)
+          Sidekiq::CLI.instance.handle_signal(msg)
+        else
+          ::Process.kill(msg, $$)
+        end
+      rescue => e
+        # ignore all redis/network issues
+        logger.error("heartbeat: #{e.message}")
+        # don't lose the counts if there was a network issue
+        Processor::PROCESSED.increment(procd)
+        Processor::FAILURE.increment(fails)
+      end
+    end
+
+    def start_heartbeat
+      k = identity
+      data = {
+        'hostname' => hostname,
+        'started_at' => Time.now.to_f,
+        'pid' => $$,
+        'tag' => @options[:tag] || '',
+        'concurrency' => @options[:concurrency],
+        'queues' => @options[:queues].uniq,
+        'labels' => @options[:labels],
+        'identity' => k,
+      }
+      # this data doesn't change so dump it to a string
+      # now so we don't need to dump it every heartbeat.
+      json = Sidekiq.dump_json(data)
+
+      while true
+        heartbeat(k, data, json)
+        sleep 5
+      end
+      Sidekiq.logger.info("Heartbeat stopping...")
+    end
+
+    def clear_heartbeat
+      # Remove record from Redis since we are shutting down.
+      # Note we don't stop the heartbeat thread; if the process
+      # doesn't actually exit, it'll reappear in the Web UI.
+      Sidekiq.redis do |conn|
+        conn.pipelined do
+          conn.srem('processes', identity)
+          conn.del("#{identity}:workers")
+        end
+      end
+    rescue
+      # best effort, ignore network errors
+    end
+
+  end
+end