process_bot 0.1.26 → 0.1.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e46c5f20791400dfc63138936340fc46e514d52947d2d2ba78cb208c521f442
-  data.tar.gz: 0f3ec322eb916178092eb5e7b19cab1a92421a23767fea310bf4c69319e72ca9
+  metadata.gz: e123dbde56775d5539bb91d48be68c1f83a09a2b001c6a61a1334aa3dba2b1ab
+  data.tar.gz: 34f9ff90352cad06e742ba69f7d4402d095678359caded93b20204f89b804a44
 SHA512:
-  metadata.gz: bd08e3680f9c436c00fed3c5ed760542cbbb4fba517021493f6d17de799ed4e781c86d652baa230f0433794a36f61861de8f52c846ff64dfda651b73ba42c3bc
-  data.tar.gz: 1b91173a14173732de83e7e00f47e95a10a0272768f5810f9ca789f12cb181fd3282bd4c0feab33a3c3f6b0074bcfac6bbb55ca753bb2e8df9c70f4cd7121464
+  metadata.gz: 8cbc29f75c5ffa3358f8614c11698fc4ac6548efa5a00a4d63a1004300707c80b395eb9229b877b06cc93c1d3b7e10987fa99d02f1942c67a133db277d9af49b
+  data.tar.gz: 8042fcbf747ba1162120b87e54d64bd1ac972615eaca4288865864ea76747e27d94b697b8de97d0a38ede453abbc9c30e5a54fdc3af32052f9ff466c82b9d311

data/AGENTS.md

@@ -9,7 +9,7 @@
 - Made graceful shutdown waiting optional and defaulted Capistrano to not wait.
 - Kept graceful handling synchronous and verified `bundle exec rspec`.
 - Enabled ProcessBot logging by default for Capistrano hooks (configurable via `process_bot_log`).
-- Always run RuboCop against changed or created Ruby files.
+- Always run RuboCop against changed or created Ruby files before pushing or opening a PR.
 - Added `graceful_no_wait` command and Capistrano task for non-blocking graceful shutdowns.
 - Always add or update tests for new/changed functionality, and run them.
 - Added coverage for graceful_no_wait and Capistrano wait defaults.

data/CHANGELOG.md

@@ -8,8 +8,8 @@
 - Add optional Sidekiq restart overlap and a new ProcessBot restart command.
 - Guard stop-related process scanning when subprocess PID/PGID is unavailable and fail stop loudly.
 - Wait briefly for subprocess PID assignment during stop; raise if PID is still missing so stop cannot silently succeed.
-
 - Require an active runner for custom stop commands to avoid constructing a fresh runner with no PID.
+- Buffer subprocess output by line before broadcasting it to control clients so Capistrano does not receive one-character log chunks.
 
 ## [0.1.0] - 2022-04-03
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    process_bot (0.1.26)
+    process_bot (0.1.28)
       knjrbfw (>= 0.0.116)
       pry
       rake
@@ -58,7 +58,7 @@ GEM
     rspec-expectations (3.13.5)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.13.0)
-    rspec-mocks (3.13.7)
+    rspec-mocks (3.13.8)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.13.0)
     rspec-support (3.13.7)

data/Rakefile

@@ -7,40 +7,6 @@ require "rubocop/rake_task"
 RSpec::Core::RakeTask.new(:spec)
 RuboCop::RakeTask.new
 
-def bump_patch_version(version_path)
-  version_content = File.read(version_path)
-  version_match = version_content.match(/VERSION = "(\d+)\.(\d+)\.(\d+)"\.freeze/)
-  raise "Could not find current version in #{version_path}" unless version_match
-
-  major = version_match[1].to_i
-  minor = version_match[2].to_i
-  patch = version_match[3].to_i + 1
-
-  new_version = "#{major}.#{minor}.#{patch}"
-  new_content = version_content.sub(version_match[0], "VERSION = \"#{new_version}\".freeze")
-  File.write(version_path, new_content)
-
-  new_version
-end
-
-namespace :release do
-  desc "Bump patch version, run bundle, commit version bump, build gem, and push gem"
-  task :patch do
-    version_path = "lib/process_bot/version.rb"
-    new_version = bump_patch_version(version_path)
-
-    puts "Bumped version to #{new_version}"
-
-    sh "bundle install"
-    sh "git add #{version_path}"
-    sh "git commit -m \"Bump version to #{new_version}\""
-    sh "bundle exec rake build"
-
-    gem_path = "pkg/process_bot-#{new_version}.gem"
-    raise "Expected gem file was not built: #{gem_path}" unless File.exist?(gem_path)
-
-    sh "gem push #{gem_path}"
-  end
-end
+Dir[File.expand_path("lib/tasks/**/*.rake", __dir__)].each { |f| load f }
 
 task default: %i[spec rubocop]

