wurk 1.9.0 → 1.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5540591682172d88b9972b1cfc33cfca88c9c88d823c0b50fe80cb3556e8c08
-  data.tar.gz: a19e9d8e68fd2f9f93131cfad4f845595bc95f45aacb65047da452da52916cdd
+  metadata.gz: ce85d34d0d8e1f5aa0837c76310a94c2ca3e584ff0e9ca4d9e977c0347510f89
+  data.tar.gz: 113f78f30121c728a4d7f3db5dc6d1472f13ab1b6b7b50d6ee73223d681585f4
 SHA512:
-  metadata.gz: 0d264b8039051e56d2f6cec5aaebb4ce1f99d62ad498a247bece1b6464c316685f43562a76c87ec46f31e846ff6cb6d536f51a11b6d9d06348c32c999d4f2be5
-  data.tar.gz: 9f695bfc7da4e5ad9e24e6874431a115b80bf3dab52f175a11b8f383d0586694b2d611f3137b6698eb896c1c2107ef18e97d33b7877a1a4fd3af60f380f0f47a
+  metadata.gz: ca00027cf185252fd95e78c3283a90d4a0c21acbc3cd6623bc1a4a1e2add8b6625d8436f60fc80b934a2fb35325d013903791dcad3606605b580b7633958fa9f
+  data.tar.gz: bcae6990d734afd7dbc30e951aead9b7d35b77d060c1198a11d4d34d17ba866e6e81ba1ab168a417b115c1a6a690e8cc4c9926951fec58615d7c2e40a9619fda

data/app/controllers/wurk/api_controller.rb

@@ -62,7 +62,10 @@ module Wurk
     end
 
     def queues
-      render json: ::Wurk::Stats.new.queue_summaries.map { |q| ::Wurk::Api::Serializers.queue_summary(q) }
+      consumers = ::Wurk.redis(idempotent: true) { |conn| ::Wurk::QueueConsumers.counts(conn) }
+      render json: ::Wurk::Stats.new.queue_summaries.map { |q|
+        ::Wurk::Api::Serializers.queue_summary(q).merge(consumers: consumers.fetch(q.name, 0))
+      }
     end
 
     def queue

data/lib/wurk/boot_checks.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative 'keys'
+require_relative 'queue_consumers'
+
+module Wurk
+  # What a standalone runner says once at boot, after the app loaded. Log only,
+  # and never allowed to stop a boot: none of this changes behaviour by backend,
+  # version or peers.
+  module BootChecks
+    # Oldest version each non-Redis backend has been run against.
+    TESTED_FLOORS = { 'dragonfly' => '1.34.0', 'valkey' => '8.0.0' }.freeze
+    MAX_LISTED = 20
+
+    module_function
+
+    def run(config, info)
+      log_backend(config.logger, info)
+      warn_on_foreign_processes(config)
+      warn_on_ignored_locks(config.logger)
+    rescue StandardError => e
+      config.logger.warn { "wurk boot checks skipped: #{e.class}: #{e.message}" }
+    end
+
+    def backend(info)
+      return ['dragonfly', info['dragonfly_version'].to_s.delete_prefix('df-v')] if info['dragonfly_version']
+      return ['valkey', info['valkey_version'].to_s] if info['valkey_version']
+
+      ['redis', info['redis_version'].to_s]
+    end
+
+    def log_backend(logger, info)
+      name, version = backend(info)
+      logger.info { "Wurk #{Wurk::VERSION} on #{name} #{version}" }
+      floor = TESTED_FLOORS[name]
+      return unless floor && ::Gem::Version.correct?(version) && ::Gem::Version.new(version) < ::Gem::Version.new(floor)
+
+      logger.warn { "#{name} #{version} is older than the oldest version Wurk is tested against (#{floor})." }
+    end
+
+    # Both runtimes share `processes` and the same queues, so a mix is safe only
+    # if it is deliberate. Wurk's heartbeat always carries `cores`; stock does not.
+    def warn_on_foreign_processes(config)
+      foreign = process_infos(config).reject { |_, info| info.nil? || ::JSON.parse(info).key?('cores') }.map(&:first)
+      return if foreign.empty?
+
+      config.logger.warn do
+        "Live processes that are not Wurk share this Redis: #{listing(foreign)}. " \
+          'They fetch from the same queues. If this is not a deliberate rolling cutover, stop them.'
+      end
+    end
+
+    def process_infos(config)
+      config.redis(idempotent: true) do |conn|
+        ids = conn.call('SMEMBERS', Keys::PROCESSES)
+        ids.empty? ? [] : ids.zip(conn.pipelined { |pipe| ids.each { |id| pipe.call('HGET', id, 'info') } })
+      end
+    end
+
+    # Without the gem's middleware the option does nothing: the "unique" job
+    # simply enqueues twice. Only classes the app has loaded by now are seen.
+    def warn_on_ignored_locks(logger)
+      return if defined?(::SidekiqUniqueJobs)
+
+      classes = locked_job_classes
+      return if classes.empty?
+
+      logger.warn do
+        'These jobs set `lock:` but sidekiq-unique-jobs is not loaded, so the option does nothing and ' \
+          "duplicates will run: #{listing(classes)}. Keep the gem, or move them to `unique_for:`."
+      end
+    end
+
+    def locked_job_classes
+      ::ObjectSpace.each_object(::Class).filter_map do |klass|
+        next unless klass.name && klass < Wurk::Worker
+
+        klass.name if klass.get_sidekiq_options.key?('lock')
+      end.sort
+    end
+
+    def listing(names)
+      extra = names.size - MAX_LISTED
+      names.first(MAX_LISTED).join(', ') + (extra.positive? ? " and #{extra} more" : '')
+    end
+  end
+end

