sidekiq 4.2.2 → 6.3.1

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/sidekiq/core_ext.rb

@@ -1,106 +0,0 @@
-# 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/logging.rb

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-require 'time'
-require 'logger'
-require 'fcntl'
-
-module Sidekiq
-  module Logging
-
-    class Pretty < Logger::Formatter
-      SPACE = " "
-
-      # Provide a call() method that returns the formatted message.
-      def call(severity, time, program_name, message)
-        "#{time.utc.iso8601(3)} #{::Process.pid} TID-#{Thread.current.object_id.to_s(36)}#{context} #{severity}: #{message}\n"
-      end
-
-      def context
-        c = Thread.current[:sidekiq_context]
-        " #{c.join(SPACE)}" if c && c.any?
-      end
-    end
-
-    class WithoutTimestamp < Pretty
-      def call(severity, time, program_name, message)
-        "#{::Process.pid} TID-#{Thread.current.object_id.to_s(36)}#{context} #{severity}: #{message}\n"
-      end
-    end
-
-    def self.with_context(msg)
-      Thread.current[:sidekiq_context] ||= []
-      Thread.current[:sidekiq_context] << msg
-      yield
-    ensure
-      Thread.current[:sidekiq_context].pop
-    end
-
-    def self.initialize_logger(log_target = STDOUT)
-      oldlogger = defined?(@logger) ? @logger : nil
-      @logger = Logger.new(log_target)
-      @logger.level = Logger::INFO
-      @logger.formatter = ENV['DYNO'] ? WithoutTimestamp.new : Pretty.new
-      oldlogger.close if oldlogger && !$TESTING # don't want to close testing's STDOUT logging
-      @logger
-    end
-
-    def self.logger
-      defined?(@logger) ? @logger : initialize_logger
-    end
-
-    def self.logger=(log)
-      @logger = (log ? log : Logger.new(File::NULL))
-    end
-
-    # This reopens ALL logfiles in the process that have been rotated
-    # using logrotate(8) (without copytruncate) or similar tools.
-    # A +File+ object is considered for reopening if it is:
-    #   1) opened with the O_APPEND and O_WRONLY flags
-    #   2) the current open file handle does not match its original open path
-    #   3) unbuffered (as far as userspace buffering goes, not O_SYNC)
-    # Returns the number of files reopened
-    def self.reopen_logs
-      to_reopen = []
-      append_flags = File::WRONLY | File::APPEND
-
-      ObjectSpace.each_object(File) do |fp|
-        begin
-          if !fp.closed? && fp.stat.file? && fp.sync && (fp.fcntl(Fcntl::F_GETFL) & append_flags) == append_flags
-            to_reopen << fp
-          end
-        rescue IOError, Errno::EBADF
-        end
-      end
-
-      nr = 0
-      to_reopen.each do |fp|
-        orig_st = begin
-          fp.stat
-        rescue IOError, Errno::EBADF
-          next
-        end
-
-        begin
-          b = File.stat(fp.path)
-          next if orig_st.ino == b.ino && orig_st.dev == b.dev
-        rescue Errno::ENOENT
-        end
-
-        begin
-          File.open(fp.path, 'a') { |tmpfp| fp.reopen(tmpfp) }
-          fp.sync = true
-          nr += 1
-        rescue IOError, Errno::EBADF
-          # not much we can do...
-        end
-      end
-      nr
-    rescue RuntimeError => ex
-      # RuntimeError: ObjectSpace is disabled; each_object will only work with Class, pass -X+O to enable
-      puts "Unable to reopen logs: #{ex.message}"
-    end
-
-    def logger
-      Sidekiq::Logging.logger
-    end
-  end
-end

data/lib/sidekiq/middleware/server/active_record.rb

@@ -1,13 +0,0 @@
-module Sidekiq
-  module Middleware
-    module Server
-      class ActiveRecord
-        def call(*args)
-          yield
-        ensure
-          ::ActiveRecord::Base.clear_active_connections!
-        end
-      end
-    end
-  end
-end