data/lib/process_bot/process/handlers/custom.rb

@@ -48,7 +48,14 @@ class ProcessBot::Process::Handlers::Custom
   end
 
   def stop(**_args)
+    runner = process.active_runner
+
+    unless runner
+      logger.logs "No active runner to stop"
+      return
+    end
+
     logger.logs "Stop related processes"
-    process.active_runner!.stop_related_processes
+    runner.stop_related_processes
   end
 end

data/lib/process_bot/process/runner.rb

@@ -3,6 +3,8 @@ require "knjrbfw"
 class ProcessBot::Process::Runner
   attr_reader :command, :exit_status, :handler_instance, :handler_name, :logger, :monitor, :options, :pid, :stop_time, :subprocess_pid
 
+  READ_CHUNK_SIZE = 4096
+
   def initialize(command:, handler_instance:, handler_name:, logger:, options:)
     @command = command
     @handler_instance = handler_instance
@@ -16,6 +18,17 @@ class ProcessBot::Process::Runner
     logger.log(output, type: type)
   end
 
+  def stream_output(io, type:)
+    buffer = +""
+
+    loop do
+      buffer << io.readpartial(READ_CHUNK_SIZE)
+      flush_complete_lines(type: type, buffer: buffer)
+    end
+  rescue EOFError, Errno::EIO
+    flush_remaining_output(type: type, buffer: buffer)
+  end
+
   def running?
     !stop_time
   end
@@ -31,13 +44,7 @@ class ProcessBot::Process::Runner
       logger.logs "Command running with PID #{pid}: #{command}"
 
       stdout_reader_thread = Thread.new do
-        stdout.each_char do |chunk|
-          monitor.synchronize do
-            output(type: :stdout, output: chunk)
-          end
-        end
-      rescue Errno::EIO
-        # Process done
+        stream_output(stdout, type: :stdout)
       ensure
         status = Process::Status.wait(subprocess_pid, 0)
 
@@ -46,11 +53,7 @@ class ProcessBot::Process::Runner
       end
 
       stderr_reader_thread = Thread.new do
-        stderr_reader.each_char do |chunk|
-          monitor.synchronize do
-            output(type: :stderr, output: chunk)
-          end
-        end
+        stream_output(stderr_reader, type: :stderr)
       end
 
       find_sidekiq_pid if handler_name == "sidekiq"
@@ -182,4 +185,37 @@ class ProcessBot::Process::Runner
       break
     end
   end
+
+  def flush_complete_lines(type:, buffer:)
+    loop do
+      separator_index = next_separator_index(buffer)
+      break unless separator_index
+
+      monitor.synchronize do
+        output(type: type, output: buffer.slice!(0, separator_index + 1))
+      end
+    end
+
+    return if buffer.bytesize < READ_CHUNK_SIZE
+
+    monitor.synchronize do
+      output(type: type, output: buffer.dup)
+    end
+
+    buffer.clear
+  end
+
+  def flush_remaining_output(type:, buffer:)
+    return if buffer.empty?
+
+    monitor.synchronize do
+      output(type: type, output: buffer.dup)
+    end
+
+    buffer.clear
+  end
+
+  def next_separator_index(buffer)
+    buffer.index(/[\r\n]/)
+  end
 end

data/lib/process_bot/process.rb

@@ -3,7 +3,7 @@ require "json"
 require "monitor"
 require "string-cases"
 
-class ProcessBot::Process
+class ProcessBot::Process # rubocop:disable Metrics/ClassLength
   extend Forwardable
 
   def_delegator :handler_instance, :graceful
@@ -131,8 +131,15 @@ class ProcessBot::Process
   def send_control_command(command, **command_options)
     logger.logs "Sending #{command} command"
     response = client.send_command(command: command, options: options.options.merge(command_options))
