sr-sidekiq 4.1.6

data/lib/sidekiq/logging.rb

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

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+# encoding: utf-8
+require 'sidekiq/util'
+require 'sidekiq/processor'
+require 'sidekiq/fetch'
+require 'thread'
+
+module Sidekiq
+
+  ##
+  # The Manager is the central coordination point in Sidekiq, controlling
+  # the lifecycle of the Processors and feeding them jobs as necessary.
+  #
+  # Tasks:
+  #
+  # 1. start: Spin up Processors.
+  # 3. processor_died: Handle job failure, throw away Processor, create new one.
+  # 4. quiet: shutdown idle Processors.
+  # 5. stop: hard stop the Processors by deadline.
+  #
+  # Note that only the last task requires its own Thread since it has to monitor
+  # the shutdown process.  The other tasks are performed by other threads.
+  #
+  class Manager
+    include Util
+
+    attr_reader :workers
+    attr_reader :options
+
+    def initialize(options={})
+      logger.debug { options.inspect }
+      @options = options
+      @count = options[:concurrency] || 25
+      raise ArgumentError, "Concurrency of #{@count} is not supported" if @count < 1
+
+      @done = false
+      @workers = Set.new
+      @count.times do
+        @workers << Processor.new(self)
+      end
+      @plock = Mutex.new
+    end
+
+    def start
+      @workers.each do |x|
+        x.start
+      end
+    end
+
+    def quiet
+      return if @done
+      @done = true
+
+      logger.info { "Terminating quiet workers" }
+      @workers.each { |x| x.terminate }
+      fire_event(:quiet, true)
+    end
+
+    # hack for quicker development / testing environment #2774
+    PAUSE_TIME = STDOUT.tty? ? 0.1 : 0.5
+
+    def stop(deadline)
+      quiet
+      fire_event(:shutdown, true)
+
+      # some of the shutdown events can be async,
+      # we don't have any way to know when they're done but
+      # give them a little time to take effect
+      sleep PAUSE_TIME
+      return if @workers.empty?
+
+      logger.info { "Pausing to allow workers to finish..." }
+      remaining = deadline - Time.now
+      while remaining > PAUSE_TIME
+        return if @workers.empty?
+        sleep PAUSE_TIME
+        remaining = deadline - Time.now
+      end
+      return if @workers.empty?
+
+      hard_shutdown
+    end
+
+    def processor_stopped(processor)
+      @plock.synchronize do
+        @workers.delete(processor)
+      end
+    end
+
+    def processor_died(processor, reason)
+      @plock.synchronize do
+        @workers.delete(processor)
+        unless @done
+          p = Processor.new(self)
+          @workers << p
+          p.start
+        end
+      end
+    end
+
+    def stopped?
+      @done
+    end
+
+    private
+
+    def hard_shutdown
+      # We've reached the timeout and we still have busy workers.
+      # They must die but their jobs shall live on.
+      cleanup = nil
+      @plock.synchronize do
+        cleanup = @workers.dup
+      end
+
+      if cleanup.size > 0
+        jobs = cleanup.map {|p| p.job }.compact
+
+        logger.warn { "Terminating #{cleanup.size} busy worker threads" }
+        logger.warn { "Work still in progress #{jobs.inspect}" }
+
+        # Re-enqueue unfinished jobs
+        # NOTE: You may notice that we may push a job back to redis before
+        # the worker thread is terminated. This is ok because Sidekiq's
+        # contract says that jobs are run AT LEAST once. Process termination
+        # is delayed until we're certain the jobs are back in Redis because
+        # it is worse to lose a job than to run it twice.
+        strategy = (@options[:fetch] || Sidekiq::BasicFetch)
+        strategy.bulk_requeue(jobs, @options)
+      end
+
+      cleanup.each do |processor|
+        processor.kill
+      end
+    end
+
+  end
+end

