Probe connection health through a per-connection atom (#2071)

* e2e: reproduce health-probe churn on the integrations list Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> * Probe connection health through a per-connection atom Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> * e2e: bound the churn scenario to its own connections Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> ---------

Rhys Sullivan committed 1 month agomain

Commit 09c19e41 parent 1aa6fd93 files · +368 −7Browse files

Showing the changes to packages (2 of 3 files). Show all

Unified · Split

2 files

packages/react/src/api/atoms.tsx +32 −0
packages/react/src/lib/use-connection-health.ts +39 −7

packages/react/src/api/atoms.tsx+32−0

@@ -17,6 +17,7 @@ import { · 16 unmodified lines
17	} from "@executor-js/sdk/shared";	17	} from "@executor-js/sdk/shared";
18	import * as Atom from "effect/unstable/reactivity/Atom";	18	import * as Atom from "effect/unstable/reactivity/Atom";
19	import * as AsyncResult from "effect/unstable/reactivity/AsyncResult";	19	import * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
		20	import * as Reactivity from "effect/unstable/reactivity/Reactivity";
20	import * as Effect from "effect/Effect";	21	import * as Effect from "effect/Effect";
21		22
22	import { ExecutorApiClient } from "./client";	23	import { ExecutorApiClient } from "./client";
@@ -198,6 +199,37 @@ export const refreshConnection = ExecutorApiClient.mutation("connections", "refr · 175 unmodified lines
198	* cache on every load). */	199	* cache on every load). */
199	export const checkConnectionHealth = ExecutorApiClient.mutation("connections", "checkHealth");	200	export const checkConnectionHealth = ExecutorApiClient.mutation("connections", "checkHealth");
200		201
		202	export interface CheckConnectionHealthArgs {
		203	readonly params: {
		204	readonly owner: Owner;
		205	readonly integration: IntegrationSlug;
		206	readonly name: ConnectionName;
		207	};
		208	readonly query: { readonly ifStaleMs?: number };
		209	readonly reactivityKeys?: ReadonlyArray<unknown>;
		210	}
		211
		212	/** The AUTOMATIC health probe, one atom PER CONNECTION.
		213	*
		214	* `checkConnectionHealth` above is one shared mutation atom. Awaiting it
		215	* (`useAtomSet(..., { mode: "promiseExit" })`) resolves with the atom's next
		216	* settled result, whichever call produced it, and a new call interrupts the
		217	* one in flight. A surface that probes every row of a list in one pass
		218	* therefore cancels all but the last probe and hands every row the LAST
		219	* row's verdict. Each row then reads a foreign verdict as a change to its own
		220	* connection, refreshes the connections cache, and re-probes: the probe storm
		221	* the automatic path was built to avoid. Keying the atom by connection address
		222	* gives every probe its own fiber and its own result. */
		223	export const checkConnectionHealthFor = Atom.family((address: ConnectionAddress) =>
		224	ExecutorApiClient.runtime.fn<CheckConnectionHealthArgs>()((args) => {
		225	const probe = Effect.gen(function* () {
		226	const client = yield* ExecutorApiClient;
		227	return yield* client.connections.checkHealth({ params: args.params, query: args.query });
		228	}).pipe(Effect.withSpan("connection.health.probe", { attributes: { address } }));
		229	return args.reactivityKeys ? Reactivity.mutation(probe, args.reactivityKeys) : probe;
		230	}),
		231	);
		232
201	/** Validate an IN-FLIGHT credential without saving it (the key-first connect	233	/** Validate an IN-FLIGHT credential without saving it (the key-first connect
202	* flow). Returns the probe result the UI derives a connection name from. */	234	* flow). Returns the probe result the UI derives a connection name from. */
203	export const validateConnection = ExecutorApiClient.mutation("connections", "validate");	235	export const validateConnection = ExecutorApiClient.mutation("connections", "validate");

packages/react/src/lib/use-connection-health.ts+39−7

 // drift apart.
 import { useCallback, useContext, useEffect, useRef, useState } from "react";
