sidekiq 7.3.0 → 8.0.5

data/lib/sidekiq/rails.rb

@@ -1,72 +1,61 @@
 # frozen_string_literal: true
 
-require "sidekiq/job"
-require "rails"
-
 module Sidekiq
-  class Rails < ::Rails::Engine
-    class Reloader
-      def initialize(app = ::Rails.application)
-        @app = app
-      end
-
-      def call
-        params = (::Rails::VERSION::STRING >= "7.1") ? {source: "job.sidekiq"} : {}
-        @app.reloader.wrap(**params) do
-          yield
+  begin
+    gem "railties", ">= 7.0"
+    require "rails"
+    require "sidekiq/job"
+    require_relative "../active_job/queue_adapters/sidekiq_adapter"
+
+    class Rails < ::Rails::Engine
+      class Reloader
+        def initialize(app = ::Rails.application)
+          @app = app
         end
-      end
 
-      def inspect
-        "#<Sidekiq::Rails::Reloader @app=#{@app.class.name}>"
-      end
+        def call
+          params = (::Rails::VERSION::STRING >= "7.1") ? {source: "job.sidekiq"} : {}
+          @app.reloader.wrap(**params) do
+            yield
+          end
+        end
 
-      def to_hash
-        {app: @app.class.name}
-      end
-    end
+        def inspect
+          "#<Sidekiq::Rails::Reloader @app=#{@app.class.name}>"
+        end
 
-    # By including the Options module, we allow AJs to directly control sidekiq features
-    # via the *sidekiq_options* class method and, for instance, not use AJ's retry system.
-    # AJ retries don't show up in the Sidekiq UI Retries tab, don't save any error data, can't be
-    # manually retried, don't automatically die, etc.
-    #
-    #   class SomeJob < ActiveJob::Base
-    #     queue_as :default
-    #     sidekiq_options retry: 3, backtrace: 10
-    #     def perform
-    #     end
-    #   end
-    initializer "sidekiq.active_job_integration" do
-      ActiveSupport.on_load(:active_job) do
-        include ::Sidekiq::Job::Options unless respond_to?(:sidekiq_options)
+        def to_hash
+          {app: @app.class.name}
+        end
       end
-    end
 
-    initializer "sidekiq.backtrace_cleaner" do
-      Sidekiq.configure_server do |config|
-        config[:backtrace_cleaner] = ->(backtrace) { ::Rails.backtrace_cleaner.clean(backtrace) }
+      initializer "sidekiq.backtrace_cleaner" do
+        Sidekiq.configure_server do |config|
+          config[:backtrace_cleaner] = ->(backtrace) { ::Rails.backtrace_cleaner.clean(backtrace) }
+        end
       end
-    end
-
-    # This hook happens after all initializers are run, just before returning
-    # from config/environment.rb back to sidekiq/cli.rb.
-    #
-    # None of this matters on the client-side, only within the Sidekiq process itself.
-    config.after_initialize do
-      Sidekiq.configure_server do |config|
-        config[:reloader] = Sidekiq::Rails::Reloader.new
 
-        # This is the integration code necessary so that if a job uses `Rails.logger.info "Hello"`,
-        # it will appear in the Sidekiq console with all of the job context.
-        unless ::Rails.logger == config.logger || ::ActiveSupport::Logger.logger_outputs_to?(::Rails.logger, $stdout)
-          if ::Rails.logger.respond_to?(:broadcast_to)
-            ::Rails.logger.broadcast_to(config.logger)
-          else
-            ::Rails.logger.extend(::ActiveSupport::Logger.broadcast(config.logger))
+      # This hook happens after all initializers are run, just before returning
+      # from config/environment.rb back to sidekiq/cli.rb.
+      #
+      # None of this matters on the client-side, only within the Sidekiq process itself.
+      config.after_initialize do
+        Sidekiq.configure_server do |config|
+          config[:reloader] = Sidekiq::Rails::Reloader.new
+
+          # This is the integration code necessary so that if a job uses `Rails.logger.info "Hello"`,
+          # it will appear in the Sidekiq console with all of the job context.
+          unless ::Rails.logger == config.logger || ::ActiveSupport::Logger.logger_outputs_to?(::Rails.logger, $stdout)
+            if ::Rails.logger.respond_to?(:broadcast_to)
+              ::Rails.logger.broadcast_to(config.logger)
+            else
+              ::Rails.logger.extend(::ActiveSupport::Logger.broadcast(config.logger))
+            end
           end
         end
       end
     end
