Eric Allam
567e2a2c32
## Summary
During an ElastiCache role swap (failover) or node-type change (vertical
scale), the ioredis TCP/TLS connection stays open but the server starts
answering with `READONLY` (the client is talking to a node that became a
replica) or `LOADING` (node still loading data from disk). Without an
explicit hook, those errors surface to caller code as `ReplyError`
instances — every write op on the affected connection fails until the
cluster fully cuts over.
This PR adds `reconnectOnError` to every prod ioredis client so the
disconnect + reconnect + retry cycle absorbs these errors and caller
code never sees them.
## Fix
```ts
export function defaultReconnectOnError(err: Error): boolean | 1 | 2 {
const msg = err.message ?? "";
if (msg.startsWith("READONLY") || msg.startsWith("LOADING")) return 2;
return false;
}
```
Returning `2` tells ioredis to disconnect, reconnect, and re-issue the
failed command. After reconnect, DNS / SG state routes the new socket to
a writable node.
The helper lives in `@internal/redis` and is wired into both the shared
`createRedisClient` (which covers RunQueue, schedule-engine,
redis-worker, and every other internal-package consumer) and the direct
`new Redis(...)` call sites in the webapp.
V1-only marqs files are intentionally not migrated.
## Test plan
- [x] `pnpm run typecheck --filter webapp`
- [x] `pnpm run typecheck --filter @internal/run-engine`
- [x] Verified end-to-end against a live ElastiCache vertical-scale
event — caller-surfaced errors went from tens of thousands during the
cutover window down to a handful per ioredis client
- [ ] Confirm steady-state behavior unchanged after deploy
103 lines
2.6 KiB
TypeScript
103 lines
2.6 KiB
TypeScript
import { Redis } from "ioredis";
|
|
import { defaultReconnectOnError } from "@internal/redis";
|
|
import { env } from "~/env.server";
|
|
import { singleton } from "~/utils/singleton";
|
|
import { logger } from "./logger.server";
|
|
|
|
const KEY_PREFIX = "isw:";
|
|
const DEFAULT_TTL_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
|
|
|
|
function buildKey(runFriendlyId: string, streamId: string): string {
|
|
return `${KEY_PREFIX}${runFriendlyId}:${streamId}`;
|
|
}
|
|
|
|
function initializeRedis(): Redis | undefined {
|
|
const host = env.CACHE_REDIS_HOST;
|
|
if (!host) {
|
|
return undefined;
|
|
}
|
|
|
|
return new Redis({
|
|
connectionName: "inputStreamWaitpointCache",
|
|
host,
|
|
port: env.CACHE_REDIS_PORT,
|
|
username: env.CACHE_REDIS_USERNAME,
|
|
password: env.CACHE_REDIS_PASSWORD,
|
|
keyPrefix: "tr:",
|
|
enableAutoPipelining: true,
|
|
reconnectOnError: defaultReconnectOnError,
|
|
...(env.CACHE_REDIS_TLS_DISABLED === "true" ? {} : { tls: {} }),
|
|
});
|
|
}
|
|
|
|
const redis = singleton("inputStreamWaitpointCache", initializeRedis);
|
|
|
|
/**
|
|
* Store a mapping from input stream to waitpoint ID in Redis.
|
|
* Called when `.wait()` creates a new waitpoint.
|
|
*/
|
|
export async function setInputStreamWaitpoint(
|
|
runFriendlyId: string,
|
|
streamId: string,
|
|
waitpointId: string,
|
|
ttlMs?: number
|
|
): Promise<void> {
|
|
if (!redis) return;
|
|
|
|
try {
|
|
const key = buildKey(runFriendlyId, streamId);
|
|
await redis.set(key, waitpointId, "PX", ttlMs ?? DEFAULT_TTL_MS);
|
|
} catch (error) {
|
|
logger.error("Failed to set input stream waitpoint cache", {
|
|
runFriendlyId,
|
|
streamId,
|
|
error,
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the waitpoint ID for an input stream without deleting it.
|
|
* Called from the `.send()` route before completing the waitpoint.
|
|
*/
|
|
export async function getInputStreamWaitpoint(
|
|
runFriendlyId: string,
|
|
streamId: string
|
|
): Promise<string | null> {
|
|
if (!redis) return null;
|
|
|
|
try {
|
|
const key = buildKey(runFriendlyId, streamId);
|
|
return await redis.get(key);
|
|
} catch (error) {
|
|
logger.error("Failed to get input stream waitpoint cache", {
|
|
runFriendlyId,
|
|
streamId,
|
|
error,
|
|
});
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Delete the cache entry for an input stream waitpoint.
|
|
* Called when a waitpoint is completed or timed out.
|
|
*/
|
|
export async function deleteInputStreamWaitpoint(
|
|
runFriendlyId: string,
|
|
streamId: string
|
|
): Promise<void> {
|
|
if (!redis) return;
|
|
|
|
try {
|
|
const key = buildKey(runFriendlyId, streamId);
|
|
await redis.del(key);
|
|
} catch (error) {
|
|
logger.error("Failed to delete input stream waitpoint cache", {
|
|
runFriendlyId,
|
|
streamId,
|
|
error,
|
|
});
|
|
}
|
|
}
|