refactor(init): derive the init error type per attempt; drop ClearInitError

The recorded init error type was sticky across init attempts and cleared
cross-component by the invoke handler after a successful invocation.
Stickiness is unnecessary: every invocation into a failed-init
environment starts a fresh suppressed Init phase (rapidcore shuts the
runtime down after an init failure so the next FastInvoke re-inits), so
each failing attempt re-records its error type via its own
SendInitReport. Resetting the field in SendInitStart therefore keeps the
same behavior with one mechanism instead of two.

This also fixes a mislabeling bug: previously, when a suppressed init
re-run recovered but the invocation itself then died fatally
(ErrInvokeDoneFailed), the stale sticky error type tainted that
invocation's REPORT line with the original init failure.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: joe4dev

cmd/localstack/custom_interop.go

@@ -159,12 +159,7 @@ func NewCustomInteropServer(lsOpts *LsOpts, adapter *LocalStackAdapter, delegate
 				timeout := int(server.delegate.GetInvokeTimeout().Seconds())
 				isErr := false
 				status := ""
-				if err == nil {
-					// The invocation succeeded: if an earlier init failure was folded into it
-					// and the suppressed init re-run recovered, the result stands on its own —
-					// AWS reports it as successful — so clear the recorded init failure.
-					server.eventsAPI.ClearInitError()
-				} else {
+				if err != nil {
 					switch {
 					case errors.Is(err, rapidcore.ErrInvokeTimeout):
 						log.Debugf("Got invoke timeout")

cmd/localstack/events.go

@@ -49,11 +49,13 @@ type LocalStackEventsAPI struct {
 	// starting the runtime process, so treat empty as an error.
 	lastInitStatus    string
 	lastInitErrorType string
-	// initErrorType is the scrubbed fatal error type of the most recent failed init. Unlike
-	// lastInitErrorType it is sticky across init attempts (each failing invocation re-runs the
-	// init as a suppressed init and AWS re-emits the failure envelope) and is cleared by the
-	// invoke handler once an invocation succeeds, so a recovered environment is not tainted by
-	// the original failure.
+	// initErrorType is the scrubbed fatal error type of the most recent failed init attempt,
+	// reset on SendInitStart. No cross-attempt stickiness is needed: every invocation into a
+	// failed-init environment starts a fresh suppressed Init phase (rapidcore shuts the runtime
+	// down after an init failure so the next FastInvoke re-inits — see Server.Invoke in
+	// rapidcore/server.go), so each failing invocation re-records the failure via its own
+	// SendInitReport, and a successful re-run leaves it empty — a recovered environment is not
+	// tainted by the original failure.
 	initErrorType string
 	// initTimedOut is set by main.go before it resets a timed-out init phase, so the aborted
 	// init's INIT_REPORT renders as AWS's "Status: timeout" (without an error type) instead of
@@ -75,7 +77,7 @@ func NewLocalStackEventsAPI(logCollector *LogCollector, onDemand bool) *LocalSta
 
 func (e *LocalStackEventsAPI) SendInitStart(data interop.InitStartData) error {
 	e.mu.Lock()
-	e.lastInitStatus, e.lastInitErrorType = "", ""
+	e.lastInitStatus, e.lastInitErrorType, e.initErrorType = "", "", ""
 	e.mu.Unlock()
 	return nil
 }
@@ -156,18 +158,9 @@ func (e *LocalStackEventsAPI) TakeColdStartInitDuration() (durationMS float64, o
 }
 
 // InitErrorType returns the scrubbed fatal error type (e.g. Runtime.ExitError) of the most
-// recent failed init, or "" if the latest init succeeded or none was recorded.
+// recent failed init attempt, or "" if the latest init attempt succeeded or none was recorded.
 func (e *LocalStackEventsAPI) InitErrorType() string {
 	e.mu.Lock()
 	defer e.mu.Unlock()
 	return e.initErrorType
 }
-
-// ClearInitError resets the recorded init failure once an invocation succeeded: the
-// suppressed init re-run recovered, so later invocations must not be tainted by the
-// original failure.
-func (e *LocalStackEventsAPI) ClearInitError() {
-	e.mu.Lock()
-	defer e.mu.Unlock()
-	e.initErrorType = ""
-}

cmd/localstack/events_test.go

@@ -119,12 +119,13 @@ func TestEventsAPI_TimedOutInit_RendersTimeoutStatusOnce(t *testing.T) {
 		logs.getLogs().Logs)
 }
 
-func TestEventsAPI_RecoveredSuppressedInit_NoLineAndErrorClearable(t *testing.T) {
+func TestEventsAPI_RecoveredSuppressedInit_NoLineAndErrorCleared(t *testing.T) {
 	logs := NewLogCollector()
 	e := NewLocalStackEventsAPI(logs, true)
 
 	// Cold-start init fails ...
 	sendInit(t, e, "init", "error", "Runtime.Unknown", 5.0)
+	assert.Equal(t, "Runtime.Unknown", e.InitErrorType())
 	logs.reset()
 	// ... and the suppressed init re-run at the first invocation recovers.
 	sendInit(t, e, "invoke", "success", "", 6.0)
@@ -135,13 +136,25 @@ func TestEventsAPI_RecoveredSuppressedInit_NoLineAndErrorClearable(t *testing.T)
 	_, ok := e.TakeColdStartInitDuration()
 	assert.False(t, ok)
 
-	// The sticky failure record survives until the invoke handler observes a successful
-	// invocation and clears it.
-	assert.Equal(t, "Runtime.Unknown", e.InitErrorType())
-	e.ClearInitError()
+	// The failure record is per init attempt: the successful re-run resets it, so the
+	// recovered invocation's REPORT is not tainted by the original failure — even if the
+	// invocation itself later dies fatally.
 	assert.Empty(t, e.InitErrorType())
 }
 
+func TestEventsAPI_RepeatedFailingSuppressedInit_ReRecordsEachAttempt(t *testing.T) {
+	logs := NewLogCollector()
+	e := NewLocalStackEventsAPI(logs, true)
+
+	// Cold-start init fails, then every invocation re-runs the suppressed init,
+	// which fails again — each attempt re-records its own error type.
+	sendInit(t, e, "init", "error", "Runtime.Unknown", 5.0)
+	sendInit(t, e, "invoke", "error", "Runtime.ExitError", 2.0)
+	assert.Equal(t, "Runtime.ExitError", e.InitErrorType())
+	sendInit(t, e, "invoke", "error", "Runtime.Unknown", 2.1)
+	assert.Equal(t, "Runtime.Unknown", e.InitErrorType())
+}
+
 func TestEventsAPI_InvokeStart_EmitsStartLine(t *testing.T) {
 	logs := NewLogCollector()
 	e := NewLocalStackEventsAPI(logs, true)