async-container-supervisor 0.8.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39abccaf400a7b793d8f0094e32ccee9a4a9fdad6c6f570e361cace376ebd611
-  data.tar.gz: 2f135ee3b0979a16a899a07c760e8aeb46f2474635f9f2862c4eef43b7744961
+  metadata.gz: b997fac3e6c645d7740f0099a3543d27d983a86057a4cde23a85254d30a2d32f
+  data.tar.gz: 83f0ce708ade60a56158e615d6222788444bb2dfbc980cd6438a93dc6ef3c18b
 SHA512:
-  metadata.gz: ffe7ddc8855501a0c30e35e925596a2aaf262d34a373608e16882295603bb1137f30be80f533adcfc480c957208c96e42907006d0564270bf209763b7d3d81a5
-  data.tar.gz: 7b71f2cdcf3f75973fffdaf676f430e34270a6b1be3b684439e50f202854bffddf9ca8d4983a441d9e4fb01319414e80343e9f2a78e4698e964b01f94c71c58e
+  metadata.gz: f6baf3ac944b425114dcb952da846b73a35fbf183ddb078c4b273015b1951a7a4658b2eba72088994fee6a4df81ff5f7c9faf79ccc4cae1433ec7a4080e8c362
+  data.tar.gz: 2069afe1a540bc4733d7a5e6ae0c4d0270787bd500a940b6131c31427b6f21f97d0e29911eda516887e745b33d4a37210e1f935089a07af62143620e8800b2e7

data/context/memory-monitor.md

@@ -28,7 +28,7 @@ service "supervisor" do
 			Async::Container::Supervisor::MemoryMonitor.new(
 				# Check worker memory every 10 seconds:
 				interval: 10,
-
+				
 				# Restart workers exceeding 500MB:
 				maximum_size_limit: 1024 * 1024 * 500
 			)

data/lib/async/container/supervisor/connection.rb

@@ -4,6 +4,7 @@
 # Copyright, 2025, by Samuel Williams.
 
 require "json"
+require "async"
 
 module Async
 	module Container
@@ -79,8 +80,8 @@ module Async
 					# Iterate over all responses from the call.
 					#
 					# @yields {|response| ...} Each response from the queue.
-					def each(&block)
-						while response = self.pop
+					def each(timeout: nil, &block)
+						while response = self.pop(timeout: timeout)
 							yield response
 						end
 					end
@@ -146,20 +147,28 @@ module Async
 					def self.dispatch(connection, target, id, message)
 						Async do
 							call = self.new(connection, id, message)
+							# Track the call in the connection's calls hash:
 							connection.calls[id] = call
 							
+							# Dispatch the call to the target (synchronously):
 							target.dispatch(call)
 							
+							# Stream responses back to the connection (asynchronously):
 							while response = call.pop
 								connection.write(id: id, **response)
 							end
 						ensure
-							# If the queue is closed, we don't need to send a finished message.
+							# Ensure the call is removed from the connection's calls hash, otherwise it will leak:
+							connection.calls.delete(id)
+							
+							# If the queue is closed, we don't need to send a finished message:
 							unless call.closed?
-								connection.write(id: id, finished: true)
+								# Ensure the call is closed, to prevent messages being buffered:
+								call.close
+								
+								# If the above write failed, this is likely to fail too, and we can safely ignore it.
+								connection.write(id: id, finished: true) rescue nil
 							end
-							
-							connection.calls.delete(id)
 						end
 					end
 					
@@ -172,7 +181,7 @@ module Async
 					# @parameter message [Hash] The call message/parameters.
 					# @yields {|response| ...} Each intermediate response if block given.
 					# @returns [Hash, Array] The final response or array of intermediate responses.
-					def self.call(connection, **message, &block)
+					def self.call(connection, timeout: nil, **message, &block)
 						id = connection.next_id
 						call = self.new(connection, id, message)
 						
@@ -181,11 +190,11 @@ module Async
 							connection.write(id: id, **message)
 							
 							if block_given?
-								call.each(&block)
+								call.each(timeout: timeout, &block)
 							else
 								intermediate = nil
 								
-								while response = call.pop
+								while response = call.pop(timeout: timeout)
 									if response.delete(:finished)
 										if intermediate
 											if response.any?
@@ -204,7 +213,11 @@ module Async
 								end
 							end
 						ensure