+  rescue Gem::LoadError
+    # Rails not available or version requirement not met
   end
 end

data/lib/sidekiq/redis_client_adapter.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "set"
 require "redis_client"
 require "redis_client/decorator"
 

data/lib/sidekiq/redis_connection.rb

@@ -10,6 +10,8 @@ module Sidekiq
       def create(options = {})
         symbolized_options = deep_symbolize_keys(options)
         symbolized_options[:url] ||= determine_redis_provider
+        symbolized_options[:password] = wrap(symbolized_options[:password]) if symbolized_options.key?(:password)
+        symbolized_options[:sentinel_password] = wrap(symbolized_options[:sentinel_password]) if symbolized_options.key?(:sentinel_password)
 
         logger = symbolized_options.delete(:logger)
         logger&.info { "Sidekiq #{Sidekiq::VERSION} connecting to Redis with options #{scrub(symbolized_options)}" }
@@ -38,6 +40,15 @@ module Sidekiq
 
       private
 
+      # Wrap hard-coded passwords in a Proc to avoid logging the value
+      def wrap(pwd)
+        if pwd.is_a?(String)
+          ->(username) { pwd }
+        else
+          pwd
+        end
+      end
+
       def deep_symbolize_keys(object)
         case object
         when Hash
@@ -57,16 +68,23 @@ module Sidekiq
         # Deep clone so we can muck with these options all we want and exclude
         # params from dump-and-load that may contain objects that Marshal is
         # unable to safely dump.
-        keys = options.keys - [:logger, :ssl_params]
+        keys = options.keys - [:logger, :ssl_params, :password, :sentinel_password]
         scrubbed_options = Marshal.load(Marshal.dump(options.slice(*keys)))
         if scrubbed_options[:url] && (uri = URI.parse(scrubbed_options[:url])) && uri.password
           uri.password = redacted
           scrubbed_options[:url] = uri.to_s
         end
-        scrubbed_options[:password] = redacted if scrubbed_options[:password]
-        scrubbed_options[:sentinel_password] = redacted if scrubbed_options[:sentinel_password]
+        scrubbed_options[:password] = redacted if options.key?(:password)
+        scrubbed_options[:sentinel_password] = redacted if options.key?(:sentinel_password)
         scrubbed_options[:sentinels]&.each do |sentinel|
-          sentinel[:password] = redacted if sentinel[:password]
+          if sentinel.is_a?(String)
+            if (uri = URI(sentinel)) && uri.password
+              uri.password = redacted
+              sentinel.replace(uri.to_s)
+            end
+          elsif sentinel[:password]
+            sentinel[:password] = redacted
+          end
         end
         scrubbed_options
       end

data/lib/sidekiq/ring_buffer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "forwardable"
 
 module Sidekiq

data/lib/sidekiq/systemd.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 #
 # Sidekiq's systemd integration allows Sidekiq to inform systemd:
 #  1. when it has successfully started

data/lib/sidekiq/testing.rb

@@ -87,7 +87,7 @@ module Sidekiq
       if Sidekiq::Testing.fake?
         payloads.each do |job|
           job = Sidekiq.load_json(Sidekiq.dump_json(job))
-          job["enqueued_at"] = Time.now.to_f unless job["at"]
+          job["enqueued_at"] = ::Process.clock_gettime(::Process::CLOCK_REALTIME, :millisecond) unless job["at"]
           Queues.push(job["queue"], job["class"], job)
         end
         true
