sidekiq 5.2.4 → 7.2.4

data/lib/sidekiq/logging.rb

@@ -1,122 +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-#{Sidekiq::Logging.tid}#{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-#{Sidekiq::Logging.tid}#{context} #{severity}: #{message}\n"
-      end
-    end
-
-    def self.tid
-      Thread.current['sidekiq_tid'] ||= (Thread.current.object_id ^ ::Process.pid).to_s(36)
-    end
-
-    def self.job_hash_context(job_hash)
-      # If we're using a wrapper class, like ActiveJob, use the "wrapped"
-      # attribute to expose the underlying thing.
-      klass = job_hash['wrapped'] || job_hash["class"]
-      bid = job_hash['bid']
-      "#{klass} JID-#{job_hash['jid']}#{" BID-#{bid}" if bid}"
-    end
-
-    def self.with_job_hash_context(job_hash, &block)
-      with_context(job_hash_context(job_hash), &block)
-    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,23 +0,0 @@
-# frozen_string_literal: true
-module Sidekiq
-  module Middleware
-    module Server
-      class ActiveRecord
-
-        def initialize
-          # With Rails 5+ we must use the Reloader **always**.
-          # The reloader handles code loading and db connection management.
-          if defined?(::Rails) && ::Rails::VERSION::MAJOR >= 5
-            raise ArgumentError, "Rails 5 no longer needs or uses the ActiveRecord middleware."
-          end
-        end
-
-        def call(*args)
-          yield
-        ensure
-          ::ActiveRecord::Base.clear_active_connections!
-        end
-      end
-    end
-  end
-end

data/lib/sidekiq/util.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-require 'socket'
-require 'securerandom'
-require 'sidekiq/exception_handler'
-
-module Sidekiq
-  ##
-  # This module is part of Sidekiq core and not intended for extensions.
-  #
-  module Util
-    include ExceptionHandler
-
-    EXPIRY = 60 * 60 * 24
-
-    def watchdog(last_words)
-      yield
-    rescue Exception => ex
-      handle_exception(ex, { context: last_words })
-      raise ex
-    end
-
-    def safe_thread(name, &block)
-      Thread.new do
-        Thread.current['sidekiq_label'] = name
-        watchdog(name, &block)
-      end
-    end
-
-    def logger
-      Sidekiq.logger
-    end
-
-    def redis(&block)
-      Sidekiq.redis(&block)
-    end
-
-    def hostname
-      ENV['DYNO'] || Socket.gethostname
-    end
-
-    def process_nonce
-      @@process_nonce ||= SecureRandom.hex(6)
-    end
-
-    def identity
-      @@identity ||= "#{hostname}:#{$$}:#{process_nonce}"
-    end
-
-    def fire_event(event, options={})
-      reverse = options[:reverse]
-      reraise = options[:reraise]
-
-      arr = Sidekiq.options[:lifecycle_events][event]
-      arr.reverse! if reverse
-      arr.each do |block|
-        begin
-          block.call
-        rescue => ex
-          handle_exception(ex, { context: "Exception during Sidekiq lifecycle event.", event: event })
-          raise ex if reraise
-        end
-      end
-      arr.clear
-    end
-  end
-end

data/lib/sidekiq/worker.rb

