sidekiq 5.2.6 → 7.1.0

data/Rakefile

@@ -1,9 +0,0 @@
-require 'bundler/gem_tasks'
-require 'rake/testtask'
-
-Rake::TestTask.new(:test) do |test|
-  test.warning = true
-  test.pattern = 'test/**/test_*.rb'
-end
-
-task default: :test

data/bin/sidekiqctl

@@ -1,20 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'fileutils'
-require 'sidekiq/api'
-require 'sidekiq/ctl'
-
-if ARGV[0] == 'status'
-  Sidekiq::Ctl::Status.new.display(ARGV[1])
-else
-  if ARGV.length < 2
-    Sidekiq::Ctl.print_usage
-  else
-    stage = ARGV[0]
-    pidfile = ARGV[1]
-    timeout = ARGV[2].to_i
-    timeout = Sidekiq::Ctl::DEFAULT_KILL_TIMEOUT if timeout == 0
-
-    Sidekiq::Ctl.new(stage, pidfile, timeout)
-  end
-end

data/code_of_conduct.md

@@ -1,50 +0,0 @@
-# Contributor Code of Conduct
-
-As contributors and maintainers of this project, and in the interest of
-fostering an open and welcoming community, we pledge to respect all people who
-contribute through reporting issues, posting feature requests, updating
-documentation, submitting pull requests or patches, and other activities.
-
-We are committed to making participation in this project a harassment-free
-experience for everyone, regardless of level of experience, gender, gender
-identity and expression, sexual orientation, disability, personal appearance,
-body size, race, ethnicity, age, religion, or nationality.
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery
-* Personal attacks
-* Trolling or insulting/derogatory comments
-* Public or private harassment
-* Publishing other's private information, such as physical or electronic
-  addresses, without explicit permission
-* Other unethical or unprofessional conduct
-
-Project maintainers have the right and responsibility to remove, edit, or
-reject comments, commits, code, wiki edits, issues, and other contributions
-that are not aligned to this Code of Conduct, or to ban temporarily or
-permanently any contributor for other behaviors that they deem inappropriate,
-threatening, offensive, or harmful.
-
-By adopting this Code of Conduct, project maintainers commit themselves to
-fairly and consistently applying these principles to every aspect of managing
-this project. Project maintainers who do not follow or enforce the Code of
-Conduct may be permanently removed from the project team.
-
-This Code of Conduct applies both within project spaces and in public spaces
-when an individual is representing the project or its community.
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project maintainer at mperham AT gmail.com. All
-complaints will be reviewed and investigated and will result in a response that
-is deemed necessary and appropriate to the circumstances. Maintainers are
-obligated to maintain confidentiality with regard to the reporter of an
-incident.
-
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage],
-version 1.3.0, available at
-[http://contributor-covenant.org/version/1/3/0/][version]
-
-[homepage]: http://contributor-covenant.org
-[version]: http://contributor-covenant.org/version/1/3/0/

data/lib/generators/sidekiq/worker_generator.rb

@@ -1,49 +0,0 @@
-require 'rails/generators/named_base'
-
-module Sidekiq
-  module Generators # :nodoc:
-    class WorkerGenerator < ::Rails::Generators::NamedBase # :nodoc:
-      desc 'This generator creates a Sidekiq Worker in app/workers and a corresponding test'
-
-      check_class_collision suffix: 'Worker'
-
-      def self.default_generator_root
-        File.dirname(__FILE__)
-      end
-
-      def create_worker_file
-        template 'worker.rb.erb', File.join('app/workers', class_path, "#{file_name}_worker.rb")
-      end
-
-      def create_test_file
-        if defined?(RSpec)
-          create_worker_spec
-        else
-          create_worker_test
-        end
-      end
-
-      private
-
-      def create_worker_spec
-        template_file = File.join(
-            'spec/workers',
-            class_path,
-            "#{file_name}_worker_spec.rb"
-        )
-        template 'worker_spec.rb.erb', template_file
-      end
-
-      def create_worker_test
-        template_file = File.join(
-            'test/workers',
-            class_path,
-            "#{file_name}_worker_test.rb"
-        )
-        template 'worker_test.rb.erb', template_file
-      end
-
-
-    end
-  end
-end

data/lib/sidekiq/core_ext.rb

@@ -1 +0,0 @@
-raise "no longer used, will be removed in 5.1"

data/lib/sidekiq/ctl.rb

@@ -1,221 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'fileutils'
-require 'sidekiq/api'
-
-class Sidekiq::Ctl
-  DEFAULT_KILL_TIMEOUT = 10
-  CMD = File.basename($0)
-
-  attr_reader :stage, :pidfile, :kill_timeout
-
-  def self.print_usage
-    puts "#{CMD} - control Sidekiq from the command line."
-    puts
-    puts "Usage: #{CMD} quiet <pidfile> <kill_timeout>"
-    puts "       #{CMD} stop <pidfile> <kill_timeout>"
-    puts "       #{CMD} status <section>"
-    puts
-    puts "       <pidfile> is path to a pidfile"
-    puts "       <kill_timeout> is number of seconds to wait until Sidekiq exits"
-    puts "       (default: #{Sidekiqctl::DEFAULT_KILL_TIMEOUT}), after which Sidekiq will be KILL'd"
-    puts
-    puts "       <section> (optional) view a specific section of the status output"
-    puts "       Valid sections are: #{Sidekiqctl::Status::VALID_SECTIONS.join(', ')}"
-    puts
-    puts "Be sure to set the kill_timeout LONGER than Sidekiq's -t timeout.  If you want"
-    puts "to wait 60 seconds for jobs to finish, use `sidekiq -t 60` and `sidekiqctl stop"
-    puts " path_to_pidfile 61`"
-    puts
-  end
-
-  def initialize(stage, pidfile, timeout)
-    @stage = stage
-    @pidfile = pidfile
-    @kill_timeout = timeout
-
-    done('No pidfile given', :error) if !pidfile
-    done("Pidfile #{pidfile} does not exist", :warn) if !File.exist?(pidfile)
-    done('Invalid pidfile content', :error) if pid == 0
-
-    fetch_process
-
-    begin
-      send(stage)
-    rescue NoMethodError
-      done "Invalid command: #{stage}", :error
-    end
-  end
-
-  def fetch_process
-    Process.kill(0, pid)
-  rescue Errno::ESRCH
-    done "Process doesn't exist", :error
-  # We were not allowed to send a signal, but the process must have existed
-  # when Process.kill() was called.
-  rescue Errno::EPERM
-    return pid
-  end
-
-  def done(msg, error = nil)
-    puts msg
-    exit(exit_signal(error))
-  end
-
-  def exit_signal(error)
-    (error == :error) ? 1 : 0
-  end
-
-  def pid
-    @pid ||= File.read(pidfile).to_i
-  end
-
-  def quiet
-    `kill -TSTP #{pid}`
-  end
-
-  def stop
-    `kill -TERM #{pid}`
-    kill_timeout.times do
-      begin
-        Process.kill(0, pid)
-      rescue Errno::ESRCH
-        FileUtils.rm_f pidfile
-        done 'Sidekiq shut down gracefully.'
-      rescue Errno::EPERM
-        done 'Not permitted to shut down Sidekiq.'
-      end
-      sleep 1
-    end
-    `kill -9 #{pid}`
-    FileUtils.rm_f pidfile
-    done 'Sidekiq shut down forcefully.'
-  end
-  alias_method :shutdown, :stop
-
-  class Status
-    VALID_SECTIONS = %w[all version overview processes queues]
-    def display(section = nil)
-      section ||= 'all'
-      unless VALID_SECTIONS.include? section
-        puts "I don't know how to check the status of '#{section}'!"
-        puts "Try one of these: #{VALID_SECTIONS.join(', ')}"
-        return
-      end
-      send(section)
-    rescue StandardError => e
-      puts "Couldn't get status: #{e}"
-    end
-
-    def all
-      version
-      puts
-      overview
-      puts
-      processes
-      puts
-      queues
-    end
-
-    def version
-      puts "Sidekiq #{Sidekiq::VERSION}"
-      puts Time.now
-    end
-
-    def overview
-      puts '---- Overview ----'
-      puts "  Processed: #{delimit stats.processed}"
-      puts "     Failed: #{delimit stats.failed}"
-      puts "       Busy: #{delimit stats.workers_size}"
-      puts "   Enqueued: #{delimit stats.enqueued}"
-      puts "    Retries: #{delimit stats.retry_size}"
-      puts "  Scheduled: #{delimit stats.scheduled_size}"
-      puts "       Dead: #{delimit stats.dead_size}"
-    end
-
-    def processes
-      puts "---- Processes (#{process_set.size}) ----"
-      process_set.each_with_index do |process, index|
-        puts "#{process['identity']} #{tags_for(process)}"
-        puts "  Started: #{Time.at(process['started_at'])} (#{time_ago(process['started_at'])})"
-        puts "  Threads: #{process['concurrency']} (#{process['busy']} busy)"
-        puts "   Queues: #{split_multiline(process['queues'].sort, pad: 11)}"
-        puts '' unless (index+1) == process_set.size
-      end
-    end
-
-    COL_PAD = 2
-    def queues
-      puts "---- Queues (#{queue_data.size}) ----"
-      columns = {
-        name: [:ljust, (['name'] + queue_data.map(&:name)).map(&:length).max + COL_PAD],
-        size: [:rjust, (['size'] + queue_data.map(&:size)).map(&:length).max + COL_PAD],
-        latency: [:rjust, (['latency'] + queue_data.map(&:latency)).map(&:length).max + COL_PAD]
-      }
-      columns.each { |col, (dir, width)| print col.to_s.upcase.public_send(dir, width) }
-      puts
-      queue_data.each do |q|
-        columns.each do |col, (dir, width)|
-          print q.send(col).public_send(dir, width)
-        end
-        puts
-      end
-    end
-
-    private
-
-    def delimit(number)
-      number.to_s.reverse.scan(/.{1,3}/).join(',').reverse
-    end
-
-    def split_multiline(values, opts = {})
-      return 'none' unless values
-      pad = opts[:pad] || 0
-      max_length = opts[:max_length] || (80 - pad)
-      out = []
-      line = ''
-      values.each do |value|
-        if (line.length + value.length) > max_length
-          out << line
-          line = ' ' * pad
-        end
-        line << value + ', '
-      end
-      out << line[0..-3]
-      out.join("\n")
-    end
-
-    def tags_for(process)
-      tags = [
-        process['tag'],
-        process['labels'],
-        (process['quiet'] == 'true' ? 'quiet' : nil)
-      ].flatten.compact
-      tags.any? ? "[#{tags.join('] [')}]" : nil
-    end
-
-    def time_ago(timestamp)
-      seconds = Time.now - Time.at(timestamp)
-      return 'just now' if seconds < 60
-      return 'a minute ago' if seconds < 120
-      return "#{seconds.floor / 60} minutes ago" if seconds < 3600
-      return 'an hour ago' if seconds < 7200
-      "#{seconds.floor / 60 / 60} hours ago"
-    end
-
-    QUEUE_STRUCT = Struct.new(:name, :size, :latency)
-    def queue_data
-      @queue_data ||= Sidekiq::Queue.all.map do |q|
-        QUEUE_STRUCT.new(q.name, q.size.to_s, sprintf('%#.2f', q.latency))
-      end
-    end
-
-    def process_set
-      @process_set ||= Sidekiq::ProcessSet.new
-    end
-
-    def stats
-      @stats ||= Sidekiq::Stats.new
-    end
-  end
-end

data/lib/sidekiq/delay.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-module Sidekiq
-  module Extensions
-
-    def self.enable_delay!
-      if defined?(::ActiveSupport)
-        require 'sidekiq/extensions/active_record'
-        require 'sidekiq/extensions/action_mailer'
-
-        # Need to patch Psych so it can autoload classes whose names are serialized
-        # in the delayed YAML.
-        Psych::Visitors::ToRuby.prepend(Sidekiq::Extensions::PsychAutoload)
-
-        ActiveSupport.on_load(:active_record) do
-          include Sidekiq::Extensions::ActiveRecord
-        end
-        ActiveSupport.on_load(:action_mailer) do
-          extend Sidekiq::Extensions::ActionMailer
-        end
-      end
-
-      require 'sidekiq/extensions/class_methods'
-      Module.__send__(:include, Sidekiq::Extensions::Klass)
-    end
-
-    module PsychAutoload
-      def resolve_class(klass_name)
-        return nil if !klass_name || klass_name.empty?
-        # constantize
-        names = klass_name.split('::')
-        names.shift if names.empty? || names.first.empty?
-
-        names.inject(Object) do |constant, name|
-          constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
-        end
-      rescue NameError
-        super
-      end
-    end
-  end
-end
-

data/lib/sidekiq/exception_handler.rb

@@ -1,29 +0,0 @@
-# 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
-
-      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

@@ -1,57 +0,0 @@
-# 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

@@ -1,40 +0,0 @@
-# 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

@@ -1,40 +0,0 @@
-# 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

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-require 'yaml'
-
-module Sidekiq
-  module Extensions
-    SIZE_LIMIT = 8_192
-
-    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]
-        marshalled = ::YAML.dump(obj)
-        if marshalled.size > SIZE_LIMIT
-          ::Sidekiq.logger.warn { "#{@target}.#{name} job argument is #{marshalled.bytesize} bytes, you should refactor it to reduce the size" }
-        end
-        @performable.client_push({ 'class' => @performable, 'args' => [marshalled] }.merge(@opts))
-      end
-    end
-
-  end
-end