@@ -283,11 +283,11 @@ module Sidekiq
       end
 
       def process_job(job)
-        inst = new
-        inst.jid = job["jid"]
-        inst.bid = job["bid"] if inst.respond_to?(:bid=)
-        Sidekiq::Testing.server_middleware.invoke(inst, job, job["queue"]) do
-          execute_job(inst, job["args"])
+        instance = new
+        instance.jid = job["jid"]
+        instance.bid = job["bid"] if instance.respond_to?(:bid=)
+        Sidekiq::Testing.server_middleware.invoke(instance, job, job["queue"]) do
+          execute_job(instance, job["args"])
         end
       end
 
@@ -329,6 +329,6 @@ module Sidekiq
   end
 end
 
-if defined?(::Rails) && Rails.respond_to?(:env) && !Rails.env.test? && !$TESTING
+if defined?(::Rails) && Rails.respond_to?(:env) && !Rails.env.test? && !$TESTING # rubocop:disable Style/GlobalVars
   warn("⛔️ WARNING: Sidekiq testing API enabled, but this is not the test environment.  Your jobs will not go to Redis.", uplevel: 1)
 end

data/lib/sidekiq/version.rb

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
 module Sidekiq
-  VERSION = "7.3.0"
-  MAJOR = 7
+  VERSION = "8.0.5"
+  MAJOR = 8
+
+  def self.gem_version
+    Gem::Version.new(VERSION)
+  end
 end

data/lib/sidekiq/web/action.rb

@@ -1,99 +1,154 @@
 # frozen_string_literal: true
 
+require "erb"
+
 module Sidekiq
-  class WebAction
-    RACK_SESSION = "rack.session"
+  class Web
+    ##
+    # These instance methods are available to all executing ERB
+    # templates.
+    class Action
+      attr_accessor :env, :block
+
+      def initialize(env, block)
+        @_erb = false
+        @env = env
+        @block = block
+      end
 
-    attr_accessor :env, :block, :type
+      def config
+        env[:web_config]
+      end
 
-    def settings
-      Web.settings
-    end
+      def request
+        @request ||= ::Rack::Request.new(env)
+      end
 
-    def request
-      @request ||= ::Rack::Request.new(env)
-    end
+      def halt(res)
+        throw :halt, [res, {"content-type" => "text/plain"}, [res.to_s]]
+      end
 
-    def halt(res)
-      throw :halt, [res, {Rack::CONTENT_TYPE => "text/plain"}, [res.to_s]]
-    end
+      # external redirect
+      def redirect_to(url)
+        throw :halt, [302, {"location" => url}, []]
+      end
 
-    def redirect(location)
-      throw :halt, [302, {Web::LOCATION => "#{request.base_url}#{location}"}, []]
-    end
+      def header(key, value)
+        env["response_headers"][key] = value.to_s
+      end
 
-    def reload_page
-      current_location = request.referer.gsub(request.base_url, "")
-      redirect current_location
-    end
+      # internal redirect
+      def redirect(location)
+        throw :halt, [302, {"location" => "#{request.base_url}#{location}"}, []]
+      end
 
-    def params
-      indifferent_hash = Hash.new { |hash, key| hash[key.to_s] if Symbol === key }
+      def reload_page
+        current_location = request.referer.gsub(request.base_url, "")
+        redirect current_location
+      end
 
-      indifferent_hash.merge! request.params
-      route_params.each { |k, v| indifferent_hash[k.to_s] = v }
+      # stuff after ? or form input
+      # uses String keys, no Symbols!
+      def url_params(key)
+        warn { "URL parameter `#{key}` should be accessed via String, not Symbol (at #{caller(3..3).first})" } if key.is_a?(Symbol)
+        request.params[key.to_s]
+      end
 
