Add naming support to readiness probes for better logging

lifecycle/func.go

@@ -31,8 +31,12 @@ func NewFuncActor(start, stop func(ctx context.Context) error) *FuncActor {
 }
 
 // WithName sets the name of the actor.
+// If a readiness probe is enabled, its name is also updated.
 func (f *FuncActor) WithName(name string) *FuncActor {
 	f.name = name
+	if f.readinessProbe != nil {
+		f.readinessProbe.WithName(name)
+	}
 	return f
 }
 
@@ -73,7 +77,7 @@ func (f *FuncActor) RequiresStop() bool {
 // Returns the actor for method chaining.
 func (f *FuncActor) WithReadiness() *FuncActor {
 	if f.readinessProbe == nil {
-		f.readinessProbe = NewReadinessProbe()
+		f.readinessProbe = NewReadinessProbe().WithName(f.name)
 	}
 	return f
 }

lifecycle/lifecycle.go

@@ -142,6 +142,7 @@ func (lc *Lifecycle) Start(ctx context.Context) (xerr error) {
 
 	lc.mu.RLock()
 	actors := slices.Clone(lc.actors)
+	logger := lc.logger
 	lc.mu.RUnlock()
 
 	// Check for long-running services before starting actors
@@ -177,25 +178,34 @@ func (lc *Lifecycle) Start(ctx context.Context) (xerr error) {
 	}
 
 	// Wait for all probes to signal ready
-	for _, probe := range allProbes {
+	for i, probe := range allProbes {
+		probeName := probe.GetName()
+		if probeName == "" {
+			probeName = fmt.Sprintf("probe[%d]", i)
+		}
+		logger.DebugContext(ctx, "Waiting for readiness probe", "probe", probeName)
 		select {
 		case <-lc.Done():
 			return lc.Err()
 		case <-ctx.Done():
 			return errors.WithStack(ctx.Err())
 		case <-probe.Done():
 			if err := probe.Error(); err != nil {
+				logger.ErrorContext(ctx, "Readiness probe failed", "probe", probeName, "error", err)
 				return err
 			}
+			logger.DebugContext(ctx, "Readiness probe signaled ready", "probe", probeName)
 		}
 	}
 
 	return nil
 }
 
 // WithName sets the name for the lifecycle.
+// Also updates the readiness probe name.
 func (lc *Lifecycle) WithName(name string) *Lifecycle {
 	lc.FuncService.WithName(name)
+	lc.readinessProbe.WithName(name)
 	return lc
 }
 
@@ -333,6 +343,8 @@ func (lc *Lifecycle) Serve(ctx context.Context, ctors ...any) (xerr error) {
 			actorType = "Service"
 		}
 
+		logger.DebugContext(ctx, fmt.Sprintf("%s starting", actorType), "actor", actorName)
+
 		if err := actor.Start(ctx); err != nil {
 			logger.ErrorContext(ctx, fmt.Sprintf("Failed to start %s", strings.ToLower(actorType)), "actor", actorName, "error", err)
 			return err

lifecycle/readiness.go

@@ -15,6 +15,7 @@ type ReadinessProbe struct {
 	doneC chan struct{} // Completion signal channel
 	mu    sync.RWMutex  // Protects err field
 	err   error         // Error if failed, nil if successful
+	name  string        // Name for logging and debugging
 }
 
 // NewReadinessProbe creates a new readiness probe.
@@ -46,3 +47,14 @@ func (rp *ReadinessProbe) Error() error {
 	defer rp.mu.RUnlock()
 	return rp.err
 }
+
+// WithName sets the name of the readiness probe for logging and debugging.
+func (rp *ReadinessProbe) WithName(name string) *ReadinessProbe {
+	rp.name = name
+	return rp
+}
+
+// GetName returns the name of the readiness probe.
+func (rp *ReadinessProbe) GetName() string {
+	return rp.name
+}