data/lib/sidekiq/middleware/chain.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+module Sidekiq
+  # Middleware is code configured to run before/after
+  # a message is processed.  It is patterned after Rack
+  # middleware. Middleware exists for the client side
+  # (pushing jobs onto the queue) as well as the server
+  # side (when jobs are actually processed).
+  #
+  # To add middleware for the client:
+  #
+  # Sidekiq.configure_client do |config|
+  #   config.client_middleware do |chain|
+  #     chain.add MyClientHook
+  #   end
+  # end
+  #
+  # To modify middleware for the server, just call
+  # with another block:
+  #
+  # Sidekiq.configure_server do |config|
+  #   config.server_middleware do |chain|
+  #     chain.add MyServerHook
+  #     chain.remove ActiveRecord
+  #   end
+  # end
+  #
+  # To insert immediately preceding another entry:
+  #
+  # Sidekiq.configure_client do |config|
+  #   config.client_middleware do |chain|
+  #     chain.insert_before ActiveRecord, MyClientHook
+  #   end
+  # end
+  #
+  # To insert immediately after another entry:
+  #
+  # Sidekiq.configure_client do |config|
+  #   config.client_middleware do |chain|
+  #     chain.insert_after ActiveRecord, MyClientHook
+  #   end
+  # end
+  #
+  # This is an example of a minimal server middleware:
+  #
+  # class MyServerHook
+  #   def call(worker_instance, msg, queue)
+  #     puts "Before work"
+  #     yield
+  #     puts "After work"
+  #   end
+  # end
+  #
+  # This is an example of a minimal client middleware, note
+  # the method must return the result or the job will not push
+  # to Redis:
+  #
+  # class MyClientHook
+  #   def call(worker_class, msg, queue, redis_pool)
+  #     puts "Before push"
+  #     result = yield
+  #     puts "After push"
+  #     result
+  #   end
+  # end
+  #
+  module Middleware
+    class Chain
+      include Enumerable
+      attr_reader :entries
+
+      def initialize_copy(copy)
+        copy.instance_variable_set(:@entries, entries.dup)
+      end
+
+      def each(&block)
+        entries.each(&block)
+      end
+
+      def initialize
+        @entries = []
+        yield self if block_given?
+      end
+
+      def remove(klass)
+        entries.delete_if { |entry| entry.klass == klass }
+      end
+
+      def add(klass, *args)
+        remove(klass) if exists?(klass)
+        entries << Entry.new(klass, *args)
+      end
+
+      def prepend(klass, *args)
+        remove(klass) if exists?(klass)
+        entries.insert(0, Entry.new(klass, *args))
+      end
+
+      def insert_before(oldklass, newklass, *args)
+        i = entries.index { |entry| entry.klass == newklass }
+        new_entry = i.nil? ? Entry.new(newklass, *args) : entries.delete_at(i)
+        i = entries.index { |entry| entry.klass == oldklass } || 0
+        entries.insert(i, new_entry)
+      end
+
+      def insert_after(oldklass, newklass, *args)
+        i = entries.index { |entry| entry.klass == newklass }
+        new_entry = i.nil? ? Entry.new(newklass, *args) : entries.delete_at(i)
+        i = entries.index { |entry| entry.klass == oldklass } || entries.count - 1
+        entries.insert(i+1, new_entry)
+      end
+
+      def exists?(klass)
+        any? { |entry| entry.klass == klass }
+      end
+
+      def retrieve
+        map(&:make_new)
+      end
+
+      def clear
+        entries.clear
+      end
+
+      def invoke(*args)
+        chain = retrieve.dup
+        traverse_chain = lambda do
+          if chain.empty?
+            yield
+          else
+            chain.shift.call(*args, &traverse_chain)
+          end
+        end
+        traverse_chain.call
+      end
+    end
+
+    class Entry
+      attr_reader :klass
+
+      def initialize(klass, *args)
+        @klass = klass
+        @args  = args
+      end
+
+      def make_new
+        @klass.new(*@args)
+      end
+    end
+  end
+end

data/lib/sidekiq/middleware/i18n.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+#
+# Simple middleware to save the current locale and restore it when the job executes.
+# Use it by requiring it in your initializer:
+#
+#     require 'sidekiq/middleware/i18n'
+#
+module Sidekiq::Middleware::I18n
+  # Get the current locale and store it in the message
+  # to be sent to Sidekiq.
+  class Client
+    def call(worker_class, msg, queue, redis_pool)
+      msg['locale'] ||= I18n.locale
+      yield
+    end
+  end
+
+  # Pull the msg locale out and set the current thread to use it.
+  class Server
+    def call(worker, msg, queue)
+      I18n.locale = msg['locale'] || I18n.default_locale
+      yield
+    ensure
+      I18n.locale = I18n.default_locale
+    end
+  end
+end
+
+Sidekiq.configure_client do |config|
+  config.client_middleware do |chain|
+    chain.add Sidekiq::Middleware::I18n::Client
+  end
+end
+
+Sidekiq.configure_server do |config|
+  config.client_middleware do |chain|
+    chain.add Sidekiq::Middleware::I18n::Client
+  end
+  config.server_middleware do |chain|
+    chain.add Sidekiq::Middleware::I18n::Server
+  end
+end

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

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