data/lib/wurk/capsule.rb

@@ -53,6 +53,8 @@ module Wurk
     #   %w[high default low]        → mode :strict,   weights all 0
     #   %w[high,3 default,2 low,1]  → mode :weighted, weights {q=>w}
     #   %w[a,1 b,1 c,1]             → mode :random,   weights all 1
+    #   %w[a,2 b]                   → mode :weighted, unweighted b fetched as if 1
+    #   %w[a,0 b,0]                 → mode :strict, 0 being the same as no weight
     # `@queues` is expanded by weight so a uniform shuffle gives weighted
     # fairness (e.g. ["high","high","high","default","default","low"]).
     def queues=(val)
@@ -188,6 +190,16 @@ module Wurk
       @pools.clear
     end
 
+    # The fork-path form: closes idle sockets but keeps every pool usable, for a
+    # parent whose own threads may be mid-checkout.
+    def reload_redis_pools!
+      @pools.each_value(&:reload!)
+    end
+
+    def redis_pools_built?
+      !@pools.empty?
+    end
+
     def redis(idempotent: false, &)
       PoolCheckout.with(redis_pool, idempotent, &)
     end
@@ -229,19 +241,32 @@ module Wurk
       copy = server_middleware
       return copy if frozen?
 
-      @config.server_middleware.entries.each do |entry|
+      global = @config.server_middleware.entries
+      global.each_with_index do |entry, index|
         next if @server_middleware_seen.include?(entry.klass)
 
         @server_middleware_seen << entry.klass
-        next if copy.exists?(entry.klass)
-
-        rebound = entry.dup
-        rebound.config = self
-        copy.entries << rebound
+        adopt_server_middleware(copy, entry, global.drop(index + 1)) unless copy.exists?(entry.klass)
       end
       copy
     end
 
+    def adopt_server_middleware(copy, entry, followers)
+      rebound = entry.dup
+      rebound.config = self
+      copy.entries.insert(refresh_position(copy, followers), rebound)
+    end
+
+    # Ahead of the first entry that follows it in the global chain, so a late
+    # `prepend` still wraps what it was prepended to. -1 appends.
+    def refresh_position(copy, followers)
+      followers.each do |follower|
+        position = copy.entries.index { |entry| entry.klass == follower.klass }
+        return position if position
+      end
+      -1
+    end
+
     # Drop-in fetch pluggability (spec §5 / §4.1): instantiate
     # `config[:fetch_class]` when the host set one — a custom or Pro fetcher —
     # else the default reliable BLMOVE fetcher (`Sidekiq::BasicFetch`). A
@@ -276,7 +301,7 @@ module Wurk
       return [qname, 0] if weight.nil?
 
       weight = Integer(weight)
-      raise ArgumentError, "queue weight must be > 0: `#{entry}`" if weight <= 0
+      raise ArgumentError, "queue weight must not be negative: `#{entry}`" if weight.negative?
 
       [qname, weight]
     end
@@ -295,7 +320,7 @@ module Wurk
     def expand_by_weight(parsed, mode)
       return parsed.map(&:first) if %i[strict random].include?(mode)
 