data/lib/sidekiq/middleware/server/logging.rb

@@ -1,40 +0,0 @@
-module Sidekiq
-  module Middleware
-    module Server
-      class Logging
-
-        def call(worker, item, queue)
-          Sidekiq::Logging.with_context(log_context(worker, item)) do
-            begin
-              start = Time.now
-              logger.info("start".freeze)
-              yield
-              logger.info("done: #{elapsed(start)} sec")
-            rescue Exception
-              logger.info("fail: #{elapsed(start)} sec")
-              raise
-            end
-          end
-        end
-
-        private
-
-        # If we're using a wrapper class, like ActiveJob, use the "wrapped"
-        # attribute to expose the underlying thing.
-        def log_context(worker, item)
-          klass = item['wrapped'.freeze] || worker.class.to_s
-          "#{klass} JID-#{item['jid'.freeze]}#{" BID-#{item['bid'.freeze]}" if item['bid'.freeze]}"
-        end
-
-        def elapsed(start)
-          (Time.now - start).round(3)
-        end
-
-        def logger
-          Sidekiq.logger
-        end
-      end
-    end
-  end
-end
-

data/lib/sidekiq/middleware/server/retry_jobs.rb

@@ -1,205 +0,0 @@
-require 'sidekiq/scheduled'
-require 'sidekiq/api'
-
-module Sidekiq
-  module Middleware
-    module Server
-      ##
-      # Automatically retry jobs that fail in Sidekiq.
-      # Sidekiq's retry support assumes a typical development lifecycle:
-      #
-      #   0. Push some code changes with a bug in it.
-      #   1. Bug causes job processing to fail, Sidekiq's middleware captures
-      #      the job and pushes it onto a retry queue.
-      #   2. Sidekiq retries jobs in the retry queue multiple times with
-      #      an exponential delay, the job continues to fail.
-      #   3. After a few days, a developer deploys a fix. The job is
-      #      reprocessed successfully.
-      #   4. Once retries are exhausted, Sidekiq will give up and move the
-      #      job to the Dead Job Queue (aka morgue) where it must be dealt with
-      #      manually in the Web UI.
-      #   5. After 6 months on the DJQ, Sidekiq will discard the job.
-      #
-      # A job looks like:
-      #
-      #     { 'class' => 'HardWorker', 'args' => [1, 2, 'foo'], 'retry' => true }
-      #
-      # The 'retry' option also accepts a number (in place of 'true'):
-      #
-      #     { 'class' => 'HardWorker', 'args' => [1, 2, 'foo'], 'retry' => 5 }
-      #
-      # The job will be retried this number of times before giving up. (If simply
-      # 'true', Sidekiq retries 25 times)
-      #
-      # We'll add a bit more data to the job to support retries:
-      #
-      #  * 'queue' - the queue to use
-      #  * 'retry_count' - number of times we've retried so far.
-      #  * 'error_message' - the message from the exception
-      #  * 'error_class' - the exception class
-      #  * 'failed_at' - the first time it failed
-      #  * 'retried_at' - the last time it was retried
-      #  * 'backtrace' - the number of lines of error backtrace to store
-      #
-      # We don't store the backtrace by default as that can add a lot of overhead
-      # to the job and everyone is using an error service, right?
-      #
-      # The default number of retry attempts is 25 which works out to about 3 weeks
-      # of retries. You can pass a value for the max number of retry attempts when
-      # adding the middleware using the options hash:
-      #
-      #   Sidekiq.configure_server do |config|
-      #     config.server_middleware do |chain|
-      #       chain.add Sidekiq::Middleware::Server::RetryJobs, :max_retries => 7
-      #     end
-      #   end
-      #
-      # or limit the number of retries for a particular worker with:
-      #
-      #    class MyWorker
-      #      include Sidekiq::Worker
-      #      sidekiq_options :retry => 10
-      #    end
-      #
-      class RetryJobs
-        include Sidekiq::Util
-
-        DEFAULT_MAX_RETRY_ATTEMPTS = 25
-
-        def initialize(options = {})
-          @max_retries = options.fetch(:max_retries, DEFAULT_MAX_RETRY_ATTEMPTS)
-        end
-
-        def call(worker, msg, queue)
-          yield
-        rescue Sidekiq::Shutdown
-          # ignore, will be pushed back onto queue during hard_shutdown
-          raise
-        rescue Exception => e
-          # ignore, will be pushed back onto queue during hard_shutdown
-          raise Sidekiq::Shutdown if exception_caused_by_shutdown?(e)
-
-          raise e unless msg['retry']
-          attempt_retry(worker, msg, queue, e)
-        end
-
-        private
-
-        def attempt_retry(worker, msg, queue, exception)
-          max_retry_attempts = retry_attempts_from(msg['retry'], @max_retries)
-
-          msg['queue'] = if msg['retry_queue']
-            msg['retry_queue']
-          else
-            queue
-          end
-
-          # App code can stuff all sorts of crazy binary data into the error message
-          # that won't convert to JSON.
-          m = exception.message.to_s[0, 10_000]
-          if m.respond_to?(:scrub!)
-            m.force_encoding("utf-8")
-            m.scrub!
-          end
-
-          msg['error_message'] = m
-          msg['error_class'] = exception.class.name
-          count = if msg['retry_count']
-            msg['retried_at'] = Time.now.to_f
-            msg['retry_count'] += 1
-          else
-            msg['failed_at'] = Time.now.to_f
-            msg['retry_count'] = 0
-          end
-
-          if msg['backtrace'] == true
-            msg['error_backtrace'] = exception.backtrace
-          elsif !msg['backtrace']
-            # do nothing
-          elsif msg['backtrace'].to_i != 0
-            msg['error_backtrace'] = exception.backtrace[0...msg['backtrace'].to_i]
-          end
-
-          if count < max_retry_attempts
-            delay = delay_for(worker, count, exception)
-            logger.debug { "Failure! Retry #{count} in #{delay} seconds" }
-            retry_at = Time.now.to_f + delay
-            payload = Sidekiq.dump_json(msg)
-            Sidekiq.redis do |conn|
-              conn.zadd('retry', retry_at.to_s, payload)
-            end
-          else
-            # Goodbye dear message, you (re)tried your best I'm sure.
-            retries_exhausted(worker, msg, exception)
-          end
-
-          raise exception
-        end
-
-        def retries_exhausted(worker, msg, exception)
-          logger.debug { "Retries exhausted for job" }
-          begin
-            block = worker.sidekiq_retries_exhausted_block || Sidekiq.default_retries_exhausted
-            block.call(msg, exception) if block
-          rescue => e
-            handle_exception(e, { context: "Error calling retries_exhausted for #{worker.class}", job: msg })
-          end
-
-          send_to_morgue(msg) unless msg['dead'] == false
-        end
-
-        def send_to_morgue(msg)
-          Sidekiq.logger.info { "Adding dead #{msg['class']} job #{msg['jid']}" }
-          payload = Sidekiq.dump_json(msg)
-          now = Time.now.to_f
-          Sidekiq.redis do |conn|
-            conn.multi do
-              conn.zadd('dead', now, payload)
-              conn.zremrangebyscore('dead', '-inf', now - DeadSet.timeout)
-              conn.zremrangebyrank('dead', 0, -DeadSet.max_jobs)
-            end
-          end
-        end
-
-        def retry_attempts_from(msg_retry, default)
-          if msg_retry.is_a?(Fixnum)
-            msg_retry
-          else
-            default
-          end
-        end
-
-        def delay_for(worker, count, exception)
-          worker.sidekiq_retry_in_block? && retry_in(worker, count, exception) || seconds_to_delay(count)
-        end
-
-        # delayed_job uses the same basic formula
-        def seconds_to_delay(count)
-          (count ** 4) + 15 + (rand(30)*(count+1))
-        end
-
-        def retry_in(worker, count, exception)
-          begin
-            worker.sidekiq_retry_in_block.call(count, exception).to_i
-          rescue Exception => e
-            handle_exception(e, { context: "Failure scheduling retry using the defined `sidekiq_retry_in` in #{worker.class.name}, falling back to default" })
-            nil
-          end
-        end
-
-        def exception_caused_by_shutdown?(e, checked_causes = [])
-          # In Ruby 2.1.0 only, check if exception is a result of shutdown.
-          return false unless defined?(e.cause)
-
-          # Handle circular causes
-          checked_causes << e.object_id
-          return false if checked_causes.include?(e.cause.object_id)
-
-          e.cause.instance_of?(Sidekiq::Shutdown) ||
-            exception_caused_by_shutdown?(e.cause, checked_causes)
-        end
-
-      end
-    end
-  end
-end

