Rename to async-service-supervisor.

Author: samuel-williams-shopify

async-container-supervisor.gemspec async-service-supervisor.gemspecasync-container-supervisor.gemspec renamed to async-service-supervisor.gemspec

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require_relative "lib/async/container/supervisor/version"
+require_relative "lib/async/service/supervisor/version"
 
 Gem::Specification.new do |spec|
-	spec.name = "async-container-supervisor"
-	spec.version = Async::Container::Supervisor::VERSION
+	spec.name = "async-service-supervisor"
+	spec.version = Async::Service::Supervisor::VERSION
 
 	spec.summary = "A supervisor for managing multiple container processes."
 	spec.authors = ["Samuel Williams"]
@@ -13,18 +13,19 @@ Gem::Specification.new do |spec|
 	spec.cert_chain  = ["release.cert"]
 	spec.signing_key = File.expand_path("~/.gem/release.pem")
 
-	spec.homepage = "https://github.com/socketry/async-container-supervisor"
+	spec.homepage = "https://github.com/socketry/async-service-supervisor"
 
 	spec.metadata = {
-		"documentation_uri" => "https://socketry.github.io/async-container-supervisor/",
-		"source_code_uri" => "https://github.com/socketry/async-container-supervisor.git",
+		"documentation_uri" => "https://socketry.github.io/async-service-supervisor/",
+		"source_code_uri" => "https://github.com/socketry/async-service-supervisor.git",
 	}
 
 	spec.files = Dir.glob(["{bake,context,lib}/**/*", "*.md"], File::FNM_DOTMATCH, base: __dir__)
 
 	spec.required_ruby_version = ">= 3.2"
 
-	spec.add_dependency "async-service"
+	spec.add_dependency "async-bus"
+	spec.add_dependency "async-service", "~> 0.15"
 	spec.add_dependency "io-endpoint"
 	spec.add_dependency "memory", "~> 0.7"
 	spec.add_dependency "memory-leak", "~> 0.5"

bake/async/container/supervisor.rb bake/async/service/supervisor.rbbake/async/container/supervisor.rb renamed to bake/async/service/supervisor.rb

@@ -6,26 +6,29 @@
 def initialize(...)
 	super
 
-	require "async/container/supervisor"
+	require "async/service/supervisor"
 end
 
 # Restart the container, typically causing it to exit (the parent process should then restart it).
 def restart
 	client do |connection|
-		connection.call(do: :restart)
+		supervisor = connection[:supervisor]
+		supervisor.restart
 	end
 end
 
 # Reload the services gracefully, allowing them to reconfigure without dropping connections.
 def reload
 	client do |connection|
-		connection.call(do: :restart, signal: :HUP)
+		supervisor = connection[:supervisor]
+		supervisor.restart(signal: :HUP)
 	end
 end
 
 def status
 	client do |connection|
-		connection.call(do: :status)
+		supervisor = connection[:supervisor]
+		supervisor.status
 	end
 end
 
@@ -35,27 +38,25 @@ def status
 # that are retained after garbage collection.
 #
 # @parameter duration [Integer] The duration in seconds to sample for (default: 10).
-# @parameter connection_id [String] The connection ID to target a specific worker.
+# @parameter connection_id [Integer] The connection ID to target a specific worker.
 def memory_sample(duration: 10, connection_id:)
 	client do |connection|
 		Console.info(self, "Sampling memory from worker...", duration: duration, connection_id: connection_id)
 
-		# Build the operation request:
-		operation = {do: :memory_sample, duration: duration}
-		
-		# Use the forward operation to proxy the request to a worker:
-		return connection.call(do: :forward, operation: operation, connection_id: connection_id)
+		supervisor = connection[:supervisor]
+		worker = supervisor[connection_id]
+		return worker.memory_sample(duration: duration)
 	end
 end
 
 private
 
 def endpoint
-	Async::Container::Supervisor.endpoint
+	Async::Service::Supervisor.endpoint
 end
 
 def client(&block)
 	Sync do
-		Async::Container::Supervisor::Client.new(endpoint: self.endpoint).connect(&block)
+		Async::Service::Supervisor::Client.new(endpoint: self.endpoint).connect(&block)
 	end
 end

