Skip to content
TypeScript

perf(server): the headless browser closes after five idle minutes (517 MiB → 1.6 MiB median) (#30306)

Andrei93dbf53db313
diff --git a/apps/server/src/preview/ServerBrowser.ts b/apps/server/src/preview/ServerBrowser.ts
index 6b92e33ce96..264a875bf6f 100644
--- a/apps/server/src/preview/ServerBrowser.ts
+++ b/apps/server/src/preview/ServerBrowser.ts
@@ -501,6 +501,7 @@ const make = Effect.gen(function* () {
const contexts = new ServerBrowserContexts({
profilesDir: NodePath.join(config.stateDir, "server-browser", "profiles"),
+ idleBrowserMs: 5 * 60_000,
executable: () => runPromise(previewBrowser.executable),
// An agent scope keeps Chrome out of the server's memory protection and OOM score.
launcher: async (executable) => {
diff --git a/apps/server/src/preview/ServerBrowserContexts.test.ts b/apps/server/src/preview/ServerBrowserContexts.test.ts
index 522df30fb66..99504e86cb1 100644
--- a/apps/server/src/preview/ServerBrowserContexts.test.ts
+++ b/apps/server/src/preview/ServerBrowserContexts.test.ts
@@ -22,6 +22,8 @@ const makeContext = () => {
return {
on: vi.fn((event: string, listener: () => void) => events.on(event, listener)),
pages: vi.fn(() => []),
+ newPage: vi.fn(async () => ({ once: vi.fn() })),
+ isClosed: () => closed,
close: vi.fn(async () => {
if (!closed) {
closed = true;
@@ -35,7 +37,8 @@ const makeBrowser = () => {
const events = new NodeEvents.EventEmitter();
const contexts: ReturnType<typeof makeContext>[] = [];
return {
- contexts,
+ created: contexts,
+ contexts: () => contexts.filter((context) => !context.isClosed()),
on: vi.fn((event: string, listener: () => void) => events.on(event, listener)),
newContext: vi.fn(async () => {
const context = makeContext();
@@ -74,6 +77,37 @@ beforeEach(() => {
});
describe("ServerBrowserContexts", () => {
+ it("closes the shared browser only after it holds no context for the idle period", async () => {
+ vi.useFakeTimers();
+ try {
+ const first = makeBrowser();
+ const second = makeBrowser();
+ launches.launch
+ .mockResolvedValueOnce(first as unknown as Browser)
+ .mockResolvedValueOnce(second as unknown as Browser);
+ const pool = new ServerBrowserContexts({ ...options(), idleBrowserMs: 10 });
+ const agent = await pool.contextFor("default", "agent");
+ await pool.scratchPage();
+ await agent.close();
+ await vi.advanceTimersByTimeAsync(10);
+ expect(first.close).not.toHaveBeenCalled();
+ await first.created[1]!.close();
+ await vi.advanceTimersByTimeAsync(9);
+ const next = await pool.contextFor("default", "next");
+ await vi.advanceTimersByTimeAsync(10);
+ expect(first.close).not.toHaveBeenCalled();
+ await next.close();
+ await vi.advanceTimersByTimeAsync(10);
+ expect(first.close).toHaveBeenCalledOnce();
+ await pool.contextFor("default", "later");
+ expect(launches.launch).toHaveBeenCalledTimes(2);
+ expect(second.newContext).toHaveBeenCalledOnce();
+ await pool.close();
+ } finally {
+ vi.useRealTimers();
+ }
+ });
+
it("lazily shares one browser across concurrent isolated sessions and reuses each context", async () => {
const browser = makeBrowser();
const launch = Promise.withResolvers<Browser>();
@@ -107,7 +141,7 @@ describe("ServerBrowserContexts", () => {
});
await pool.close();
expect(browser.close).toHaveBeenCalledTimes(1);
- for (const context of browser.contexts) expect(context.close).toHaveBeenCalled();
+ for (const context of browser.created) expect(context.close).toHaveBeenCalled();
});
it("keeps human profiles persistent without sharing their storage with agents", async () => {
@@ -172,7 +206,7 @@ describe("ServerBrowserContexts", () => {
force: true,
});
expect(await pool.contextFor("work/team", "agent")).toBe(agent);
- expect(browser.contexts[0]?.close).not.toHaveBeenCalled();
+ expect(browser.created[0]?.close).not.toHaveBeenCalled();
launches.persistent.mockResolvedValue(makeContext() as unknown as BrowserContext);
expect(await pool.contextFor("work/team")).not.toBe(persistent);
await pool.clearProfile("never-opened");
@@ -291,6 +325,6 @@ describe("ServerBrowserContexts", () => {
await expect(pool.contextFor("default", "agent")).rejects.toThrow("closed");
await pool.close();
expect(browser.close).toHaveBeenCalledTimes(1);
- expect(browser.contexts[0]?.close).toHaveBeenCalled();
+ expect(browser.created[0]?.close).toHaveBeenCalled();
});
});
diff --git a/apps/server/src/preview/ServerBrowserContexts.ts b/apps/server/src/preview/ServerBrowserContexts.ts
index 2a7c342d30d..365add7565c 100644
--- a/apps/server/src/preview/ServerBrowserContexts.ts
+++ b/apps/server/src/preview/ServerBrowserContexts.ts
@@ -1,4 +1,4 @@
-// @effect-diagnostics nodeBuiltinImport:off - Owns Playwright resources outside the Effect runtime.
+// @effect-diagnostics nodeBuiltinImport:off globalTimers:off -- Owns Playwright resources and their idle timer outside the Effect runtime.
import { INCOGNITO_BROWSER_PROFILE_ID } from "@t3tools/contracts";
import { constVoid } from "effect/Function";
import * as NodeFSP from "node:fs/promises";
@@ -26,6 +26,8 @@ interface Options {
) => Promise<{ readonly path: string; readonly release: () => Promise<void> } | undefined>;
readonly diagnose?: (executable: string, cause: unknown) => Promise<unknown>;
readonly env?: NodeJS.ProcessEnv;
+ /** Closes the shared browser once it has held no context for this long. */
+ readonly idleBrowserMs?: number;
readonly onContextClose?: (context: BrowserContext) => void;
}
@@ -80,6 +82,8 @@ export class ServerBrowserContexts {
private readonly clearing = new Map<string, Promise<void>>();
private browser: Promise<Browser> | undefined;
private closing: Promise<void> | undefined;
+ private idleTimer: ReturnType<typeof setTimeout> | undefined;
+ private pendingSharedContexts = 0;
constructor(options: Options) {
this.options = options;
@@ -136,6 +140,37 @@ export class ServerBrowserContexts {
return this.browser;
}
+ private async sharedContext(options?: Parameters<Browser["newContext"]>[0]) {
+ clearTimeout(this.idleTimer);
+ this.pendingSharedContexts++;
+ const launched = this.sharedBrowser();
+ try {
+ const context = await (await launched).newContext(options);
+ context.on("close", () => this.retireWhenIdle(launched));
+ return context;
+ } finally {
+ this.pendingSharedContexts--;
+ this.retireWhenIdle(launched);
+ }
+ }
+
+ private retireWhenIdle(launched: Promise<Browser>) {
+ const delay = this.options.idleBrowserMs;
+ if (delay === undefined || this.closing || this.pendingSharedContexts > 0) return;
+ clearTimeout(this.idleTimer);
+ this.idleTimer = setTimeout(() => void this.retire(launched), delay);
+ this.idleTimer.unref();
+ }
+
+ private async retire(launched: Promise<Browser>) {
+ const browser = await launched.catch(() => undefined);
+ if (!browser || this.browser !== launched || this.pendingSharedContexts > 0) return;
+ if (browser.contexts().length > 0) return;
+ // Cleared first, so a request during the close launches a fresh browser.
+ this.browser = undefined;
+ await browser.close().catch(constVoid);
+ }
+
contextFor(profileId: string, isolationKey?: string): Promise<BrowserContext> {
if (this.closing) return Promise.reject(new Error("The preview browser is closed."));
const key = JSON.stringify([profileId, isolationKey ?? null]);
@@ -166,8 +201,7 @@ export class ServerBrowserContexts {
private async createContext(profileId: string, isolationKey?: string) {
const contextOptions = { viewport: { width: 1280, height: 800 }, deviceScaleFactor: 2 };
if (isolationKey !== undefined || profileId === INCOGNITO_BROWSER_PROFILE_ID) {
- const browser = await this.sharedBrowser();
- return browser.newContext(contextOptions);
+ return this.sharedContext(contextOptions);
}
const directory = this.profileDirectory(profileId);
await NodeFSP.mkdir(directory, { recursive: true });
@@ -192,7 +226,7 @@ export class ServerBrowserContexts {
async scratchPage() {
if (this.closing) throw new Error("The preview browser is closed.");
- const context = await (await this.sharedBrowser()).newContext();
+ const context = await this.sharedContext();
const page = await context.newPage();
page.once("close", () => void context.close().catch(constVoid));
return page;
@@ -237,6 +271,7 @@ export class ServerBrowserContexts {
}
private async dispose() {
+ clearTimeout(this.idleTimer);
await Promise.allSettled(
[...this.contexts.values()].map(async (pending) => (await pending).close()),
);