data/test/config.yml

@@ -1,9 +0,0 @@
----
-:verbose:      false
-:require:      ./test/fake_env.rb
-:pidfile:      /tmp/sidekiq-config-test.pid
-:logfile:      /tmp/sidekiq.log
-:concurrency:  50
-:queues:
-  - [<%="very_"%>often, 2]
-  - [seldom, 1]

data/test/env_based_config.yml

@@ -1,11 +0,0 @@
----
-:pidfile:      /tmp/sidekiq-config-test.pid
-:concurrency:  50
-staging:
-  :verbose:      false
-  :require:      ./test/fake_env.rb
-  :logfile:      /tmp/sidekiq.log
-  :concurrency:  5
-  :queues:
-    - [<%="very_"%>often, 2]
-    - [seldom, 1]

data/test/fake_env.rb

@@ -1 +0,0 @@
-# frozen_string_literal: true

data/test/fixtures/en.yml

@@ -1,2 +0,0 @@
-en:
-  translated_text: 'Changed text from add locals'

data/test/helper.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-$TESTING = true
-# disable minitest/parallel threads
-ENV["N"] = "0"
-
-if ENV["COVERAGE"]
-  require 'simplecov'
-  SimpleCov.start do
-    add_filter "/test/"
-    add_filter "/myapp/"
-  end
-end
-ENV['RACK_ENV'] = ENV['RAILS_ENV'] = 'test'
-
-trap 'USR1' do
-  threads = Thread.list
-
-  puts
-  puts "=" * 80
-  puts "Received USR1 signal; printing all #{threads.count} thread backtraces."
-
-  threads.each do |thr|
-    description = thr == Thread.main ? "Main thread" : thr.inspect
-    puts
-    puts "#{description} backtrace: "
-    puts thr.backtrace.join("\n")
-  end
-
-  puts "=" * 80
-end
-
-begin
-  require 'pry-byebug'
-rescue LoadError
-end
-
-require 'minitest/autorun'
-
-require 'sidekiq'
-require 'sidekiq/util'
-Sidekiq.logger.level = Logger::ERROR
-
-Sidekiq::Test = Minitest::Test
-
-require 'sidekiq/redis_connection'
-REDIS_URL = ENV['REDIS_URL'] || 'redis://localhost/15'
-REDIS = Sidekiq::RedisConnection.create(:url => REDIS_URL, :namespace => 'testy')
-
-Sidekiq.configure_client do |config|
-  config.redis = { :url => REDIS_URL, :namespace => 'testy' }
-end
-
-def capture_logging(lvl=Logger::INFO)
-  old = Sidekiq.logger
-  begin
-    out = StringIO.new
-    logger = Logger.new(out)
-    logger.level = lvl
-    Sidekiq.logger = logger
-    yield
-    out.string
-  ensure
-    Sidekiq.logger = old
-  end
-end
-
-def with_logging(lvl=Logger::DEBUG)
-  old = Sidekiq.logger.level
-  begin
-    Sidekiq.logger.level = lvl
-    yield
-  ensure
-    Sidekiq.logger.level = old
-  end
-end