-      indifferent_hash
-    end
+      # variables embedded in path, `/metrics/:name`
+      # uses Symbol keys, no Strings!
+      def route_params(key)
+        warn { "Route parameter `#{key}` should be accessed via Symbol, not String (at #{caller(3..3).first})" } if key.is_a?(String)
+        env["rack.route_params"][key.to_sym]
+      end
 
-    def route_params
-      env[WebRouter::ROUTE_PARAMS]
-    end
+      def params
+        warn { "Direct access to Rack parameters is discouraged, use `url_params` or `route_params` (at #{caller(3..3).first})" }
+        request.params
+      end
 
-    def session
-      env[RACK_SESSION]
-    end
+      def session
+        env["rack.session"]
+      end
 
-    def erb(content, options = {})
-      if content.is_a? Symbol
-        unless respond_to?(:"_erb_#{content}")
-          views = options[:views] || Web.settings.views
-          src = ERB.new(File.read("#{views}/#{content}.erb")).src
-          WebAction.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def _erb_#{content}
-              #{src}
-            end
-          RUBY
-        end
+      def logger
+        Sidekiq.logger
       end
 
-      if @_erb
-        _erb(content, options[:locals])
-      else
-        @_erb = true
-        content = _erb(content, options[:locals])
+      # flash { "Some message to show on redirect" }
+      def flash
+        msg = yield
+        logger.info msg
+        session[:flash] = msg
+      end
 
-        _render { content }
+      def flash?
+        session&.[](:flash)
       end
-    end
 
-    def render(engine, content, options = {})
-      raise "Only erb templates are supported" if engine != :erb
+      def get_flash
+        @flash ||= session.delete(:flash)
+      end
 
-      erb(content, options)
-    end
+      def erb(content, options = {})
+        if content.is_a? Symbol
+          unless respond_to?(:"_erb_#{content}")
+            views = options[:views] || Web.views
+            filename = "#{views}/#{content}.erb"
+            src = ERB.new(File.read(filename)).src
+
+            # Need to use lineno less by 1 because erb generates a
+            # comment before the source code.
+            Action.class_eval <<-RUBY, filename, -1 # standard:disable Style/EvalWithLocation
+              def _erb_#{content}
+                #{src}
+              end
+            RUBY
+          end
+        end
 
-    def json(payload)
-      [200, {Rack::CONTENT_TYPE => "application/json", Rack::CACHE_CONTROL => "private, no-store"}, [Sidekiq.dump_json(payload)]]
-    end
+        if @_erb
+          _erb(content, options[:locals])
+        else
+          @_erb = true
+          content = _erb(content, options[:locals])
 
-    def initialize(env, block)
-      @_erb = false
-      @env = env
-      @block = block
-      @files ||= {}
-    end
+          _render { content }
+        end
+      end
 
-    private
+      def render(engine, content, options = {})
+        raise "Only erb templates are supported" if engine != :erb
 
-    def _erb(file, locals)
-      locals&.each { |k, v| define_singleton_method(k) { v } unless singleton_methods.include? k }
+        erb(content, options)
+      end
+
+      def json(payload)
+        [200,
+          {"content-type" => "application/json", "cache-control" => "private, no-store"},
+          [Sidekiq.dump_json(payload)]]
+      end
+
+      private
+
+      def warn
+        Sidekiq.logger.warn yield
+      end
+
+      def _erb(file, locals)
+        locals&.each { |k, v| define_singleton_method(k) { v } unless singleton_methods.include? k }
 
-      if file.is_a?(String)
-        ERB.new(file).result(binding)
-      else
-        send(:"_erb_#{file}")
+        if file.is_a?(String)
+          ERB.new(file).result(binding)
+        else
+          send(:"_erb_#{file}")
+        end
       end
+
+      class_eval <<-RUBY, ::Sidekiq::Web::LAYOUT, -1 # standard:disable Style/EvalWithLocation
+        def _render
+          #{ERB.new(File.read(::Sidekiq::Web::LAYOUT)).src}
+        end
+      RUBY
     end
   end
 end