feat(serverless-init): add ProcessHooks for subprocess liveness tracking

RunInit and execute() gain a *ProcessHooks parameter (OnAlive/OnDead)
so callers can track a spawned user process's liveness. mode.Conf.Runner
is dropped for init-container mode since its func type can no longer
match RunInit's new signature; main.go switches from modeConf.Runner(logConfig)
to cloudService.Run(modeConf, logConfig) (already available on the
CloudService interface) so init-container behavior is unaffected.
mode_windows.go gains a matching ProcessHooks stub so packages that
construct one (e.g. a future MicroVM CloudService) still cross-compile
for GOOS=windows.

PR stack — this is PR 7 (of the microvm-07 split), part 1/5:
1. This PR — ProcessHooks plumbing in mode package
2. MicroVM CloudService (cloudservice/microvm.go)
3. MicroVM tags/metrics/arch tests
4. MicroVM lifecycle-server tests
5. main.go wiring + CloudService registration

Author: litianningdatadog

cmd/serverless-init/cloudservice/service.go

@@ -171,12 +171,13 @@ func (l *LocalService) Run(modeConf mode.Conf, logConfig *serverlessInitLog.Conf
 
 // defaultRun is the standard Run implementation for cloud services that do not
 // manage a child process themselves. In sidecar mode it calls RunSidecar; in
-// init-container mode it spawns the user app directly via RunInit.
+// init-container mode it spawns the user app with no child handle (no
+// MarkAlive/MarkDead tracking). MicroVM overrides Run to supply its child.
 func defaultRun(modeConf mode.Conf, logConfig *serverlessInitLog.Config) error {
 	if modeConf.SidecarMode {
 		return mode.RunSidecar(logConfig)
 	}
-	return mode.RunInit(logConfig)
+	return mode.RunInit(logConfig, nil) // no child tracking for non-MicroVM services
 }
 
 // Shutdown emits the shutdown metric for LocalService

cmd/serverless-init/main.go

@@ -374,7 +374,7 @@ func run(
 		cloudService, tagConfig, metricTags, demux,
 	)
 
-	err := modeConf.Runner(logConfig)
+	err := cloudService.Run(modeConf, logConfig)
 
 	// Defers are LIFO. Order of execution:
 	//   1. Watchdog timer starts (debug log if shutdown exceeds the budget).

cmd/serverless-init/mode/initcontainer_mode.go

@@ -21,24 +21,33 @@ import (
 	"github.com/spf13/afero"
 )
 
-// Run is the entrypoint of the init process. It will spawn the customer process
-func RunInit(logConfig *serverlessLog.Config) error {
+// ProcessHooks carries optional callbacks that are invoked around subprocess
+// lifecycle transitions. MicroVM supplies OnAlive/OnDead to drive its /ready
+// alive-check; other cloud services pass nil.
+type ProcessHooks struct {
+	OnAlive func() // called after cmd.Start succeeds
+	OnDead  func() // called when cmd.Wait returns (deferred, fires on panic too)
+}
+
+// RunInit is the entrypoint of the init process. It spawns the customer
+// process and, when hooks is non-nil, invokes hooks.OnAlive on cmd.Start
+// success and hooks.OnDead via defer so the caller can track liveness.
+func RunInit(logConfig *serverlessLog.Config, hooks *ProcessHooks) error {
 	if len(os.Args) < 2 {
 		panic("[datadog init process] invalid argument count, did you forget to set CMD ?")
 	}
 
 	args := os.Args[1:]
 
 	log.Debugf("Launching subprocess %v\n", args)
-	err := execute(logConfig, args)
-	if err != nil {
+	if err := execute(logConfig, args, hooks); err != nil {
 		log.Errorf("ERROR: Failed to execute command: %v\n", err)
 		return err
 	}
 	return nil
 }
 
-func execute(logConfig *serverlessLog.Config, args []string) error {
+func execute(logConfig *serverlessLog.Config, args []string, hooks *ProcessHooks) error {
 	commandName, commandArgs := buildCommandParam(args)
 
 	// Add our tracer settings
@@ -55,15 +64,21 @@ func execute(logConfig *serverlessLog.Config, args []string) error {
 		cmd.Stderr = io.MultiWriter(os.Stderr, serverlessLog.NewChannelWriter(logConfig.Channel, true))
 	}
 
-	err := cmd.Start()
-	if err != nil {
+	if err := cmd.Start(); err != nil {
 		return err
 	}
+	if hooks != nil && hooks.OnAlive != nil {
+		hooks.OnAlive()
+		// Defer OnDead so it fires even on panic / runtime.Goexit. The
+		// child process is no longer being supervised once we leave this frame.
+		if hooks.OnDead != nil {
+			defer hooks.OnDead()
+		}
+	}
 	sigs := make(chan os.Signal, 1)
 	signal.Notify(sigs)
 	go forwardSignals(cmd.Process, sigs)
-	err = cmd.Wait()
-	return err
+	return cmd.Wait()
 }
 
 func buildCommandParam(cmdArg []string) (string, []string) {

cmd/serverless-init/mode/initcontainer_mode_test.go

@@ -12,16 +12,74 @@ import (
 	"os/exec"
 	"runtime"
 	"strconv"
+	"sync/atomic"
 	"syscall"
 	"testing"
+	"time"
 
 	"github.com/spf13/afero"
 
+	"github.com/DataDog/datadog-agent/cmd/serverless-init/lifecycle"
 	serverlessLog "github.com/DataDog/datadog-agent/cmd/serverless-init/log"
 
 	"github.com/stretchr/testify/assert"
 )
 
+// TestDetectMode_Sidecar_HasRunnerSet verifies that sidecar mode (no args)
+// sets Runner to RunSidecar so main.go can call it directly.
+func TestDetectMode_Sidecar_HasRunnerSet(t *testing.T) {
+	saved := os.Args
+	defer func() { os.Args = saved }()
+	os.Args = []string{"datadog-init"}
+
+	conf := DetectMode()
+	assert.True(t, conf.SidecarMode)
+	assert.NotNil(t, conf.Runner, "sidecar mode must set Runner to RunSidecar")
+}
+
+// TestDetectMode_Init_RunnerIsNil verifies that init mode (args present) leaves
+// Runner nil. main.go delegates to cloudService.Run(modeConf, logConfig) which
+// each CloudService implements directly, so modeConf.Runner is not used in
+// init-container mode.
+func TestDetectMode_Init_RunnerIsNil(t *testing.T) {
+	saved := os.Args
+	defer func() { os.Args = saved }()
+	os.Args = []string{"datadog-init", "sh", "-c", "exit 0"}
+
+	conf := DetectMode()
+	assert.False(t, conf.SidecarMode)
+	assert.Nil(t, conf.Runner, "init mode Runner must be nil; main.go builds the closure with child")
+}
+
+// TestHandleTerminationSignals_SIGTERM and _SIGINT exercise handleTerminationSignals
+// via its injectable notify parameter, avoiding real OS signals and verifying
+// that either signal unblocks stopCh.
+func TestHandleTerminationSignals_SIGTERM(t *testing.T) {
+	stopCh := make(chan struct{}, 1)
+	notify := func(c chan<- os.Signal, _ ...os.Signal) {
+		go func() { c <- syscall.SIGTERM }()
+	}
+	handleTerminationSignals(stopCh, notify)
+	select {
+	case <-stopCh:
+	default:
+		t.Fatal("stopCh must be closed after SIGTERM")
+	}
+}
+
+func TestHandleTerminationSignals_SIGINT(t *testing.T) {
+	stopCh := make(chan struct{}, 1)
+	notify := func(c chan<- os.Signal, _ ...os.Signal) {
+		go func() { c <- syscall.SIGINT }()
+	}
+	handleTerminationSignals(stopCh, notify)
+	select {
+	case <-stopCh:
+	default:
+		t.Fatal("stopCh must be closed after SIGINT")
+	}
+}
+
 func TestBuildCommandParamWithArgs(t *testing.T) {
 	name, args := buildCommandParam([]string{"superCmd", "--verbose", "path", "-i", "."})
 	assert.Equal(t, "superCmd", name)
@@ -36,19 +94,110 @@ func TestBuildCommandParam(t *testing.T) {
 
 func TestPropagateChildSuccess(t *testing.T) {
 	runTestOnLinuxOnly(t, func(t *testing.T) {
-		err := execute(&serverlessLog.Config{}, []string{"bash", "-c", "exit 0"})
+		err := execute(&serverlessLog.Config{}, []string{"bash", "-c", "exit 0"}, nil)
 		assert.Equal(t, nil, err)
 	})
 }
 
 func TestPropagateChildError(t *testing.T) {
 	runTestOnLinuxOnly(t, func(t *testing.T) {
 		expectedError := 123
-		err := execute(&serverlessLog.Config{}, []string{"bash", "-c", "exit " + strconv.Itoa(expectedError)})
+		err := execute(&serverlessLog.Config{}, []string{"bash", "-c", "exit " + strconv.Itoa(expectedError)}, nil)
 		assert.Equal(t, expectedError<<8, int(err.(*exec.ExitError).ProcessState.Sys().(syscall.WaitStatus)))
 	})
 }
 
+// When cmd.Start fails (e.g. binary not found), execute must return the error
+// and never invoke OnAlive — the user app never ran.
+func TestExecute_StartFailure_NeverCallsOnAlive(t *testing.T) {
+	var onAliveCalled bool
+	hooks := &ProcessHooks{
+		OnAlive: func() { onAliveCalled = true },
+		OnDead:  func() {},
+	}
+	err := execute(&serverlessLog.Config{}, []string{"/nonexistent/binary/that/cannot/be/found"}, hooks)
+	assert.Error(t, err, "cmd.Start must fail for a missing binary")
+	assert.False(t, onAliveCalled, "OnAlive must not be called when cmd.Start fails")
+}
+
+// On a successful run, execute must call OnAlive after cmd.Start and OnDead
+// via defer after cmd.Wait. The mid-run probe pins the ordering.
+func TestExecute_SuccessfulRun_InvokesHooksInOrder(t *testing.T) {
+	child := lifecycle.NewChild()
+	hooks := &ProcessHooks{
+		OnAlive: child.MarkAlive,
+		OnDead:  child.MarkDead,
+	}
+	var midRunAlive atomic.Bool
+	probeDone := make(chan struct{})
+	go func() {
+		defer close(probeDone)
+		time.Sleep(100 * time.Millisecond)
+		midRunAlive.Store(child.IsAlive())
+	}()
+	err := execute(&serverlessLog.Config{}, []string{"sh", "-c", "sleep 0.5"}, hooks)
+	<-probeDone
+	assert.NoError(t, err)
+	assert.True(t, midRunAlive.Load(), "OnAlive must fire before cmd.Wait returns")
+	assert.False(t, child.IsAlive(), "OnDead must fire after cmd.Wait returns")
+}
+
+// MicroVM init-container mode: ProcessHooks drive liveness tracking through
+// the public RunInit entry point. Pins the alive→dead transition.
+func TestRunInit_MicroVM_ChildSupplied_TracksLiveness(t *testing.T) {
+	saved := os.Args
+	defer func() { os.Args = saved }()
+	os.Args = []string{"datadog-init", "sh", "-c", "sleep 0.5"}
+
+	child := lifecycle.NewChild()
+	var midRunAlive atomic.Bool
+	probeDone := make(chan struct{})
+	go func() {
+		defer close(probeDone)
+		time.Sleep(100 * time.Millisecond)
+		midRunAlive.Store(child.IsAlive())
+	}()
+	err := RunInit(&serverlessLog.Config{}, &ProcessHooks{OnAlive: child.MarkAlive, OnDead: child.MarkDead})
+	<-probeDone
+	assert.NoError(t, err)
+	assert.True(t, midRunAlive.Load(), "child must be marked alive while RunInit is blocked")
+	assert.False(t, child.IsAlive(), "child must be marked dead after RunInit returns")
+}
+
+// Non-MicroVM mode: nil hooks. RunInit must execute the user app without
+// panicking. Pins the `if hooks != nil` guard.
+func TestRunInit_NonMicroVM_NoHooks_StillExecutes(t *testing.T) {
+	saved := os.Args
+	defer func() { os.Args = saved }()
+	os.Args = []string{"datadog-init", "sh", "-c", "exit 0"}
+
+	err := RunInit(&serverlessLog.Config{}, nil)
+	assert.NoError(t, err)
+}
+
+// On a non-zero exit, OnDead must still fire. Pins the defer-on-error path.
+func TestExecute_NonZeroExit_OnDeadFiresAfterExit(t *testing.T) {
+	child := lifecycle.NewChild()
+	// Simulate MicroVM wiring: OnAlive fires first so child is alive, then
+	// OnDead fires on defer.
+	hooks := &ProcessHooks{OnAlive: child.MarkAlive, OnDead: child.MarkDead}
+	err := execute(&serverlessLog.Config{}, []string{"sh", "-c", "exit 7"}, hooks)
+	assert.Error(t, err, "non-zero exit must surface as an error")
+	assert.False(t, child.IsAlive(), "OnDead must fire after non-zero exit")
+}
+
+// ProcessHooks with OnAlive set but OnDead nil must not panic. Pins the
+// nil-guard on hooks.OnDead added to execute().
+func TestExecute_OnAliveSetOnDeadNil_DoesNotPanic(t *testing.T) {
+	hooks := &ProcessHooks{
+		OnAlive: func() {},
+		OnDead:  nil, // intentionally absent
+	}
+	assert.NotPanics(t, func() {
+		_ = execute(&serverlessLog.Config{}, []string{"sh", "-c", "exit 0"}, hooks)
+	})
+}
+
 func TestForwardSignalToChild(t *testing.T) {
 	runTestOnLinuxOnly(t, func(t *testing.T) {
 		resultChan := make(chan error)

cmd/serverless-init/mode/mode.go

@@ -57,7 +57,6 @@ func DetectMode() Conf {
 	log.Infof("Arguments provided, launching in Init mode")
 	return Conf{
 		LoggerName:                    loggerNameInit,
-		Runner:                        RunInit,
 		TagVersionMode:                "_dd.datadog_init_version",
 		TagVersionModeEnhancedMetrics: "datadog_init_version",
 		SidecarMode:                   false,

cmd/serverless-init/mode/mode_windows.go

@@ -27,8 +27,16 @@ type Conf struct {
 	EnvDefaults                   map[string]string
 }
 
+// ProcessHooks mirrors the init-container ProcessHooks type so that packages
+// which construct it (e.g. cloudservice.MicroVM) still build on windows.
+// serverless-init is not supported on windows, so these hooks are never invoked.
+type ProcessHooks struct {
+	OnAlive func()
+	OnDead  func()
+}
+
 // RunInit is unsupported on windows.
-func RunInit(_ *serverlessLog.Config) error {
+func RunInit(_ *serverlessLog.Config, _ *ProcessHooks) error {
 	return errors.New("serverless-init is not supported on windows")
 }
 

cmd/serverless-init/mode/mode_windows_test.go

@@ -14,7 +14,7 @@ import (
 )
 
 func TestRunInitUnsupportedOnWindows(t *testing.T) {
-	err := RunInit(nil)
+	err := RunInit(nil, nil)
 	assert.EqualError(t, err, "serverless-init is not supported on windows")
 }
 

cmd/serverless-init/mode/sidecarcontainer_mode.go

@@ -17,7 +17,8 @@ import (
 	"github.com/DataDog/datadog-agent/pkg/util/log"
 )
 
-// Run is the entrypoint of the init process. It will spawn the customer process
+// RunSidecar is the entrypoint when serverless-init runs as a sidecar
+// container. It blocks until SIGINT/SIGTERM.
 func RunSidecar(_ *serverlessLog.Config) error {
 	stopCh := make(chan struct{})
 	go handleTerminationSignals(stopCh, signal.Notify)