Ensure process title is set immediately after run is invoked.

Author: ioquatix

lib/async/service/managed/health_checker.rb

@@ -10,32 +10,28 @@ module Managed
 			module HealthChecker
 				# Start the health checker.
 				#
-				# If a timeout is specified, a transient child task will be scheduled, which will yield the instance if a block is given, then mark the instance as ready, and finally sleep for half the health check duration (so that we guarantee that the health check runs in time).
+				# If a timeout is specified, a transient child task will be scheduled which will mark the instance as healthy, sleep for half the health check duration (so that we guarantee that the health check runs in time), and then yield the instance if a block is given. This repeats indefinitely.
 				#
-				# If a timeout is not specified, the health checker will yield the instance immediately and then mark the instance as ready.
+				# If a timeout is not specified, the instance is marked as healthy immediately and no task is created. Any block given is ignored.
 				#
 				# @parameter instance [Object] The service instance to check.
 				# @parameter timeout [Numeric] The timeout duration for the health check.
 				# @parameter parent [Async::Task] The parent task to run the health checker in.
-				# @yields {|instance| ...} If a block is given, it will be called with the service instance at least once.
+				# @yields {|instance| ...} If a block is given and a timeout is specified, it will be called with the service instance after each sleep interval.
 				def health_checker(instance, timeout = @evaluator.health_check_timeout, parent: Async::Task.current, &block)
 					if timeout
 						parent.async(transient: true) do
 							while true
-								if block_given?
-									yield(instance)
-								end
-								
 								instance.healthy!
 
 								sleep(timeout / 2.0)
+								
+								if block_given?
+									yield(instance)
+								end
 							end
 						end
 					else
-						if block_given?
-							yield(instance)
-						end
-						
 						instance.healthy!
 					end
 				end

lib/async/service/managed/service.rb

@@ -93,6 +93,7 @@ def setup(container)
 							evaluator = self.environment.evaluator
 							server = nil
 
+							# If a health check timeout is configured, this block runs periodically to refresh the process title. Without a timeout there is no periodic timer, so the block is never called — the one-shot assignment below handles that case.
 							health_checker(instance, health_check_timeout) do
 								if server
 									instance.name = format_title(evaluator, server)
@@ -105,6 +106,8 @@ def setup(container)
 
 							instance.status!("Running...")
 							server = run(instance, evaluator)
+							# Set the process title immediately once the server is available:
+							instance.name = format_title(evaluator, server)
 							emit_running(instance, clock)
 
 							instance.ready!

releases.md

@@ -1,5 +1,9 @@
 # Releases
 
+## Unreleased
+
+  - Ensure process title is updated immediately after server starts in `Managed::Service`.
+
 ## v0.21.0
 
   - Add missing bake files.

test/async/service/managed/health_checker.rb

@@ -121,17 +121,14 @@ def initialize(environment)
 			expect(update[0]).to be == :healthy!
 		end
 
-		it "yields the instance if a block is given" do
+		it "does not yield the block" do
 			block_called = false
-			instance_passed = nil
 
 			service.health_checker(instance, nil) do |inst|
 				block_called = true
-				instance_passed = inst
 			end
 
-			expect(block_called).to be == true
-			expect(instance_passed).to be == instance
+			expect(block_called).to be == false
 		end
 
 		it "does not create async task when parent is not async" do

test/async/service/managed/service.rb

@@ -178,6 +178,40 @@ def run_called?
 			expect(options).not.to have_keys(:health_check_timeout)
 			expect(options[:restart]).to be == true
 		end
+		
+		it "updates the process title immediately even without a health check timeout" do
+			fake_server = Object.new
+			def fake_server.to_s = "fake-server"
+			
+			# Use a proper anonymous class so instance state is self-contained
+			# (avoids fragile closure captures via define_singleton_method).
+			fake_instance = Class.new do
+				def healthy! = nil
+				def ready! = nil
+				def status!(_) = nil
+				def name=(value)
+					@name = value
+				end
+				def name = @name
+			end.new
+			
+			service_with_fake_run = Class.new(Async::Service::Managed::Service) do
+				define_method(:run) {|_, _| fake_server}
+			end.new(service.environment)
+			
+			container = Async::Container.new
+			mock(container) do |mock|
+				# Call the block directly; the Async do...end inside setup creates
+				# its own reactor and runs synchronously, so the assertion is safe.
+				mock.replace(:run) do |**options, &block|
+					block.call(fake_instance)
+				end
+			end
+			
+			service_with_fake_run.setup(container)
+			
+			expect(fake_instance.name).to be == "#{service.environment.evaluator.name} fake-server"
+		end
 	end
 
 	with "#start" do