+							# Ensure the call is removed from the connection's calls hash, otherwise it will leak:
 							connection.calls.delete(id)
+							
+							# Ensure the call is closed, so that `Call#pop` will return `nil`.
+							call.close
 						end
 					end
 				end
@@ -244,22 +257,6 @@ module Async
 					@stream.flush
 				end
 				
-				# Make a synchronous call and wait for a single response.
-				#
-				# @parameter timeout [Numeric, nil] Optional timeout for the call.
-				# @parameter message [Hash] The call message.
-				# @returns [Hash] The response.
-				def call(timeout: nil, **message)
-					id = next_id
-					calls[id] = ::Thread::Queue.new
-					
-					write(id: id, **message)
-					
-					return calls[id].pop(timeout: timeout)
-				ensure
-					calls.delete(id)
-				end
-				
 				# Read a message from the connection stream.
 				#
 				# @returns [Hash, nil] The parsed message or nil if stream is closed.
@@ -289,16 +286,19 @@ module Async
 				#
 				# @parameter target [Dispatchable] The target to dispatch calls to.
 				def run(target)
+					# Process incoming messages from the connection:
 					self.each do |message|
+						# If the message has an ID, it is a response to a call:
 						if id = message.delete(:id)
+							# Find the call in the connection's calls hash:
 							if call = @calls[id]
-								# Response to a call:
+								# Enqueue the response for the call:
 								call.push(**message)
 							elsif message.key?(:do)
-								# Incoming call:
+								# Otherwise, if we couldn't find an existing call, it must be a new call:
 								Call.dispatch(self, target, id, message)
 							else
-								# Likely a response to a timed-out call, ignore it:
+								# Finally, if none of the above, it is likely a response to a timed-out call, so ignore it:
 								Console.debug(self, "Ignoring message:", message)
 							end
 						else

data/lib/async/container/supervisor/loop.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Async
+	module Container
+		module Supervisor
+			# A helper for running loops at aligned intervals.
+			module Loop
+				# A robust loop that executes a block at aligned intervals.
+				#
+				# The alignment is modulo the current clock in seconds.
+				#
+				# If an error occurs during the execution of the block, it is logged and the loop continues.
+				#
+				# @parameter interval [Integer] The interval in seconds between executions of the block.
+				def self.run(interval: 60, &block)
+					while true
+						# Compute the wait time to the next interval:
+						wait = interval - (Time.now.to_f % interval)
+						if wait.positive?
+							# Sleep until the next interval boundary:
+							sleep(wait)
+						end
+						
+						begin
+							yield
+						rescue => error
+							Console.error(self, "Loop error:", error)
+						end
+					end
+				end
+			end
+			
+			private_constant :Loop
+		end
+	end
+end

data/lib/async/container/supervisor/memory_monitor.rb

@@ -6,6 +6,8 @@
 require "memory/leak/cluster"
 require "set"
 
+require_relative "loop"
+
 module Async
 	module Container
 		module Supervisor
@@ -13,14 +15,12 @@ module Async
 			#
 			# Uses the `memory` gem to track process memory and detect leaks.
 			class MemoryMonitor
-				MEMORY_SAMPLE = {duration: 30, timeout: 30*4}
-				
 				# Create a new memory monitor.
 				#
 				# @parameter interval [Integer] The interval at which to check for memory leaks.
 				# @parameter total_size_limit [Integer] The total size limit of all processes, or nil for no limit.
 				# @parameter options [Hash] Options to pass to the cluster when adding processes.
-				def initialize(interval: 10, total_size_limit: nil, memory_sample: MEMORY_SAMPLE, **options)
+				def initialize(interval: 10, total_size_limit: nil, memory_sample: false, **options)
 					@interval = interval
 					@cluster = Memory::Leak::Cluster.new(total_size_limit: total_size_limit)
 					
@@ -32,6 +32,9 @@ module Async
 					@processes = Hash.new{|hash, key| hash[key] = Set.new.compare_by_identity}
 				end
 				
+				# @attribute [Memory::Leak::Cluster] The cluster of processes being monitored.
+				attr_reader :cluster
+				
 				# Add a process to the memory monitor. You may override this to control how processes are added to the cluster.
 				#
 				# @parameter process_id [Integer] The process ID to add.