context/getting-started.md

@@ -1,23 +1,23 @@
 # Getting Started
 
-This guide explains how to get started with `async-container-supervisor` to supervise and monitor worker processes in your Ruby applications.
+This guide explains how to get started with `async-service-supervisor` to supervise and monitor worker processes in your Ruby applications.
 
 ## Installation
 
 Add the gem to your project:
 
 ```bash
-$ bundle add async-container-supervisor
+$ bundle add async-service-supervisor
 ```
 
 ## Core Concepts
 
-`async-container-supervisor` provides a robust process supervision system built on top of {ruby Async::Service::Generic}. The key components are:
+`async-service-supervisor` provides a robust process supervision system built on top of {ruby Async::Service::Generic}. The key components are:
 
-- {ruby Async::Container::Supervisor::Environment}: An environment mixin that sets up a supervisor service in your application.
-- {ruby Async::Container::Supervisor::Supervised}: An environment mixin that enables workers to connect to and be supervised by the supervisor.
-- {ruby Async::Container::Supervisor::Server}: The server that handles communication with workers and performs monitoring.
-- {ruby Async::Container::Supervisor::Worker}: A client that connects workers to the supervisor for health monitoring and diagnostics.
+- {ruby Async::Service::Supervisor::Environment}: An environment mixin that sets up a supervisor service in your application.
+- {ruby Async::Service::Supervisor::Supervised}: An environment mixin that enables workers to connect to and be supervised by the supervisor.
+- {ruby Async::Service::Supervisor::Server}: The server that handles communication with workers and performs monitoring.
+- {ruby Async::Service::Supervisor::Worker}: A client that connects workers to the supervisor for health monitoring and diagnostics.
 
 ### Process Architecture
 
@@ -27,7 +27,7 @@ The supervisor operates as a multi-process architecture with three layers:
 graph TD
     Controller[Async::Container::Controller<br/>Root Process]
     
-    Controller -->|spawns & manages| Supervisor[Supervisor Process<br/>async-container-supervisor]
+    Controller -->|spawns & manages| Supervisor[Supervisor Process<br/>async-service-supervisor]
     Controller -->|spawns & manages| Worker1[Worker Process 1]
     Controller -->|spawns & manages| Worker2[Worker Process 2]
     Controller -->|spawns & manages| WorkerN[Worker Process N...]
@@ -51,18 +51,19 @@ Create a service configuration file (e.g., `service.rb`):
 #!/usr/bin/env async-service
 # frozen_string_literal: true
 
-require "async/container/supervisor"
+require "async/service/supervisor"
 
 class MyWorkerService < Async::Service::Generic
 	def setup(container)
 		super
 
 		container.run(name: self.class.name, count: 4, restart: true) do |instance|
 			Async do
-				# Connect to the supervisor if available:
-				if @environment.implements?(Async::Container::Supervisor::Supervised)
-					@evaluator.make_supervised_worker(instance).run
-				end
+				# Get the environment evaluator:
+				evaluator = self.environment.evaluator
+				
+				# Prepare the instance (connects to supervisor if available):
+				evaluator.prepare!(instance)
 
 				# Mark the worker as ready:
 				instance.ready!
@@ -85,12 +86,12 @@ service "worker" do
 	service_class MyWorkerService
 
 	# Enable supervision for this service:
-	include Async::Container::Supervisor::Supervised
+	include Async::Service::Supervisor::Supervised
 end
 
 # Define the supervisor service:
 service "supervisor" do
-	include Async::Container::Supervisor::Environment
+	include Async::Service::Supervisor::Environment
 end
 ```
 
@@ -119,17 +120,17 @@ For example, to add monitoring:
 
 ```ruby
 service "supervisor" do
