sidekiq-process_manager 1.1.1 → 1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 51d57e09aba69d64225948647f2f95625c668b44eb16e514b5ab4daf8e064e3c
-  data.tar.gz: 73d49c20ce5bf06a8d84a168d8e1afa2b04883ea1656d3d4e0ac96b66855140c
+  metadata.gz: 24bc40ee7ef3f0ade56a7c116d509cc7cbb88c4f15c1781a6c065be88ebe4a0c
+  data.tar.gz: 9c3704f538d9cb990aa4cb55e4fc2ce8f4b59c60aa0de92d0a95f1cca44e30fc
 SHA512:
-  metadata.gz: 2f35e8a6ccbbcbaa15fbbbd62658bd79e4337e675a0c4a776e8dc2c6457bb957ed5ba9880336532a68f54e5ea13890917d758d5f84a2395130c0c52a5166a7cc
-  data.tar.gz: dd4fa55ec09584a890e5125d93a64d15924b138583d23e91331a1818bec0c58dfa0cdd81ab58bfab37951a645ed41e149fa04996ec89d11c85c0362204c21be4
+  metadata.gz: fe31823918abde6d3128ada00c22aa60e25e3d16c7a3ebe85fbeaa25d20aa228ad5aee0ed68c0746876ae98bebbc951ea46725c0a339d583566befa82a2d1b1c
+  data.tar.gz: 39f00a80aaef0fc0e936f592a8b592a497ba697c366787d006924e1df73239db424a74d354bada8fadebb6f51e8bea87c44b4807b5b56a994a29902a2930526c

data/CHANGELOG.md

@@ -4,6 +4,29 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 1.1.3
+
+### Added
+- The interval between memory checks can now be set with the `--memory-check-interval` command line argument or the `SIDEKIQ_MEMORY_CHECK_INTERVAL` environment variable. It still defaults to 60 seconds.
+
+### Fixed
+- Child processes now reset the signal handlers inherited from the process manager to their default behavior when they are forked. The inherited handlers do nothing outside of the master process, so any signal sent to a child process before sidekiq installed its own handlers was silently discarded and the process would only be stopped by the SIGKILL failsafe.
+- Fixed race condition where a child process forked to replace a dead process while a TERM or INT signal was being handled would never receive the shutdown signal, leaving the process manager hung waiting on it.
+- Child processes are now reaped while waiting for them to exit at shutdown, with a timeout, so the process manager can no longer hang forever waiting on zombie processes if it exits abnormally. All processes are polled on each pass so that one slow process cannot consume the entire timeout, and any that are still running when the timeout expires are killed with SIGKILL and reaped rather than being orphaned.
+- Child processes spawned by libraries or application code (e.g. `ps` invoked by the get_process_mem gem) are no longer mistaken for sidekiq processes by the process monitor.
+- The SIGKILL failsafe now uses the manager's list of running processes to determine liveness instead of a system call, removing the possibility of signaling an unrelated process if the operating system reuses a process id.
+- The signal handling thread exits cleanly instead of busy-looping if the signal pipe is closed.
+- Fixed the validation error message when the process count is less than one.
+- The `sidekiq-process-manager` command line now accepts a max memory value in plain bytes and aborts with an error message on invalid values instead of silently ignoring them.
+
+## 1.1.2
+
+### Added
+- Added thread to monitor child processes to make sure they exit after a SIGTERM signal has been sent. If a process does not exit after the configured Sidekiq timeout time, then it will be killed with a SIGKILL signal.
+
+### Changed
+- A SIGINT sent to the manager process will sent SIGTERM to the child processes to give them a chance to shutdown gracefully.
+
 ## 1.1.1
 
 ### Added

data/README.md