-      parsed.flat_map { |q, w| [q] * w }
+      parsed.flat_map { |q, w| [q] * [w, 1].max }
     end
 
     # `config.redis = { size: N }` pins the main pool at N; otherwise

data/lib/wurk/cli.rb

@@ -11,6 +11,8 @@ require_relative 'configuration'
 require_relative 'component'
 require_relative 'capsule'
 require_relative 'launcher'
+require_relative 'rails_boot'
+require_relative 'boot_checks'
 
 module Wurk
   # Standalone CLI. Loads from `exe/wurk` — never loads `wurk/rails` so the
@@ -29,7 +31,7 @@ module Wurk
     # Subcommands. Bare `wurk` runs the worker — the historical shape, and the
     # only one the swarm binaries accept — so a subcommand is never anything
     # but the first argument, and every argument after it is that command's.
-    COMMANDS = %w[api].freeze
+    COMMANDS = %w[api health].freeze
 
     # `wurk api` defaults. 0.0.0.0 because the point of the machine API is for
     # another service to reach it; it is bearer-gated, and answers 404 to
@@ -99,6 +101,15 @@ module Wurk
       ['-s', '--server NAME',  :api_server, 'Rack handler to serve with (default: the first installed)']
     ].freeze
 
+    HEALTH_OPTION_FLAGS = [
+      ['-w', '--window SECONDS', :health_window, 'A heartbeat older than this does not count (default 60)', :to_i],
+      ['-m', '--min COUNT', :health_min, 'Processes on this host that must be beating (default 1)', :to_i],
+      ['-u', '--redis-url URL', :health_redis_url, 'Redis to read (default REDIS_URL)'],
+      ['-s', '--strict', :health_strict, 'Fail when Redis cannot be read, rather than passing']
+    ].freeze
+
+    HELP_COMMANDS = "\nCommands:\n    health    Exit 0 if this host's workers are heartbeating\n\nOptions:"
+
     attr_accessor :launcher, :environment, :config
 
     # The subcommand `parse` pulled off argv, or nil for the worker runner.
@@ -127,6 +138,8 @@ module Wurk
     def parse(args = ARGV.dup)
       @config ||= Wurk.default_configuration
       @command = extract_command!(args)
+      return parse_health_options(args) if @command == 'health'
+
       setup_options(args)
       initialize_logger
       validate!
@@ -134,7 +147,9 @@ module Wurk
     end
 
     # `boot_app:` / `warmup:` are test seams. Production always passes true.
-    def run(boot_app: true, warmup: true)
+    def run(boot_app: true, warmup: true) # rubocop:disable Metrics/AbcSize
+      exit(run_health) if @command == 'health'
+
       # Mark server mode BEFORE the app loads so `configure_server` blocks in
       # the required initializer actually fire (they gate on `config.server?`).
       # Matches Sidekiq, which sets `Sidekiq.server = true` before requiring
@@ -149,6 +164,7 @@ module Wurk
         trap_signals(self_write)
         validate_redis!
         validate_pool_sizes!
+        BootChecks.run(@config, redis_info)
         @config[:identity] = identity
         # Force lazy server-middleware chain so worker threads don't race
         # against each other constructing it. Spec: Sidekiq::CLI line 104.
@@ -175,23 +191,28 @@ module Wurk
     # (`WURK_PRELOAD`/`SIDEKIQ_PRELOAD` Bundler groups, `WURK_PRELOAD_APP`/
     # `SIDEKIQ_PRELOAD_APP` whole-app eager-load) and boots `Process.warmup`
     # before the fork so children share warmed pages (copy-on-write). Spec §7.
-    def run_swarm(boot_app: true, warmup: true)
+    def run_swarm(boot_app: true, warmup: true) # rubocop:disable Metrics/AbcSize
       raise ArgumentError, "the swarm runner takes no subcommand; run `wurk #{@command}` instead" if @command
 
       # Server mode before the app loads — see #run. The flag rides through the
       # fork into every child (the config object is copied), so configure_server
       # blocks registered in the parent take effect in the workers.
       enter_server_mode
+      # Only the children read it. Rejected here, a typo fails this boot instead of
+      # crash-looping the fleet until the crash-loop exit.
+      Health.options_from_env
       if boot_app
+        load_rails_framework
         preload_bundler_groups
         boot_application
         eager_load_application
       end
       validate_redis!
       validate_pool_sizes!
+      BootChecks.run(@config, redis_info)
       @config[:identity] = identity
       warm_up_process if warmup