@@ -98,8 +101,14 @@ module Async
 					end
 					
 					# Kill the process gently:
-					Console.info(self, "Killing process!", child: {process_id: process_id})
-					Process.kill(:INT, process_id)
+					begin
+						Console.info(self, "Killing process!", child: {process_id: process_id})
+						Process.kill(:INT, process_id)
+					rescue Errno::ESRCH
+						# No such process - he's dead Jim.
+					rescue => error
+						Console.warn(self, "Failed to kill process!", child: {process_id: process_id}, exception: error)
+					end
 					
 					true
 				end
@@ -109,14 +118,17 @@ module Async
 				# @returns [Async::Task] The task that is running the memory monitor.
 				def run
 					Async do
-						while true
+						Loop.run(interval: @interval) do
 							# This block must return true if the process was killed.
 							@cluster.check! do |process_id, monitor|
 								Console.error(self, "Memory leak detected!", child: {process_id: process_id}, monitor: monitor)
-								memory_leak_detected(process_id, monitor)
+								
+								begin
+									memory_leak_detected(process_id, monitor)
+								rescue => error
+									Console.error(self, "Failed to handle memory leak!", child: {process_id: process_id}, exception: error)
+								end
 							end
-							
-							sleep(@interval)
 						end
 					end
 				end

data/lib/async/container/supervisor/process_monitor.rb

@@ -4,6 +4,9 @@
 # Copyright, 2025, by Samuel Williams.
 
 require "process/metrics"
+require_relative "loop"
+
+require_relative "loop"
 
 module Async
 	module Container
@@ -15,14 +18,14 @@ module Async
 			# by tracking the parent process ID (ppid), which is more efficient than tracking
 			# individual processes.
 			class ProcessMonitor
-			# Create a new process monitor.
-			#
-			# @parameter interval [Integer] The interval in seconds at which to log process metrics.
-			# @parameter ppid [Integer] The parent process ID to monitor. If nil, uses the current process to capture its children.
-			def initialize(interval: 60, ppid: nil)
-				@interval = interval
-				@ppid = ppid || Process.ppid
-			end
+				# Create a new process monitor.
+				#
+				# @parameter interval [Integer] The interval in seconds at which to log process metrics.
+				# @parameter ppid [Integer] The parent process ID to monitor. If nil, uses the current process to capture its children.
+				def initialize(interval: 60, ppid: nil)
+					@interval = interval
+					@ppid = ppid || Process.ppid
+				end
 				
 				# @attribute [Integer] The parent process ID being monitored.
 				attr :ppid
@@ -68,21 +71,19 @@ module Async
 				# Periodically captures and logs process metrics for the entire process tree.
 				#
 				# @returns [Async::Task] The task that is running the process monitor.
-			def run
-				Async do
-					while true
-						metrics = self.metrics
-						
-						# Log each process individually for better searchability in log platforms:
-						metrics.each do |process_id, general|
-							Console.info(self, "Process metrics captured.", general: general)
+				def run
+					Async do
+						Loop.run(interval: @interval) do
+							metrics = self.metrics
+							
+							# Log each process individually for better searchability in log platforms:
+							metrics.each do |process_id, general|
+								Console.info(self, "Process metrics captured.", general: general)
+							end
 						end
-						
-						sleep(@interval)
 					end
 				end
 			end
-			end
 		end
 	end
 end

data/lib/async/container/supervisor/server.rb

@@ -39,7 +39,9 @@ module Async
 				# @parameter call [Connection::Call] The registration call.
 				# @parameter call[:state] [Hash] The worker state to merge (e.g. process_id).
 				def do_register(call)
-					call.connection.state.merge!(call.message[:state])
+					if state = call.message[:state]
+						call.connection.state.merge!(state)
+					end
 					
 					connection_id = SecureRandom.uuid
 					call.connection.state[:connection_id] = connection_id
@@ -52,7 +54,7 @@ module Async
 						Console.error(self, "Error while registering process!", monitor: monitor, exception: error)
 					end
 				ensure
-					call.finish
+					call.finish(connection_id: connection_id)
 				end
 				
 				# Forward an operation to a worker connection.

data/lib/async/container/supervisor/version.rb

@@ -9,7 +9,7 @@ module Async
 	module Container
 		# @namespace
 		module Supervisor
-			VERSION = "0.8.0"
+			VERSION = "0.9.1"
 		end
 	end
 end