@@ -1,14 +1,14 @@
 # Sidekiq::ProcessManager
 
 [![Continuous Integration](https://github.com/bdurand/sidekiq-process_manager/actions/workflows/continuous_integration.yml/badge.svg)](https://github.com/bdurand/sidekiq-process_manager/actions/workflows/continuous_integration.yml)
-[![Maintainability](https://api.codeclimate.com/v1/badges/ed89164d480af0e1442e/maintainability)](https://codeclimate.com/github/bdurand/sidekiq-process_manager/maintainability)
 [![Ruby Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://github.com/testdouble/standard)
+[![Gem Version](https://badge.fury.io/rb/sidekiq-process_manager.svg)](https://badge.fury.io/rb/sidekiq-process_manager)
 
 This gem provides a command line script for managing [sidekiq](https://github.com/mperham/sidekiq) processes. It starts up a process that then forks multiple sidekiq processes and manages their life cycle. This is important for large sidekiq installations, since without it on MRI ruby, sidekiq will only use one CPU core. By starting multiple processes you make all cores available.
 
 The sidekiq processes can all be managed by sending signals to the manager process. This process simply forwards the signals on to the child processes, allowing you to control the sidekiq processes as you normally would.
 
-If one of the sidekiq processes dies unexpectedly, the process manager automatically starts a new sidekiq process to replace it.
+If one of the sidekiq processes exits unexpectedly, the process manager automatically starts a new sidekiq process to replace it.
 
 ## Pre-Forking
 
@@ -44,7 +44,7 @@ For a Rails application, you would normally want to preboot the `config/boot.rb`
 
 ## Memory Bloat
 
-You can also specify a maximum memory footprint that you want to allow for each child process. You can use this feature to automatically guard against poorly designed workers that bloat the Ruby memory heap. Note that you can also use an external process monitor to kill processes with memory bloat; the process manager will restart any process regardless of how it dies.
+You can also specify a maximum memory footprint that you want to allow for each child process. You can use this feature to automatically guard against poorly designed workers that bloat the Ruby memory heap. Note that you can also use an external process monitor to kill processes with memory bloat; the process manager will restart any process regardless of how it exits.
 
 ## Usage
 
@@ -109,6 +109,18 @@ or
 SIDEKIQ_MAX_MEMORY=2000m SIDEKIQ_PROCESSES=4 bundle exec sidekiq-process-manager
 ```
 
+Memory is checked once a minute by default. You can change how often with the `--memory-check-interval` argument or with the `SIDEKIQ_MEMORY_CHECK_INTERVAL` environment variable. The value is in seconds. Note that only one process is restarted per check, so the interval also controls how quickly multiple bloated processes are recycled.
+
+```bash
+bundle exec sidekiq-process-manager --processes 4 --max-memory 2g --memory-check-interval 10
+```
+
+or
+
+```bash
+SIDEKIQ_MEMORY_CHECK_INTERVAL=10 SIDEKIQ_MAX_MEMORY=2g SIDEKIQ_PROCESSES=4 bundle exec sidekiq-process-manager
+```
+
 ## Alternatives
 
 Any process manager can be an alternative (service, update, systemd, monit, god, etc.).
@@ -139,6 +151,20 @@ Or install it yourself as:
 $ gem install sidekiq-process_manager
 ```
 
+## Test Application
+
+There is a test application in the `test_app` directory that can be used to test the process manager. You can run it with:
+
+```bash
+$ cd test_app
+$ bundle install
+$ bin/run
+```
+
+This will bring up a valkey docker instance, sidekiq cluster, and rack application that shows the status of the sidekiq processes.
+
+Then visit [http://localhost:9292](http://localhost:9292) to see the status of the sidekiq processes.
+
 ## Contributing
 
 Open a pull request on [GitHub](https://github.com/bdurand/sidekiq-process_manager).

data/VERSION

@@ -1 +1 @@
-1.1.1
+1.1.3

data/bin/sidekiq-process-manager

@@ -7,19 +7,23 @@ require_relative "../lib/sidekiq-process_manager"
 DEFAULT_PROCESS_COUNT = 1
 
 def parse_max_memory(max_memory)
-  value = nil
-
-  matched = max_memory.to_s.match(/\A([\d]+(?:\.[\d]+)?)([mg])\z/i)
-  if matched
-    value = matched[1].to_f
-    if matched[2].downcase == 'm'
-      value *= 1024 * 1024
-    elsif matched[2].downcase == 'g'
-      value *= 1024 * 1024 * 1024
-    end
+  Sidekiq::ProcessManager.parse_max_memory(max_memory)
+rescue ArgumentError => e
+  abort(e.message)
+end
+
+def parse_memory_check_interval(interval)
+  interval = interval.to_s.strip
+  return nil if interval.empty?
+
+  begin
+    interval = Float(interval)
+  rescue ArgumentError, TypeError
+    abort("Invalid memory check interval value: #{interval.inspect}")
   end
+  abort("Memory check interval must be greater than 0") unless interval > 0
 
-  value
+  interval
 end
 
 options = {
@@ -27,6 +31,7 @@ options = {
   prefork: !ENV.fetch("SIDEKIQ_PREFORK", "").empty?,
   preboot: ENV["SIDEKIQ_PREBOOT"],
   max_memory: parse_max_memory(ENV["SIDEKIQ_MAX_MEMORY"]),
+  memory_check_interval: parse_memory_check_interval(ENV["SIDEKIQ_MEMORY_CHECK_INTERVAL"]),
   mode: nil,
 }
 
@@ -45,10 +50,14 @@ parser = OptionParser.new do |opts|
     options[:preboot] = preboot
   end
 
-  opts.on('--max-memory MEMORY', "Max memory for each process (can also specify with SIDEKIQ_MAX_MEMORY); suffix with m or g to specify megabytes or gigabytes") do |max_memory|
+  opts.on('--max-memory MEMORY', "Max memory for each process (can also specify with SIDEKIQ_MAX_MEMORY); value is in bytes, or suffix with m or g to specify megabytes or gigabytes") do |max_memory|
     options[:max_memory] = parse_max_memory(max_memory)
   end
 
+  opts.on('--memory-check-interval SECONDS', "Seconds between memory checks when a max memory is set (can also specify with SIDEKIQ_MEMORY_CHECK_INTERVAL); defaults to #{Sidekiq::ProcessManager::Manager::DEFAULT_MEMORY_CHECK_INTERVAL} seconds") do |interval|
+    options[:memory_check_interval] = parse_memory_check_interval(interval)
+  end
+
   opts.on('--testing', "Enable test mode") do |testing|
     options[:mode] = :testing if testing
   end

data/lib/sidekiq/process_manager/manager.rb

@@ -2,6 +2,7 @@
 
 require "sidekiq"
 require "get_process_mem"
+require "timeout"
 
 module Sidekiq
   module ProcessManager
@@ -9,6 +10,12 @@ module Sidekiq
     # that the specified number of sidekiq processes are running. It will also forward
     # signals sent to the main process to the child processes.
     class Manager
+      # Signals that are trapped by the process manager and forwarded to the child processes.
+      SIGNALS = [:INT, :TERM, :USR1, :USR2, :TSTP, :TTIN].freeze
+
+      # Number of seconds between memory checks when a max memory is set.
+      DEFAULT_MEMORY_CHECK_INTERVAL = 60
+
       attr_reader :cli
 
       # Create a new process manager.
@@ -16,31 +23,38 @@ module Sidekiq
       # @param process_count [Integer] The number of sidekiq processes to start.
       # @param prefork [Boolean] If true, the process manager will load the application before forking.
       # @param preboot [String] If set, the process manager will require the specified file before forking the child processes.
+      # @param memory_check_interval [Numeric] The number of seconds between memory checks
+      #   when a max memory is set.
       # @param mode [Symbol] If set to :testing, the process manager will use a mock CLI.
       # @param silent [Boolean] If true, the process manager will not output any messages.
-      def initialize(process_count: 1, prefork: false, preboot: nil, max_memory: nil, mode: nil, silent: false)
+      def initialize(process_count: 1, prefork: false, preboot: nil, max_memory: nil, memory_check_interval: nil, mode: nil, silent: false)
         require "sidekiq/cli"
 
         # Get the number of processes to fork
         @process_count = process_count
-        raise ArgumentError.new("Process count must be greater than 1") if @process_count < 1
+        raise ArgumentError.new("Process count must be greater than 0") if @process_count < 1
 
-        @prefork = (prefork && process_count > 1)
+        @prefork = prefork && process_count > 1
         @preboot = preboot if process_count > 1 && !prefork
         @max_memory = ((max_memory.to_i > 0) ? max_memory.to_i : nil)
 
+        if !memory_check_interval.nil? && memory_check_interval.to_f <= 0
+          raise ArgumentError.new("Memory check interval must be greater than 0")
+        end
+
         if mode == :testing
           require_relative "../../../spec/support/mocks"
           @cli = MockSidekiqCLI.new(silent)
-          @memory_check_interval = 1
+          @memory_check_interval = (memory_check_interval || 1).to_f
+          @exit_grace_period = 0.5
         else
           @cli = Sidekiq::CLI.instance
-          @memory_check_interval = 60
+          @memory_check_interval = (memory_check_interval || DEFAULT_MEMORY_CHECK_INTERVAL).to_f
+          @exit_grace_period = 5
         end
 
         @silent = silent
         @pids = []
-        @terminated_pids = []
         @started = false
         @mutex = Mutex.new
       end
@@ -69,18 +83,22 @@ module Sidekiq
 
           while @signal_pipe_read.wait_readable
             begin
-              signal = @signal_pipe_read.gets.strip
+              signal = @signal_pipe_read.gets
+              break if signal.nil?
+
+              signal = signal.strip
               send_signal_to_children(signal.to_sym)
             rescue => e
-              log_error("Error handling signal #{signal}: #{e.message}")
+              log_warning("Error sending signal #{signal} to child processes: #{e.message}")
             end
           end
         end
 
         # Trap signals that will be forwarded to child processes
-        [:INT, :TERM, :USR1, :USR2, :TSTP, :TTIN].each do |signal|
+        SIGNALS.each do |signal|
           ::Signal.trap(signal) do
             if ::Process.pid == master_pid
+              signal = :TERM if signal == :INT
               @signal_pipe_write.puts(signal)
             end
           end
@@ -88,15 +106,19 @@ module Sidekiq
 
         # Ensure that child processes receive the term signal when the master process exits.
         at_exit do
-          if ::Process.pid == master_pid && @process_count > 0
-            send_signal_to_children(:TERM)
+          if ::Process.pid == master_pid
+            if @process_count > 0
+              send_signal_to_children(:TERM)
+            end
+            wait_for_children_to_exit
+            log_info("Process manager exiting")
           end
         end
 
         GC.start
         GC.compact if GC.respond_to?(:compact)
         # I'm not sure why, but running GC operations blocks until we try to write some I/O.
-        File.write("/dev/null", "0")
+        File.write(File::NULL, "0")
 
         @process_count.times do
           start_child_process!
@@ -104,9 +126,8 @@ module Sidekiq
 
         start_memory_monitor if @max_memory
 
-        log_info("Process manager started with pid #{::Process.pid}")
+        log_info("Process manager started")
         monitor_child_processes
-        log_info("Process manager #{::Process.pid} exiting")
       end
 
       # Helper to wait on the manager to wait on child processes to start up.
@@ -116,7 +137,7 @@ module Sidekiq
       def wait(timeout = 5)
         timeout_time = monotonic_time + timeout
         while monotonic_time <= timeout_time
-          return if @pids.size == @process_count
+          return if pids.size == @process_count
           sleep(0.01)
         end
 
@@ -213,11 +234,20 @@ module Sidekiq
       end
 
       def set_program_name!
-        $PROGRAM_NAME = "sidekiq process manager #{sidekiq_options[:tag]} [#{@pids.size} processes]"
+        $PROGRAM_NAME = "sidekiq process manager #{sidekiq_options[:tag]} [#{pids.size} processes]"
       end
 
       def start_child_process!
         pid = fork do
+          # Child processes inherit the signal handlers installed by the process
+          # manager. Those handlers only do anything in the master process, so
+          # leaving them in place would silently discard any signal sent to the
+          # child before sidekiq installs its own handlers. Restore the default
+          # behavior until then so signals are never swallowed.
+          SIGNALS.each do |signal|
+            ::Signal.trap(signal, "DEFAULT")
+          end
+
           # Set $0 so instrumentation libraries detecting sidekiq from the command run will work properly.
           $0 = File.join(File.dirname($0), "sidekiq")
           @process_count = 0
@@ -228,27 +258,47 @@ module Sidekiq
           Sidekiq::ProcessManager.run_after_fork_hooks
           @cli.run
         end
-        @mutex.synchronize { @pids << pid }
+        shutting_down = false
+        @mutex.synchronize do
+          @pids << pid
+          shutting_down = @process_count < 1
+        end
         log_info("Forked sidekiq process with pid #{pid}")
+        # A shutdown signal may have been forwarded to the other processes while
+        # this one was being forked; it needs to get the signal as well.
+        send_signal_to_pid(:TERM, pid) if shutting_down
         set_program_name!
       end
 
       def send_signal_to_children(signal)
         log_info("Process manager trapped signal #{signal}")
-        @process_count = 0 if signal == :INT || signal == :TERM
-        pids.each do |pid|
-          begin
-            log_info("Sending signal #{signal} to sidekiq process #{pid}")
-            ::Process.kill(signal, pid)
-          rescue => e
-            log_warning("Error sending signal #{signal} to sidekiq process #{pid}: #{e.inspect}")
+        child_pids = @mutex.synchronize do
+          @process_count = 0 if signal == :INT || signal == :TERM
+          @pids.dup
+        end
+        child_pids.each do |pid|
+          send_signal_to_pid(signal, pid)
+        end
+      end
+
+      def send_signal_to_pid(signal, pid)
+        signal = signal.to_sym
+        begin
+          log_info("Sending signal #{signal} to sidekiq process #{pid}")
+          ::Process.kill(signal, pid)
+          if [:TERM, :INT].include?(signal)
+            Thread.new do
+              Thread.current.name = "pid-#{pid}-killer"
+              ensure_pid_dies(pid)
+            end
           end
+        rescue Errno::ESRCH
+          # The process is already dead
         end
-        wait_for_children_to_exit(pids) if @process_count == 0
       end
 
       def start_memory_monitor
-        log_info("Starting memory monitor with max memory #{(@max_memory / (1024**2)).round}mb")
+        log_info("Starting memory monitor with max memory #{(@max_memory / (1024**2)).round}mb checked every #{@memory_check_interval} seconds")
 
         @memory_monitor = Thread.new do
           Thread.current.name = "memory-monitor"
@@ -256,20 +306,14 @@ module Sidekiq
             sleep(@memory_check_interval)
 
             pids.each do |pid|
-              begin
-                memory = GetProcessMem.new(pid)
-                if memory.bytes > @max_memory
-                  log_warning("Kill bloated sidekiq process #{pid}: #{memory.mb.round}mb used")
-                  begin
-                    ::Process.kill(:TERM, pid)
-                  rescue Errno::ESRCH
-                    # The process is already dead
-                  end
-                  break
-                end
-              rescue => e
-                log_warning("Error monitoring memory for sidekiq process #{pid}: #{e.inspect}")
+              memory = GetProcessMem.new(pid)
+              if memory.bytes > @max_memory
+                log_warning("Killing bloated sidekiq process #{pid}: #{memory.mb.round}mb used")
+                send_signal_to_pid(:TERM, pid)
+                break
               end
+            rescue => e
+              log_warning("Error monitoring memory for sidekiq process #{pid}: #{e.inspect}")
             end
           end
         end
@@ -281,49 +325,122 @@ module Sidekiq
         end
       end
 
-      def wait_for_children_to_exit(pids)
-        timeout = monotonic_time + (sidekiq_options[:timeout] || 25).to_f
-        pids.each do |pid|
-          while monotonic_time < timeout
-            break unless process_alive?(pid)
-            sleep(0.01)
+      def wait_for_children_to_exit
+        # Allow the SIGKILL failsafe in ensure_pid_dies time to fire before giving up on a process.
+        remaining = reap_child_processes(pids, monotonic_time + sidekiq_shutdown_timeout + @exit_grace_period)
+
+        unless remaining.empty?
+          # Don't leave orphaned processes behind. These pids were never reaped,
+          # so the operating system cannot have reused them for another process
+          # and it is safe to signal them.
+          remaining.each do |pid|
+            ::Process.kill(:KILL, pid)
+            log_warning("Sidekiq process #{pid} failed to exit; killed with SIGKILL")
+          rescue Errno::ESRCH
+            # The process is already dead
           end
+
+          # SIGKILL cannot be caught or ignored, so the processes will exit, but
+          # not necessarily by the time the signal is sent. Wait for them so they
+          # are not left behind as zombies.
+          remaining = reap_child_processes(remaining, monotonic_time + @exit_grace_period)
         end
 
-        pids.each do |pid|
-          begin
-            ::Process.kill(:INT, pid) if process_alive?(pid)
-          rescue
-            # Ignore errors so we can continue to kill other processes.
-          end
+        if remaining.empty?
+          log_info("All sidekiq processes have exited")
+        else
+          log_warning("Gave up waiting on sidekiq processes: #{remaining.join(", ")}")
         end
       end
 
-      def process_alive?(pid)
-        begin
-          ::Process.getpgid(pid)
-          true
-        rescue Errno::ESRCH
-          false
+      # Reap child processes as they exit until they have all been reaped or the
+      # deadline passes.
+      #
+      # @return [Array<Integer>] The pids that were not reaped.
+      def reap_child_processes(child_pids, deadline)
+        remaining = child_pids.dup
+        until remaining.empty?
+          # Poll all of the processes on each pass so that one slow process
+          # cannot consume the entire timeout waiting for the others.
+          remaining.delete_if { |pid| reap_child_process(pid) }
+          break if remaining.empty? || monotonic_time >= deadline
+          sleep(0.01)
+        end
+        remaining
+      end
+
+      # Reap a child process if it has exited. The pid is only removed from the
+      # list of running processes when it is actually reaped so that the SIGKILL
+      # failsafe in ensure_pid_dies still sees it as running until then.
+      #
+      # @return [Boolean] true if the process has been reaped or is no longer a child process.
+      def reap_child_process(pid)
+        reaped = begin
+          # The monitoring loop may no longer be running, so reap the child
+          # process here rather than just polling for it to disappear.
+          ::Process.waitpid(pid, ::Process::WNOHANG)
+        rescue Errno::ECHILD, Errno::ESRCH
+          # The process has already been reaped.
+          pid
+        end
+        return false unless reaped
+
+        @mutex.synchronize { @pids.delete(pid) }
+        true
+      end
+
+      def sidekiq_shutdown_timeout
+        (sidekiq_options[:timeout] || 25).to_f
+      end
+
+      def ensure_pid_dies(pid)
+        # Wait for the process to die, or kill it after a timeout. A pid is
+        # removed from the list only once it has been reaped, so the list is the
+        # source of truth for liveness; a pid still in it cannot have been reused
+        # by the operating system for a different process. Checking with a system
+        # call is not reliable since it cannot distinguish a recycled pid.
+        end_time = monotonic_time + sidekiq_shutdown_timeout
+        while monotonic_time < end_time && pids.include?(pid)
+          sleep(0.1)
+        end
+
+        if pids.include?(pid)
+          begin
+            ::Process.kill(:KILL, pid)
+            log_warning("Sidekiq process #{pid} failed to exit after #{sidekiq_shutdown_timeout} seconds; killed with SIGKILL")
+          rescue Errno::ESRCH
+            # The process is already dead
+          end
         end
       end
 
       # Listen for child processes dying and restart if necessary.
       def monitor_child_processes
         loop do
-          pid = ::Process.wait
-          @mutex.synchronize { @pids.delete(pid) }
+          begin
+            pid = ::Process.wait
+          rescue Errno::ECHILD
+            # All child processes are already gone.
+            @mutex.synchronize { @pids.clear }
+            break
+          end
+
+          # Process.wait reaps any child process, including ones spawned by
+          # libraries or application code (i.e. get_process_mem shelling out
+          # to ps). Only act on processes forked by the manager.
+          removed = @mutex.synchronize { @pids.delete(pid) }
+          next unless removed
 
           log_info("Sidekiq process #{pid} exited")
 
           # If there are not enough processes running, start a replacement one.
-          if @process_count > @pids.size
+          if @process_count > pids.size
             start_child_process!
           end
 
           set_program_name!
 
-          if @pids.empty?
+          if pids.empty?
             break
           end
         end

data/lib/sidekiq/process_manager.rb

@@ -33,6 +33,31 @@ module Sidekiq
         end
         @after_fork = nil
       end
+
+      # Parse a max memory value into a number of bytes. The value can be a plain
+      # number of bytes or a number suffixed with "m" for megabytes or "g" for
+      # gigabytes (case insensitive).
+      #
+      # @param value [String, nil] The value to parse.
+      # @return [Float, nil] The number of bytes or nil if the value is blank.
+      # @raise [ArgumentError] If the value cannot be parsed.
+      def parse_max_memory(value)
+        value = value.to_s.strip
+        return nil if value.empty?
+
+        matched = value.match(/\A(\d+(?:\.\d+)?)([mg]?)\z/i)
+        raise ArgumentError.new("Invalid max memory value: #{value.inspect}") unless matched
+
+        bytes = matched[1].to_f
+        case matched[2].downcase
+        when "m"
+          bytes *= 1024**2
+        when "g"
+          bytes *= 1024**3
+        end
+
+        bytes
+      end
     end
   end
 end

data/sidekiq-process_manager.gemspec

@@ -7,9 +7,16 @@ Gem::Specification.new do |spec|
   spec.email = ["bbdurand@gmail.com"]
 
   spec.summary = "Process manager for forking and monitoring multiple sidekiq processes."
+
   spec.homepage = "https://github.com/bdurand/sidekiq-process_manager"
   spec.license = "MIT"
 
+  spec.metadata = {
+    "homepage_uri" => spec.homepage,
+    "source_code_uri" => spec.homepage,
+    "changelog_uri" => "#{spec.homepage}/blob/main/CHANGELOG.md"
+  }
+
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   ignore_files = %w[
@@ -20,6 +27,7 @@ Gem::Specification.new do |spec|
     Rakefile
     gemfiles/
     spec/
+    test_app/
   ]
   spec.files = Dir.chdir(File.expand_path("..", __FILE__)) do
     `git ls-files -z`.split("\x0").reject { |f| ignore_files.any? { |path| f.start_with?(path) } }
@@ -33,6 +41,4 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "sidekiq", ">= 5.0"
   spec.add_dependency "get_process_mem"
-
-  spec.add_development_dependency "bundler"
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-process_manager
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.1.3
 platform: ruby
 authors:
 - Brian Durand
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-07-19 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
@@ -38,21 +37,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-description:
 email:
 - bbdurand@gmail.com
 executables:
@@ -73,8 +57,10 @@ files:
 homepage: https://github.com/bdurand/sidekiq-process_manager
 licenses:
 - MIT
-metadata: {}
-post_install_message:
+metadata:
+  homepage_uri: https://github.com/bdurand/sidekiq-process_manager
+  source_code_uri: https://github.com/bdurand/sidekiq-process_manager
+  changelog_uri: https://github.com/bdurand/sidekiq-process_manager/blob/main/CHANGELOG.md
 rdoc_options: []
 require_paths:
 - lib
@@ -89,8 +75,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.12
-signing_key:
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Process manager for forking and monitoring multiple sidekiq processes.
 test_files: []