-	include Async::Container::Supervisor::Environment
+	include Async::Service::Supervisor::Environment
 
 	monitors do
 		[
 			# Log process metrics for observability:
-			Async::Container::Supervisor::ProcessMonitor.new(
+			Async::Service::Supervisor::ProcessMonitor.new(
 				interval: 60
 			),
 
 			# Restart workers exceeding memory limits:
-			Async::Container::Supervisor::MemoryMonitor.new(
+			Async::Service::Supervisor::MemoryMonitor.new(
 				interval: 10,
 				maximum_size_limit: 1024 * 1024 * 500  # 500MB limit per process
 			)
@@ -138,7 +139,7 @@ service "supervisor" do
 end
 ```
 
-See the {ruby Async::Container::Supervisor::MemoryMonitor Memory Monitor} and {ruby Async::Container::Supervisor::ProcessMonitor Process Monitor} guides for detailed configuration options and best practices.
+See the {ruby Async::Service::Supervisor::MemoryMonitor Memory Monitor} and {ruby Async::Service::Supervisor::ProcessMonitor Process Monitor} guides for detailed configuration options and best practices.
 
 ### Collecting Diagnostics
 

context/index.yaml

@@ -3,18 +3,18 @@
 ---
 description: A supervisor for managing multiple container processes.
 metadata:
-  documentation_uri: https://socketry.github.io/async-container-supervisor/
-  source_code_uri: https://github.com/socketry/async-container-supervisor.git
+  documentation_uri: https://socketry.github.io/async-service-supervisor/
+  source_code_uri: https://github.com/socketry/async-service-supervisor.git
 files:
 - path: getting-started.md
   title: Getting Started
-  description: This guide explains how to get started with `async-container-supervisor`
+  description: This guide explains how to get started with `async-service-supervisor`
     to supervise and monitor worker processes in your Ruby applications.
 - path: memory-monitor.md
   title: Memory Monitor
-  description: This guide explains how to use the <code class="language-ruby">Async::Container::Supervisor::MemoryMonitor</code>
+  description: This guide explains how to use the <code class="language-ruby">Async::Service::Supervisor::MemoryMonitor</code>
     to detect and restart workers that exceed memory limits or develop memory leaks.
 - path: process-monitor.md
   title: Process Monitor
-  description: This guide explains how to use the <code class="language-ruby">Async::Container::Supervisor::ProcessMonitor</code>
+  description: This guide explains how to use the <code class="language-ruby">Async::Service::Supervisor::ProcessMonitor</code>
     to log CPU and memory metrics for your worker processes.

context/memory-monitor.md

@@ -1,6 +1,6 @@
 # Memory Monitor
 
-This guide explains how to use the {ruby Async::Container::Supervisor::MemoryMonitor} to detect and restart workers that exceed memory limits or develop memory leaks.
+This guide explains how to use the {ruby Async::Service::Supervisor::MemoryMonitor} to detect and restart workers that exceed memory limits or develop memory leaks.
 
 ## Overview
 
@@ -21,11 +21,11 @@ Add a memory monitor to your supervisor service to automatically restart workers
 
 ```ruby
 service "supervisor" do
-	include Async::Container::Supervisor::Environment
+	include Async::Service::Supervisor::Environment
 
 	monitors do
 		[
-			Async::Container::Supervisor::MemoryMonitor.new(
+			Async::Service::Supervisor::MemoryMonitor.new(
 				# Check worker memory every 10 seconds:
 				interval: 10,
 
@@ -52,7 +52,7 @@ The `MemoryMonitor` accepts the following options:
 The interval (in seconds) at which to check for memory leaks. Default: `10` seconds.
 
 ```ruby
-Async::Container::Supervisor::MemoryMonitor.new(interval: 30)
+Async::Service::Supervisor::MemoryMonitor.new(interval: 30)
 ```
 
 ### `maximum_size_limit`
@@ -61,10 +61,10 @@ The maximum memory size (in bytes) per process. When a process exceeds this limi
 
 ```ruby
 # 500MB limit
-Async::Container::Supervisor::MemoryMonitor.new(maximum_size_limit: 1024 * 1024 * 500)
+Async::Service::Supervisor::MemoryMonitor.new(maximum_size_limit: 1024 * 1024 * 500)
 
 # 1GB limit
-Async::Container::Supervisor::MemoryMonitor.new(maximum_size_limit: 1024 * 1024 * 1024)
+Async::Service::Supervisor::MemoryMonitor.new(maximum_size_limit: 1024 * 1024 * 1024)
 ```
 
 ### `total_size_limit`
@@ -73,7 +73,7 @@ The total size limit (in bytes) for all monitored processes combined. If not spe
 
 ```ruby
 # Total limit of 2GB across all workers
-Async::Container::Supervisor::MemoryMonitor.new(
+Async::Service::Supervisor::MemoryMonitor.new(
 	maximum_size_limit: 1024 * 1024 * 500,  # 500MB per process
 	total_size_limit: 1024 * 1024 * 1024 * 2  # 2GB total
 )
@@ -87,15 +87,15 @@ Default: `{duration: 30, timeout: 120}`
 
 ```ruby
 # Customize memory sampling:
-Async::Container::Supervisor::MemoryMonitor.new(
+Async::Service::Supervisor::MemoryMonitor.new(
 	memory_sample: {
 		duration: 60,  # Sample for 60 seconds
 		timeout: 180   # Timeout after 180 seconds
 	}
 )
 
 # Disable memory sampling:
-Async::Container::Supervisor::MemoryMonitor.new(
+Async::Service::Supervisor::MemoryMonitor.new(
 	memory_sample: nil
 )
 ```

context/process-monitor.md

@@ -1,6 +1,6 @@
 # Process Monitor
 
-This guide explains how to use the {ruby Async::Container::Supervisor::ProcessMonitor} to log CPU and memory metrics for your worker processes.
+This guide explains how to use the {ruby Async::Service::Supervisor::ProcessMonitor} to log CPU and memory metrics for your worker processes.
 
 ## Overview
 
@@ -16,20 +16,20 @@ Use the `ProcessMonitor` when you need:
 - **Debugging assistance**: Correlate resource usage with application behavior.
 - **Cost optimization**: Right-size infrastructure based on actual usage.
 
-Unlike the {ruby Async::Container::Supervisor::MemoryMonitor}, which takes action when limits are exceeded, the `ProcessMonitor` is purely observational - it logs metrics without interfering with worker processes.
+Unlike the {ruby Async::Service::Supervisor::MemoryMonitor}, which takes action when limits are exceeded, the `ProcessMonitor` is purely observational - it logs metrics without interfering with worker processes.
 
 ## Usage
 
 Add a process monitor to log resource usage every minute:
 
 ```ruby
 service "supervisor" do
-	include Async::Container::Supervisor::Environment
+	include Async::Service::Supervisor::Environment
 
 	monitors do
 		[
 			# Log CPU and memory metrics for all processes:
-			Async::Container::Supervisor::ProcessMonitor.new(
+			Async::Service::Supervisor::ProcessMonitor.new(
 				interval: 60  # Capture metrics every minute
 			)
 		]
@@ -51,10 +51,10 @@ The interval (in seconds) at which to capture and log process metrics. Default:
 
 ```ruby
 # Log every 30 seconds
-Async::Container::Supervisor::ProcessMonitor.new(interval: 30)
+Async::Service::Supervisor::ProcessMonitor.new(interval: 30)
 
 # Log every 5 minutes
-Async::Container::Supervisor::ProcessMonitor.new(interval: 300)
+Async::Service::Supervisor::ProcessMonitor.new(interval: 300)
 ```
 
 ## Captured Metrics

examples/hang/service.rb

@@ -4,17 +4,17 @@
 # Released under the MIT License.
 # Copyright, 2025, by Samuel Williams.
 
-require "async/container/supervisor"
+require "async/service/supervisor"
 
 class SleepService < Async::Service::Generic
 	def setup(container)
 		super
 
 		container.run(name: self.class.name, count: 1, restart: true, health_check_timeout: 2) do |instance|
 			Async do
-				if @environment.implements?(Async::Container::Supervisor::Supervised)
-					@evaluator.make_supervised_worker(instance).run
-				end
+				evaluator = self.environment.evaluator
+				
+				evaluator.prepare!(instance)
 
 				start_time = Time.now
 
@@ -31,9 +31,9 @@ def setup(container)
 service "sleep" do
 	service_class SleepService
 
-	include Async::Container::Supervisor::Supervised
+	include Async::Service::Supervisor::Supervised
 end
 
 service "supervisor" do
-	include Async::Container::Supervisor::Environment
+	include Async::Service::Supervisor::Environment
 end