data/lib/async/container/supervisor/worker.rb

@@ -25,25 +25,32 @@ module Async
 				#
 				# @parameter state [Hash] The worker state to register with the supervisor.
 				# @parameter endpoint [IO::Endpoint] The supervisor endpoint to connect to.
-				def initialize(state, endpoint: Supervisor.endpoint)
+				def initialize(state = nil, endpoint: Supervisor.endpoint)
+					super(endpoint: endpoint)
 					@state = state
-					@endpoint = endpoint
 				end
 				
 				include Dispatchable
 				
-				private def dump(call)
+				private def dump(call, buffer: true)
 					if path = call[:path]
 						File.open(path, "w") do |file|
 							yield file
 						end
 						
 						call.finish(path: path)
-					else
+					elsif buffer
 						buffer = StringIO.new
 						yield buffer
 						
-						call.finish(data: buffer.string)
+						if message = call[:log]
+							Console.info(self, message, data: buffer.string)
+							call.finish
+						else
+							call.finish(data: buffer.string)
+						end
+					else
+						call.fail(error: {message: "Buffered output not supported!"})
 					end
 				end
 				
@@ -69,7 +76,7 @@ module Async
 				def do_memory_dump(call)
 					require "objspace"
 					
-					dump(call) do |file|
+					dump(call, buffer: false) do |file|
 						ObjectSpace.dump_all(output: file)
 					end
 				end
@@ -109,13 +116,9 @@ module Async
 					
 					report = sampler.report
 					
-					# This is a temporary log to help with debugging:
-					buffer = StringIO.new
-					report.print(buffer)
-					Console.info(self, "Memory sample completed.", report: buffer.string)
-					
-					# Generate a report focused on retained objects (likely leaks):
-					call.finish(report: report)
+					dump(call) do |file|
+						file.puts(report.to_s)
+					end
 				ensure
 					GC.start
 				end
@@ -164,6 +167,7 @@ module Async
 					
 					# Register the worker with the supervisor:
 					connection.call(do: :register, state: @state)
+					# We ignore the response (it contains the `connection_id`).
 				end
 			end
 		end

data/readme.md

@@ -26,6 +26,17 @@ Please see the [project documentation](https://socketry.github.io/async-containe
 
 Please see the [project releases](https://socketry.github.io/async-container-supervisor/releases/index) for all releases.
 
+### v0.9.1
+
+  - Close `Call` queue if asynchronous call fails during dispatch - further messages will fail with `ClosedQueueError`.
+
+### v0.9.0
+
+  - Better handling of write failures in `Connection::Call.dispatch`, ensuring we don't leak calls.
+  - Robust monitor loop handling - restart on failure, and align loop iterations.
+  - Disable memory sampler by default and use text output format.
+      - Introduce support for redirecting dump output to logs.
+
 ### v0.8.0
 
   - Add `Async::Container::Supervisor::ProcessMonitor` for logging CPU and memory metrics periodically.

data/releases.md

@@ -1,5 +1,16 @@
 # Releases
 
+## v0.9.1
+
+  - Close `Call` queue if asynchronous call fails during dispatch - further messages will fail with `ClosedQueueError`.
+
+## v0.9.0
+
+  - Better handling of write failures in `Connection::Call.dispatch`, ensuring we don't leak calls.
+  - Robust monitor loop handling - restart on failure, and align loop iterations.
+  - Disable memory sampler by default and use text output format.
+      - Introduce support for redirecting dump output to logs.
+
 ## v0.8.0
 
   - Add `Async::Container::Supervisor::ProcessMonitor` for logging CPU and memory metrics periodically.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: async-container-supervisor
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.1
 platform: ruby
 authors:
 - Samuel Williams
@@ -123,6 +123,7 @@ files:
 - lib/async/container/supervisor/dispatchable.rb
 - lib/async/container/supervisor/endpoint.rb
 - lib/async/container/supervisor/environment.rb
+- lib/async/container/supervisor/loop.rb
 - lib/async/container/supervisor/memory_monitor.rb
 - lib/async/container/supervisor/process_monitor.rb
 - lib/async/container/supervisor/server.rb
@@ -153,7 +154,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.2
+rubygems_version: 3.6.9
 specification_version: 4
 summary: A supervisor for managing multiple container processes.
 test_files: []