sidekiq 3.5.4 → 7.2.0

data/lib/sidekiq/util.rb

@@ -1,68 +0,0 @@
-require 'socket'
-require 'securerandom'
-require 'sidekiq/exception_handler'
-require 'sidekiq/core_ext'
-
-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 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, reverse=false)
-      arr = Sidekiq.options[:lifecycle_events][event]
-      arr.reverse! if reverse
-      arr.each do |block|
-        begin
-          block.call
-        rescue => ex
-          handle_exception(ex, { event: event })
-        end
-      end
-    end
-
-    def want_a_hertz_donut?
-      # what's a hertz donut?
-      # punch!  Hurts, don't it?
-      info = Sidekiq.redis {|c| c.info }
-      if info['connected_clients'].to_i > 1000 && info['hz'].to_i >= 10
-        Sidekiq.logger.warn { "Your Redis `hz` setting is too high at #{info['hz']}.  See mperham/sidekiq#2431.  Set it to 3 in #{info[:config_file]}" }
-        true
-      else
-        Sidekiq.logger.debug { "Redis hz: #{info['hz']}.  Client count: #{info['connected_clients']}" }
-        false
-      end
-    end
-
-  end
-end

data/lib/sidekiq/web_helpers.rb

@@ -1,249 +0,0 @@
-require 'uri'
-
-module Sidekiq
-  # This is not a public API
-  module WebHelpers
-    def strings(lang)
-      @@strings ||= {}
-      @@strings[lang] ||= begin
-        # Allow sidekiq-web extensions to add locale paths
-        # so extensions can be localized
-        settings.locales.each_with_object({}) do |path, global|
-          find_locale_files(lang).each do |file|
-            strs = YAML.load(File.open(file))
-            global.deep_merge!(strs[lang])
-          end
-        end
-      end
-    end
-
-    def locale_files
-      @@locale_files = settings.locales.flat_map do |path|
-        Dir["#{path}/*.yml"]
-      end
-    end
-
-    def find_locale_files(lang)
-      locale_files.select { |file| file =~ /\/#{lang}\.yml$/ }
-    end
-
-    # This is a hook for a Sidekiq Pro feature.  Please don't touch.
-    def filtering(*)
-    end
-
-    # This view helper provide ability display you html code in
-    # to head of page. Example:
-    #
-    #   <% add_to_head do %>
-    #     <link rel="stylesheet" .../>
-    #     <meta .../>
-    #   <% end %>
-    #
-    def add_to_head(&block)
-      @head_html ||= []
-      @head_html << block if block_given?
-    end
-
-    def display_custom_head
-      return unless defined?(@head_html)
-      @head_html.map { |block| capture(&block) }.join
-    end
-
-    # Simple capture method for erb templates. The origin was
-    # capture method from sinatra-contrib library.
-    def capture(&block)
-      block.call
-      eval('', block.binding)
-    end
-
-    # Given a browser request Accept-Language header like
-    # "fr-FR,fr;q=0.8,en-US;q=0.6,en;q=0.4,ru;q=0.2", this function
-    # will return "fr" since that's the first code with a matching
-    # locale in web/locales
-    def locale
-      @locale ||= begin
-        locale = 'en'.freeze
-        languages = request.env['HTTP_ACCEPT_LANGUAGE'.freeze] || 'en'.freeze
-        languages.downcase.split(','.freeze).each do |lang|
-          next if lang == '*'.freeze
-          lang = lang.split(';'.freeze)[0]
-          break locale = lang if find_locale_files(lang).any?
-        end
-        locale
-      end
-    end
-
-    def get_locale
-      strings(locale)
-    end
-
-    def t(msg, options={})
-      string = get_locale[msg] || msg
-      if options.empty?
-        string
-      else
-        string % options
-      end
-    end
-
-    def workers
-      @workers ||= Sidekiq::Workers.new
-    end
-
-    def processes
-      @processes ||= Sidekiq::ProcessSet.new
-    end
-
-    def stats
-      @stats ||= Sidekiq::Stats.new
-    end
-
-    def retries_with_score(score)
-      Sidekiq.redis do |conn|
-        conn.zrangebyscore('retry', score, score)
-      end.map { |msg| Sidekiq.load_json(msg) }
-    end
-
-    def location
-      Sidekiq.redis { |conn| conn.client.location }
-    end
-
-    def redis_connection
-      Sidekiq.redis { |conn| conn.client.id }
-    end
-
-    def namespace
-      @@ns ||= Sidekiq.redis { |conn| conn.respond_to?(:namespace) ? conn.namespace : nil }
-    end
-
-    def redis_info
-      Sidekiq.redis do |conn|
-        # admin commands can't go through redis-namespace starting
-        # in redis-namespace 2.0
-        if conn.respond_to?(:namespace)
-          conn.redis.info
-        else
-          conn.info
-        end
-      end
-    end
-
-    def root_path
-      "#{env['SCRIPT_NAME']}/"
-    end
-
-    def current_path
-      @current_path ||= request.path_info.gsub(/^\//,'')
-    end
-
-    def current_status
-      workers.size == 0 ? 'idle' : 'active'
-    end
-
-    def relative_time(time)
-      %{<time datetime="#{time.getutc.iso8601}">#{time}</time>}
-    end
-
-    def job_params(job, score)
-      "#{score}-#{job['jid']}"
-    end
-
-    def parse_params(params)
-      score, jid = params.split("-")
-      [score.to_f, jid]
-    end
-
-    SAFE_QPARAMS = %w(page poll)
-
-    # Merge options with current params, filter safe params, and stringify to query string
-    def qparams(options)
-      options = options.stringify_keys
-      params.merge(options).map do |key, value|
-        SAFE_QPARAMS.include?(key) ? "#{key}=#{value}" : next
-      end.join("&")
-    end
-
-    def truncate(text, truncate_after_chars = 2000)
-      truncate_after_chars && text.size > truncate_after_chars ? "#{text[0..truncate_after_chars]}..." : text
-    end
-
-    def display_args(args, truncate_after_chars = 2000)
-      args.map do |arg|
-        h(truncate(to_display(arg)))
-      end.join(", ")
-    end
-
-    def csrf_tag
-      "<input type='hidden' name='authenticity_token' value='#{session[:csrf]}'/>"
-    end
-
-    def to_display(arg)
-      begin
-        arg.inspect
-      rescue
-        begin
-          arg.to_s
-        rescue => ex
-          "Cannot display argument: [#{ex.class.name}] #{ex.message}"
-        end
-      end
-    end
-
-    RETRY_JOB_KEYS = Set.new(%w(
-      queue class args retry_count retried_at failed_at
-      jid error_message error_class backtrace
-      error_backtrace enqueued_at retry wrapped
-    ))
-
-    def retry_extra_items(retry_job)
-      @retry_extra_items ||= {}.tap do |extra|
-        retry_job.item.each do |key, value|
-          extra[key] = value unless RETRY_JOB_KEYS.include?(key)
-        end
-      end
-    end
-
-    def number_with_delimiter(number)
-      begin
-        Float(number)
-      rescue ArgumentError, TypeError
-        return number
-      end
-
-      options = {delimiter: ',', separator: '.'}
-      parts = number.to_s.to_str.split('.')
-      parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{options[:delimiter]}")
-      parts.join(options[:separator])
-    end
-
-    def h(text)
-      ::Rack::Utils.escape_html(text)
-    rescue ArgumentError => e
-      raise unless e.message.eql?('invalid byte sequence in UTF-8')
-      text.encode!('UTF-16', 'UTF-8', invalid: :replace, replace: '').encode!('UTF-8', 'UTF-16')
-      retry
-    end
-
-    # Any paginated list that performs an action needs to redirect
-    # back to the proper page after performing that action.
-    def redirect_with_query(url)
-      r = request.referer
-      if r && r =~ /\?/
-        ref = URI(r)
-        redirect("#{url}?#{ref.query}")
-      else
-        redirect url
-      end
-    end
-
-    def environment_title_prefix
-      environment = Sidekiq.options[:environment] || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
-
-      "[#{environment.upcase}] " unless environment == "production"
-    end
-
-    def product_version
-      "Sidekiq v#{Sidekiq::VERSION}"
-    end
-  end
-end

data/lib/sidekiq/worker.rb

@@ -1,103 +0,0 @@
-require 'sidekiq/client'
-require 'sidekiq/core_ext'
-
-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.class_attribute :sidekiq_options_hash
-      base.class_attribute :sidekiq_retry_in_block
-      base.class_attribute :sidekiq_retries_exhausted_block
-    end
-
-    def logger
-      Sidekiq.logger
-    end
-
-    module ClassMethods
-
-      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 perform_async(*args)
-        client_push('class' => self, 'args' => args)
-      end
-
-      def perform_in(interval, *args)
-        int = interval.to_f
-        now = Time.now
-        ts = (int < 1_000_000_000 ? (now + interval).to_f : 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'.freeze) if ts <= now.to_f
-
-        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, default *true*
-      #   :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.
-      def sidekiq_options(opts={})
-        self.sidekiq_options_hash = get_sidekiq_options.merge(opts.stringify_keys)
-      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
-        Sidekiq::Client.new(pool).push(item.stringify_keys)
-      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/fixtures/en.yml

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

data/test/helper.rb

@@ -1,49 +0,0 @@
-$CELLULOID_DEBUG = false
-$TESTING = true
-if ENV["COVERAGE"]
-  require 'simplecov'
-  SimpleCov.start do
-    add_filter "/test/"
-    add_filter "/myapp/"
-  end
-end
-ENV['RACK_ENV'] = ENV['RAILS_ENV'] = 'test'
-
-begin
-  require 'pry-byebug'
-rescue LoadError
-end
-
-require 'minitest/autorun'
-require 'minitest/pride'
-
-require 'celluloid/current'
-require 'celluloid/test'
-Celluloid.boot
-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