@@ -1,215 +0,0 @@
-# frozen_string_literal: true
-require 'sidekiq/client'
-
-module Sidekiq
-
-  ##
-  # Include this module in your worker class and you can easily create
-  # asynchronous jobs:
-  #
-  #   class HardWorker
-  #     include Sidekiq::Worker
-  #
-  #     def perform(*args)
-  #       # do some work
-  #     end
-  #   end
-  #
-  # Then in your Rails app, you can do this:
-  #
-  #   HardWorker.perform_async(1, 2, 3)
-  #
-  # Note that perform_async is a class method, perform is an instance method.
-  module Worker
-    attr_accessor :jid
-
-    def self.included(base)
-      raise ArgumentError, "You cannot include Sidekiq::Worker in an ActiveJob: #{base.name}" if base.ancestors.any? {|c| c.name == 'ActiveJob::Base' }
-
-      base.extend(ClassMethods)
-      base.sidekiq_class_attribute :sidekiq_options_hash
-      base.sidekiq_class_attribute :sidekiq_retry_in_block
-      base.sidekiq_class_attribute :sidekiq_retries_exhausted_block
-    end
-
-    def logger
-      Sidekiq.logger
-    end
-
-    # This helper class encapsulates the set options for `set`, e.g.
-    #
-    #     SomeWorker.set(queue: 'foo').perform_async(....)
-    #
-    class Setter
-      def initialize(klass, opts)
-        @klass = klass
-        @opts = opts
-      end
-
-      def perform_async(*args)
-        @klass.client_push(@opts.merge('args' => args, 'class' => @klass))
-      end
-
-      # +interval+ must be a timestamp, numeric or something that acts
-      #   numeric (like an activesupport time interval).
-      def perform_in(interval, *args)
-        int = interval.to_f
-        now = Time.now.to_f
-        ts = (int < 1_000_000_000 ? now + int : int)
-
-        payload = @opts.merge('class' => @klass, 'args' => args, 'at' => ts)
-        # Optimization to enqueue something now that is scheduled to go out now or in the past
-        payload.delete('at') if ts <= now
-        @klass.client_push(payload)
-      end
-      alias_method :perform_at, :perform_in
-    end
-
-    module ClassMethods
-      ACCESSOR_MUTEX = Mutex.new
-
-      def delay(*args)
-        raise ArgumentError, "Do not call .delay on a Sidekiq::Worker class, call .perform_async"
-      end
-
-      def delay_for(*args)
-        raise ArgumentError, "Do not call .delay_for on a Sidekiq::Worker class, call .perform_in"
-      end
-
-      def delay_until(*args)
-        raise ArgumentError, "Do not call .delay_until on a Sidekiq::Worker class, call .perform_at"
-      end
-
-      def set(options)
-        Setter.new(self, options)
-      end
-
-      def perform_async(*args)
-        client_push('class' => self, 'args' => args)
-      end
-
-      # +interval+ must be a timestamp, numeric or something that acts
-      #   numeric (like an activesupport time interval).
-      def perform_in(interval, *args)
-        int = interval.to_f
-        now = Time.now.to_f
-        ts = (int < 1_000_000_000 ? now + int : int)
-
-        item = { 'class' => self, 'args' => args, 'at' => ts }
-
-        # Optimization to enqueue something now that is scheduled to go out now or in the past
-        item.delete('at') if ts <= now
-
-        client_push(item)
-      end
-      alias_method :perform_at, :perform_in
-
-      ##
-      # Allows customization for this type of Worker.
-      # Legal options:
-      #
-      #   queue - use a named queue for this Worker, default 'default'
-      #   retry - enable the RetryJobs middleware for this Worker, *true* to use the default
-      #      or *Integer* count
-      #   backtrace - whether to save any error backtrace in the retry payload to display in web UI,
-      #      can be true, false or an integer number of lines to save, default *false*
-      #   pool - use the given Redis connection pool to push this type of job to a given shard.
-      #
-      # In practice, any option is allowed.  This is the main mechanism to configure the
-      # options for a specific job.
-      def sidekiq_options(opts={})
-        # stringify
-        self.sidekiq_options_hash = get_sidekiq_options.merge(Hash[opts.map{|k, v| [k.to_s, v]}])
-      end
-
-      def sidekiq_retry_in(&block)
-        self.sidekiq_retry_in_block = block
-      end
-
-      def sidekiq_retries_exhausted(&block)
-        self.sidekiq_retries_exhausted_block = block
-      end
-
-      def get_sidekiq_options # :nodoc:
-        self.sidekiq_options_hash ||= Sidekiq.default_worker_options
-      end
-
-      def client_push(item) # :nodoc:
-        pool = Thread.current[:sidekiq_via_pool] || get_sidekiq_options['pool'] || Sidekiq.redis_pool
-        # stringify
-        item.keys.each do |key|
-          item[key.to_s] = item.delete(key)
-        end
-
-        Sidekiq::Client.new(pool).push(item)
-      end
-
-      def sidekiq_class_attribute(*attrs)
-        instance_reader = true
-        instance_writer = true
-
-        attrs.each do |name|
-          synchronized_getter = "__synchronized_#{name}"
-
-          singleton_class.instance_eval do
-            undef_method(name) if method_defined?(name) || private_method_defined?(name)
-          end
-
-          define_singleton_method(synchronized_getter) { nil }
-          singleton_class.class_eval do
-            private(synchronized_getter)
-          end
-
-          define_singleton_method(name) { ACCESSOR_MUTEX.synchronize { send synchronized_getter } }
-
-          ivar = "@#{name}"
-
-          singleton_class.instance_eval do
-            m = "#{name}="
-            undef_method(m) if method_defined?(m) || private_method_defined?(m)
-          end
-          define_singleton_method("#{name}=") do |val|
-            singleton_class.class_eval do
-              ACCESSOR_MUTEX.synchronize do
-                undef_method(synchronized_getter) if method_defined?(synchronized_getter) || private_method_defined?(synchronized_getter)
-                define_method(synchronized_getter) { val }
-              end
-            end
-
-            if singleton_class?
-              class_eval do
-                undef_method(name) if method_defined?(name) || private_method_defined?(name)
-                define_method(name) do
-                  if instance_variable_defined? ivar
-                    instance_variable_get ivar
-                  else
-                    singleton_class.send name
-                  end
-                end
-              end
-            end
-            val
-          end
-
-          if instance_reader
-            undef_method(name) if method_defined?(name) || private_method_defined?(name)
-            define_method(name) do
-              if instance_variable_defined?(ivar)
-                instance_variable_get ivar
-              else
-                self.class.public_send name
-              end
-            end
-          end
-
-          if instance_writer
-            m = "#{name}="
-            undef_method(m) if method_defined?(m) || private_method_defined?(m)
-            attr_writer name
-          end
-        end
-      end
-
-    end
-  end
-end