chore(core): move actor liveness check to setInterval

[NathanFlurry]

Fixes KIT-246

[claude]

Claude finished @NathanFlurry's task —— View job

---

Code Review Complete ✅

Reviewing the PR that moves actor liveness check to setInterval. Analyzing the changes across 4 files:

• Analyze the modified files to understand the refactor
• Review the git diff to see specific changes
• Assess code quality and best practices
• Check for potential bugs or issues
• Evaluate performance considerations
• Look for security concerns
• Assess test coverage
• Provide comprehensive feedback

Analysis Summary

The PR refactors how connection liveness checks are implemented:

Before: Used alarm-based scheduling with persistent events
After: Uses setInterval with in-memory timers

Code Quality & Best Practices ✅

Excellent refactoring work:

• Clean separation of concerns - liveness checks are now properly isolated from the persistence layer
• Well-documented rationale in comments at instance.ts:345-362
• Proper cleanup in _stop() method at instance.ts:1624-1625
• Follows established patterns for timer management

Code improvements:

• Simplified persistent event structure removing special-case ccl events
• Better type safety with unified PersistedScheduleEventKind structure
• Reduced complexity in alarm scheduling logic

Performance Considerations ✅

Significant improvements:

• Reduced I/O overhead: No longer persisting liveness check events to disk
• Better memory usage: Eliminates persistent storage of transient liveness events
• Cleaner separation: Alarms reserved for durable events, intervals for ephemeral checks
• No wake-up overhead: Liveness checks won't unnecessarily wake sleeping actors

The change appropriately trades persistence for performance since connection liveness is inherently transient.

Architecture & Logic ✅

Sound architectural decisions:

• Proper lifecycle management: interval starts after actor is ready, clears on stop
• Immediate liveness check on startup handles reconnecting connections from previous sleep
• Timer reset logic preserved and working correctly
• Event structure refactoring maintains backward compatibility for actual scheduled events

Potential Issues & Recommendations

Minor concerns:

1. Race condition potential (instance.ts:1624-1625): Interval clearing happens after starting connection disconnections. Consider moving it earlier:

   // Clear timeouts first to prevent new liveness checks
   if (this.#checkConnLivenessInterval) clearInterval(this.#checkConnLivenessInterval);
   
   // Then disconnect connections
   for (const connection of this.#connections.values()) {
     promises.push(connection.disconnect());
   }

2. Error handling: The setInterval callback at instance.ts:358-362 uses .bind(this) which is good, but consider wrapping in try-catch for robustness:

   this.#checkConnLivenessInterval = setInterval(() => {
     try {
       this.#checkConnectionsLiveness();
     } catch (error) {
       logger().error("liveness check failed", { error: stringifyError(error) });
     }
   }, this.#config.options.connectionLivenessInterval);

Security Considerations ✅

No security concerns identified. The change reduces attack surface by eliminating persistent liveness events.

Test Coverage ⚠️

Missing test coverage: No tests found specifically for the liveness check functionality. Recommend adding tests for:

• Interval creation and cleanup
• Liveness check logic with mock connections
• Race condition scenarios during actor shutdown
• Behavior when actor sleeping is disabled vs enabled

Overall Assessment

Excellent refactoring that improves performance and architectural cleanliness. The change is well-reasoned and properly implemented. The minor recommendations above would further strengthen the robustness.

Recommendation: ✅ Approve with suggestions - The core change is solid and the minor improvements can be addressed in follow-up work.

[NathanFlurry]

Warning

This pull request is not mergeable via GitHub because a downstack PR is open. Once all requirements are satisfied, merge this PR as a stack on Graphite.
Learn more

• chore: simplify package directories #1205
• chore(core): migrate actor persist & file system to bare #1204
• chore(core): migrate client protocol to BARE #1203
• chore(core): move actor liveness check to setInterval #1202 👈 (View in Graphite)
• fix(core): fix disconnecting sse connections #1201
• feat(core): add abort controller & implement waitUntil #1200
• feat(core): actor sleeping #1178
• fix(core): revert deleted fixtures #1199
• main

---

How to use the Graphite Merge Queue

Add either label to this PR to merge it via the merge queue:

• merge queue - adds this PR to the back of the merge queue
• hotfix - for urgent hot fixes, skip the queue and merge this PR next

You must have a Graphite account in order to use the merge queue. Sign up using this link.

An organization admin has enabled the Graphite Merge Queue in this repository.

Please do not merge from GitHub as this will restart CI on PRs being processed by the merge queue.

This stack of pull requests is managed by Graphite. Learn more about stacking.

[linear]

KIT-246 Remove alarms for conn liveness

[graphite-app]

The property access pattern has changed from direct access (event.a, event.ar) to nested access (event.k.g.a, event.k.g.ar), but there's no null/undefined checking for these nested properties. This could cause runtime errors when processing persisted events that don't match the new structure.

Consider adding defensive checks before accessing these nested properties:

if (!event.k?.g) {
  throw new Error(`Invalid event format: missing k.g structure in event ${event.e}`);
}

Or use optional chaining with fallbacks:

action: event.k?.g?.a ?? "(unknown action)",
args: event.k?.g?.ar ?? [],

This would ensure backward compatibility with any persisted events in the old format.

Suggested change

	action: event.k.g.a,
	args: event.k.g.ar,
	action: event.k?.g?.a ?? event.a ?? "(unknown action)",
	args: event.k?.g?.ar ?? event.ar ?? [],

Spotted by Diamond



Is this helpful? React 👍 or 👎 to let us know.

[graphite-app]

The code accesses event.k.g.ar without first verifying that event.k and event.k.g exist. If the event structure is malformed, this could lead to a runtime error. Consider adding a null check or using optional chaining (event.k?.g?.ar || []) to handle potentially invalid event structures gracefully.

Suggested change

	await fn.call(
	undefined,
	this.actorContext,
	...(event.k.g.ar || []),
	);
	await fn.call(
	undefined,
	this.actorContext,
	...(event.k?.g?.ar || []),
	);

Spotted by Diamond



Is this helpful? React 👍 or 👎 to let us know.

[graphite-app]

The error logging code accesses event.k.g.a and event.k.g.ar directly without checking if event.k or event.k.g exist. If the event structure is malformed, this will cause additional runtime errors during error reporting, potentially obscuring the original error. Consider adding null checks or using optional chaining (event.k?.g?.a) to make the error reporting more robust.

Suggested change

	action: event.k.g.a,
	args: event.k.g.ar,
	action: event.k?.g?.a,
	args: event.k?.g?.ar,

Spotted by Diamond



Is this helpful? React 👍 or 👎 to let us know.

[graphite-app]

Merge activity

• Sep 11, 10:34 PM UTC: NathanFlurry added this pull request to the Graphite merge queue.
• Sep 11, 10:35 PM UTC: CI is running for this pull request on a draft pull request (#1206) due to your merge queue CI optimization settings.
• Sep 11, 10:35 PM UTC: Merged by the Graphite merge queue via draft PR: #1206.