-    raise "No response from ProcessBot while sending #{command}" if response == :nil
+
+    if response == :nil
+      handle_missing_control_command_response(command)
+      return if options[:ignore_no_process_bot]
+
+      raise "No response from ProcessBot while sending #{command}"
+    end
   rescue Errno::ECONNREFUSED => e
+    handle_missing_control_command_response(command)
     raise e unless options[:ignore_no_process_bot]
   end
 
@@ -274,6 +281,65 @@ class ProcessBot::Process
     start_runner_instance
   end
 
+  def handle_missing_control_command_response(command)
+    return unless command == "stop"
+
+    matching_processes = matching_process_bot_processes
+    log_missing_control_response_diagnostics(matching_processes)
+    force_stop_process_bot_if_configured(matching_processes)
+  end
+
+  def log_missing_control_response_diagnostics(matching_processes)
+    logger.logs "Control command response missing; attempting diagnostics for application=#{options[:application].inspect} id=#{options[:id].inspect}"
+    logger.logs "Matching process_bot lines:\n#{matching_process_bot_processes_text(matching_processes)}"
+  end
+
+  def matching_process_bot_processes_text(lines)
+    return "(none)" if lines.empty?
+
+    lines.join("\n")
+  end
+
+  def matching_process_bot_processes
+    ps_output = Knj::Os.shellcmd("ps -eo pid,args")
+
+    ps_output
+      .to_s
+      .split("\n")
+      .select { |line| process_bot_process_line_matches?(line) }
+  end
+
+  def process_bot_process_line_matches?(line)
+    line.include?("ProcessBot {") &&
+      line.include?("\"application\":\"#{options[:application]}\"") &&
+      line.include?("\"id\":\"#{options[:id]}\"")
+  end
+
+  def force_stop_process_bot_if_configured(matching_processes)
+    return unless truthy_option?(:force_stop_on_no_response)
+
+    matching_processes.each do |line|
+      pid = line.strip.split(/\s+/, 2).first
+      next unless pid&.match?(/\A\d+\z/)
+
+      logger.logs "Force-stopping unresponsive process_bot PID #{pid}"
+      Process.kill("TERM", Integer(pid, 10))
+    rescue Errno::ESRCH
+      logger.logs "Process bot PID #{pid} already gone during force stop"
+    end
+  end
+
+  def truthy_option?(key)
+    value = options[key]
+    return false if value.nil?
+    return value if value == true || value == false
+
+    normalized = value.to_s.strip.downcase
+    return false if normalized == "false" || normalized == "0" || normalized == ""
+
+    true
+  end
+
 private
 
   attr_reader :current_runner_instance, :runner_events, :runner_monitor

data/lib/process_bot/version.rb

@@ -1,3 +1,3 @@
 module ProcessBot
-  VERSION = "0.1.26".freeze
+  VERSION = "0.1.28".freeze
 end

data/lib/tasks/release.rake