-      @swarm = Wurk::Swarm.new(topology: @config.topology, config: @config,
+      @swarm = Wurk::Swarm.new(topology: @config.topology, config: @config, exit_on_crash_loop: true,
                                shutdown_timeout: @config[:timeout] || Swarm::DEFAULT_SHUTDOWN_TIMEOUT)
       begin
         @swarm.boot(install_signals: true)
@@ -202,6 +223,16 @@ module Wurk
         # A no-op once the loop already drained (no children, pipe closed).
         @swarm.shutdown
       end
+      exit(1) if @swarm.crash_looped?
+    end
+
+    # `wurk health` — see Wurk::HealthProbe. Boots nothing; returns the exit code.
+    def run_health
+      require_relative 'health_probe'
+      opts = @health_options
+      @config.redis = { url: opts[:health_redis_url] } if opts[:health_redis_url]
+      HealthProbe.new(@config, window: opts[:health_window] || HealthProbe::DEFAULT_WINDOW,
+                               min: opts[:health_min] || 1, strict: opts[:health_strict] == true).call
     end
 
     # `wurk api` — serve the machine-facing HTTP API and nothing else: no
@@ -329,8 +360,8 @@ module Wurk
     def reopen_logs
       log = logger
       log.reopen if log.respond_to?(:reopen)
-    rescue StandardError
-      nil
+    rescue StandardError => e
+      warn "wurk: USR2 log reopen failed, still writing to the previous log: #{e.class}: #{e.message}"
     end
 
     def validate_redis!
@@ -372,6 +403,14 @@ module Wurk
       COMMANDS.include?(args.first) ? args.shift : nil
     end
 
+    def parse_health_options(args)
+      @health_options = {}
+      parser = option_parser(@health_options)
+      @parser = parser
+      parser.parse!(args)
+      self
+    end
+
     def setup_options(args)
       opts = parse_options(args)
       set_environment(opts[:environment])
@@ -458,8 +497,9 @@ module Wurk
       require 'optparse'
 
       ::OptionParser.new do |o|
-        o.banner = @command ? "wurk #{@command} [options]" : 'wurk [options]'
-        define_value_flags(o, opts, OPTION_FLAGS)
+        o.banner = @command ? "wurk #{@command} [options]" : "wurk [options]\nwurk COMMAND [options]"
+        o.separator HELP_COMMANDS unless @command
+        define_value_flags(o, opts, @command == 'health' ? HEALTH_OPTION_FLAGS : OPTION_FLAGS)
         define_value_flags(o, opts, API_OPTION_FLAGS) if @command == 'api'
         define_meta_flags(o, opts)
       end
@@ -492,6 +532,28 @@ module Wurk
 
     # --- application bootstrap --------------------------------------------
 
+    # A Rails app expects Rails to be loaded before its gems: `config/application.rb`
+    # requires the framework and only then calls `Bundler.require`, and gems read
+    # `defined?(Rails)` or reference ActiveModel while loading. Requiring the groups
+    # first broke those gems in this boot path only. So for a Rails target, run
+    # the app's own first half before the group preload.
+    def load_rails_framework
+      root = rails_app_root(@config[:require])
+      return unless root
+
+      ENV['RACK_ENV'] = ENV['RAILS_ENV'] = @environment
+      require 'rails'
+      define_active_job_adapter
+      require ::File.join(root, 'config/application.rb')
+    end
+
+    # The app root for a `-r` that is the app directory or its environment file.
+    def rails_app_root(require_path)
+      path = ::File.expand_path(require_path.to_s)
+      path = ::File.dirname(path, 2) if ::File.basename(path) == 'environment.rb'
+      path if ::File.directory?(path) && ::File.exist?(::File.join(path, 'config/application.rb'))
+    end
+
     # Spec §7.2/§7.3. Before the swarm parent forks, `Bundler.require` the
     # configured groups so their gems are resident in the parent and paged
     # copy-on-write into every child. Comma-separated group list; the native
@@ -554,6 +616,9 @@ module Wurk
     def boot_rails_application(require_path)
       require 'rails'
       define_active_job_adapter
+      # No railtie here (see boot_application), and a host's after_initialize hook
+      # may wrap the reloader, so it has to be the Rails one by then.
+      ::ActiveSupport.on_load(:after_initialize, yield: true) { |app| RailsBoot.install_reloader(app) }
       require ::File.expand_path("#{require_path}/config/environment.rb")
       @config[:tag] ||= default_tag(::Rails.root) if defined?(::Rails) && ::Rails.respond_to?(:root)
     end