Skip to content

Infisical is the open-source platform for securing secrets, certificates, access, and AI Agents.

set timeout

Thiago Araujo da Silva1afba435185a
diff --git a/backend/src/services/org/org-access-sweep-queue.test.ts b/backend/src/services/org/org-access-sweep-queue.test.ts
index 181055e3f3..a8f664375e 100644
--- a/backend/src/services/org/org-access-sweep-queue.test.ts
+++ b/backend/src/services/org/org-access-sweep-queue.test.ts
@@ -1,7 +1,11 @@
import { ActorType } from "@app/services/auth/auth-type";
import { TEventInput } from "@app/services/event-outbox/event-outbox-types";
-import { ORG_ACCESS_SWEEP_LIMIT, orgAccessSweepQueueFactory } from "./org-access-sweep-queue";
+import {
+ ORG_ACCESS_SWEEP_LIMIT,
+ ORG_ACCESS_SWEEP_STATEMENT_TIMEOUT_MS,
+ orgAccessSweepQueueFactory
+} from "./org-access-sweep-queue";
import { ORG_MEMBERSHIP_REMOVED_EVENT } from "./org-membership-events";
const { loggerWarn, appCfg } = vi.hoisted(() => ({
@@ -21,28 +25,33 @@ const ORG_B = uuid(2);
const build = (orphans: { actorUserId: string | null; actorIdentityId: string | null; scopeOrgId: string }[]) => {
const emitted: TEventInput[] = [];
const register = vi.fn();
+ const findOrphanedProjectActors = vi.fn().mockResolvedValue(orphans);
const queue = orgAccessSweepQueueFactory({
cronJob: { register } as never,
- orgDAL: { findOrphanedProjectActors: vi.fn().mockResolvedValue(orphans) },
+ orgDAL: { findOrphanedProjectActors },
eventEmitter: {
emit: async (event) => {
emitted.push(event);
}
}
});
- return { queue, emitted, register };
+ return { queue, emitted, register, findOrphanedProjectActors };
};
describe("orgAccessSweepQueue", () => {
beforeEach(() => loggerWarn.mockClear());
test("reports each orphaned actor as a removed org membership", async () => {
- const { queue, emitted } = build([
+ const { queue, emitted, findOrphanedProjectActors } = build([
{ actorUserId: uuid(10), actorIdentityId: null, scopeOrgId: ORG_A },
{ actorUserId: null, actorIdentityId: uuid(20), scopeOrgId: ORG_B }
]);
expect(await queue.runSweep()).toEqual({ orphans: 2 });
+ expect(findOrphanedProjectActors).toHaveBeenCalledWith({
+ limit: ORG_ACCESS_SWEEP_LIMIT,
+ statementTimeoutMs: ORG_ACCESS_SWEEP_STATEMENT_TIMEOUT_MS
+ });
expect(emitted).toEqual([
{
eventType: ORG_MEMBERSHIP_REMOVED_EVENT,
diff --git a/backend/src/services/org/org-access-sweep-queue.ts b/backend/src/services/org/org-access-sweep-queue.ts
index 4b4d1469b5..da5d0e64ef 100644
--- a/backend/src/services/org/org-access-sweep-queue.ts
+++ b/backend/src/services/org/org-access-sweep-queue.ts
@@ -7,6 +7,7 @@ import { TOrgDALFactory } from "./org-dal";
import { emitOrgMembershipRemoved, toOrgMembershipActors } from "./org-membership-events";
export const ORG_ACCESS_SWEEP_LIMIT = 5000;
+export const ORG_ACCESS_SWEEP_STATEMENT_TIMEOUT_MS = 3 * 60_000;
type TOrgAccessSweepQueueDep = {
cronJob: TCronJobFactory;
@@ -20,7 +21,10 @@ export type TOrgAccessSweepQueueFactory = ReturnType<typeof orgAccessSweepQueueF
// an org membership removal for each. Also cleans up data from before the events existed.
export const orgAccessSweepQueueFactory = ({ cronJob, orgDAL, eventEmitter }: TOrgAccessSweepQueueDep) => {
const runSweep = async () => {
- const orphans = await orgDAL.findOrphanedProjectActors({ limit: ORG_ACCESS_SWEEP_LIMIT });
+ const orphans = await orgDAL.findOrphanedProjectActors({
+ limit: ORG_ACCESS_SWEEP_LIMIT,
+ statementTimeoutMs: ORG_ACCESS_SWEEP_STATEMENT_TIMEOUT_MS
+ });
for await (const orphan of orphans) {
await emitOrgMembershipRemoved(eventEmitter, {
diff --git a/backend/src/services/org/org-dal.ts b/backend/src/services/org/org-dal.ts
index 13a0a87fa2..2f383e37cf 100644
--- a/backend/src/services/org/org-dal.ts
+++ b/backend/src/services/org/org-dal.ts
@@ -1235,12 +1235,17 @@ export const orgDALFactory = (db: TDbClient) => {
};
// (actor, org) pairs with a project row in an org the actor no longer reaches. Skips ghost users (project
- // bots), they never have an org row.
- const findOrphanedProjectActors = async ({ limit }: { limit: number }, tx?: Knex) => {
- try {
- const conn = tx || db.replicaNode();
- const m = TableName.Membership;
+ // bots), they never have an org row. One streaming pass over the project rows against a hash of the org
+ // rows; collapsing to distinct pairs first was measured and only moved the cost into an aggregate.
+ // Without a caller's tx it runs in its own replica transaction so `statementTimeoutMs` bounds it: a
+ // backstop that overruns should fail and log, not keep the replica busy after the cron has given up on it.
+ const findOrphanedProjectActors = async (
+ { limit, statementTimeoutMs }: { limit: number; statementTimeoutMs?: number },
+ tx?: Knex
+ ) => {
+ const m = TableName.Membership;
+ const query = async (conn: Knex): Promise<TOrphanedProjectActor[]> => {
const noDirectOrgRow = (actorColumn: "actorUserId" | "actorIdentityId") =>
conn
.select(conn.raw("1"))
@@ -1286,7 +1291,15 @@ export const orgDALFactory = (db: TDbClient) => {
actorIdentityId: row.actorIdentityId,
scopeOrgId: row.scopeOrgId
}))
- ] as TOrphanedProjectActor[];
+ ];
+ };
+
+ try {
+ if (tx) return await query(tx);
+ return await db.replicaNode().transaction(async (trx) => {
+ if (statementTimeoutMs) await trx.raw(`SET LOCAL statement_timeout = ${Math.floor(statementTimeoutMs)}`);
+ return query(trx);
+ });
} catch (error) {
throw new DatabaseError({ error, name: "FindOrphanedProjectActors" });
}