@@ -0,0 +1,177 @@
+require "English"
+require "fileutils"
+require "pathname"
+require "rubygems/version"
+require "shellwords"
+
+class ProcessBotRubygemsRelease
+  VERSION_FILE = Pathname.new(File.expand_path("../process_bot/version.rb", __dir__)) unless const_defined?(:VERSION_FILE)
+
+  def call
+    ensure_clean_worktree!
+    checkout_master!
+    fetch!
+    merge!
+
+    next_version = determine_next_version
+
+    bump_version!(next_version)
+    commit!(next_version)
+    push!
+    gem_file = build_gem!(next_version)
+    push_gem!(gem_file)
+    delete_gem_file!(gem_file)
+  rescue StandardError
+    warn "Release failed."
+    raise
+  end
+
+private
+
+  def ensure_clean_worktree!
+    dirty_entries = git_status_lines.grep_v(%r{\A\?\? process_bot-[^/]+\.gem\z})
+    return if dirty_entries.empty?
+
+    raise "Working tree must be clean before releasing:\n#{dirty_entries.join("\n")}"
+  end
+
+  def checkout_master!
+    run!("git", "checkout", "master")
+  end
+
+  def fetch!
+    run!("git", "fetch", remote_name)
+  end
+
+  def merge!
+    run!("git", "merge", "--ff-only", "#{remote_name}/master")
+  end
+
+  def determine_next_version
+    requested_version || bumped_version
+  end
+
+  def requested_version
+    version = ENV["VERSION"]&.strip
+    return if version.to_s.empty?
+
+    Gem::Version.new(version)
+    version
+  end
+
+  def bumped_version
+    major, minor, patch = version_segments
+
+    case bump_type
+    when "major"
+      format_version(major + 1, 0, 0)
+    when "minor"
+      format_version(major, minor + 1, 0)
+    when "patch"
+      format_version(major, minor, patch + 1)
+    else
+      raise "Unsupported BUMP=#{bump_type.inspect}. Use patch, minor, major, or VERSION=x.y.z."
+    end
+  end
+
+  def version_segments
+    @version_segments ||= begin
+      segments = Gem::Version.new(current_version).segments
+      segments << 0 while segments.length < 3
+      segments
+    end
+  end
+
+  def current_version
+    @current_version ||= VERSION_FILE.read[/VERSION = "([^"]+)"\.freeze/, 1] || raise("Could not find current version")
+  end
+
+  def format_version(major, minor, patch)
+    [major, minor, patch].join(".")
+  end
+
+  def bump_version!(next_version)
+    raise "Next version must differ from current version" if next_version == current_version
+
+    VERSION_FILE.write(
+      VERSION_FILE.read.sub(
+        /VERSION = "[^"]+"\.freeze/,
+        %(VERSION = "#{next_version}".freeze)
+      )
+    )
+
+    run!("git", "add", VERSION_FILE.to_s)
+  end
+
+  def commit!(next_version)
+    run!("git", "commit", "-m", "Release #{next_version}")
+  end
+
+  def push!
+    run!("git", "push", remote_name, "master")
+  end
+
+  def build_gem!(next_version)
+    gem_file = "process_bot-#{next_version}.gem"
+    run!("gem", "build", "process_bot.gemspec")
+    gem_file
+  end
+
+  def push_gem!(gem_file)
+    run!("gem", "push", gem_file)
+  end
+
+  def delete_gem_file!(gem_file)
+    FileUtils.rm_f(gem_file)
+  end
+
+  def git_status_lines
+    capture!("git", "status", "--porcelain").split("\n").reject(&:empty?)
+  end
+
+  def bump_type
+    ENV.fetch("BUMP", "patch")
+  end
+
+  def remote_name
+    ENV.fetch("REMOTE", "origin")
+  end
+
+  def capture!(*command)
+    output = `#{command.map { |part| Shellwords.escape(part) }.join(" ")}`
+    raise "Command failed: #{command.join(' ')}" unless $CHILD_STATUS&.success?
+
+    output
+  end
+
+  def run!(*command)
+    return if system(*command)
+
+    raise "Command failed: #{command.join(' ')}"
+  end
+end
+
+namespace :release do
+  desc "Release a patch version from master by fetching, fast-forward merging, bumping version, pushing, and publishing"
+  task :patch do
+    ENV["BUMP"] = "patch"
+    ProcessBotRubygemsRelease.new.call
+  end
+
+  desc "Release a minor version from master by fetching, fast-forward merging, bumping version, pushing, and publishing"
+  task :minor do
+    ENV["BUMP"] = "minor"
+    ProcessBotRubygemsRelease.new.call
+  end
+
+  desc "Release a major version from master by fetching, fast-forward merging, bumping version, pushing, and publishing"
+  task :major do
+    ENV["BUMP"] = "major"
+    ProcessBotRubygemsRelease.new.call
+  end
+
+  desc "Release the gem from master by fetching, fast-forward merging, bumping version, pushing, and publishing"
+  task :rubygems do
+    ProcessBotRubygemsRelease.new.call
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: process_bot
 version: !ruby/object:Gem::Version
-  version: 0.1.26
+  version: 0.1.28
 platform: ruby
 authors:
 - kaspernj
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-02-12 00:00:00.000000000 Z
+date: 2026-04-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: knjrbfw
@@ -175,6 +175,7 @@ files:
 - lib/process_bot/process/runner.rb
 - lib/process_bot/process/runner_instance.rb
 - lib/process_bot/version.rb
+- lib/tasks/release.rake
 - peak_flow.yml
 - process_bot.gemspec
 homepage: https://github.com/kaspernj/process_bot