-import { RegistryContext, useAtomSet } from "@effect/atom-react";
+import { RegistryContext } from "@effect/atom-react";
+import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
+import * as AtomRegistry from "effect/unstable/reactivity/AtomRegistry";
 import type { Connection, HealthCheckResult, HealthStatus, Owner } from "@executor-js/sdk/shared";
-import { checkConnectionHealth, connectionsOptimisticAtom } from "../api/atoms";
+import {
+  checkConnectionHealthFor,
+  connectionsOptimisticAtom,
+  type CheckConnectionHealthArgs,
+} from "../api/atoms";
 import { connectionCheckKeys } from "../api/reactivity-keys";
 /** Freshness window for automatic revalidation: a HEALTHY verdict younger
   );
 }
+/**
+ * Run one probe against its OWN per-connection atom and await that atom's
+ * result. The shared `checkConnectionHealth` mutation cannot be awaited from a
+ * loop: every `set` interrupts the previous call and every waiter resolves
+ * with whichever call settled last, so a list of N rows would hand N-1 rows a
+ * verdict for a connection that is not theirs (see `checkConnectionHealthFor`).
+ * This is the same set-then-await that `useAtomSet` performs in promise mode,
+ * addressed at the connection's atom, and usable from a loop.
+ */
+function useProbeConnection(): (
+  connection: Connection,
+  args: CheckConnectionHealthArgs,
+) => Promise<Exit.Exit<HealthCheckResult, unknown>> {
+  const registry = useContext(RegistryContext);
+  return useCallback(
+    (connection: Connection, args: CheckConnectionHealthArgs) => {
+      const atom = checkConnectionHealthFor(connection.address);
+      registry.set(atom, args);
+      return Effect.runPromiseExit(
+        AtomRegistry.getResult(registry, atom, { suspendOnWaiting: true }),
+      );
+    },
+    [registry],
+  );
+}
 /**
  * Health for ONE connection, stale-while-revalidate. The persisted verdict
  * renders instantly; a background probe on mount corrects it in place (once
   // A live probe result, once a check has run; merged with the persisted
   // verdict by freshness (see freshestVerdict for why not live-always-wins).
   const [liveProbe, setLiveProbe] = useState<HealthCheckResult | null>(null);
-  const doCheck = useAtomSet(checkConnectionHealth, { mode: "promiseExit" });
+  const doCheck = useProbeConnection();
   const invalidateConnections = useInvalidateConnections();
   const probe = freshestVerdict(liveProbe, connection.lastHealth);
     seenEpoch.current = epoch;
     if (!firstSight && !cleared) return;
     if (healthyAndFresh(last)) return;
-    void doCheck({
+    void doCheck(connection, {
       params: connectionParams(connection),
       query: revalidateQuery(last),
     }).then((exit) => {
     // Manual "Check now": invalidate the connections cache unconditionally so
     // every surface picks up the freshly persisted verdict. Adopting the
     // result's epoch keeps the resulting refetch from re-probing.
-    const exit = await doCheck({
+    const exit = await doCheck(connection, {
       params: connectionParams(connection),
       query: {},
       reactivityKeys: connectionCheckKeys,
   connections: readonly Connection[],
 ): (connection: Connection) => HealthCheckResult | null {
   const [liveProbes, setLiveProbes] = useState<ReadonlyMap<string, HealthCheckResult>>(new Map());
-  const doCheck = useAtomSet(checkConnectionHealth, { mode: "promiseExit" });
+  const doCheck = useProbeConnection();
   const invalidateConnections = useInvalidateConnections();
   // Once per VERDICT per connection (same epoch guard as the single-connection
       if (revalidated.current.has(key) && revalidated.current.get(key) === epoch) continue;
       revalidated.current.set(key, epoch);
       if (healthyAndFresh(last)) continue;
-      void doCheck({
+      void doCheck(connection, {
         params: connectionParams(connection),
         query: revalidateQuery(last),
       }).then((exit) => {

Probe connection health through a per-connection atom (#2071)

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code