@crawlee/browser-pool 3.18.2-beta.3 → 3.18.2-beta.5

package/abstract-classes/browser-controller.d.ts

@@ -42,6 +42,7 @@ export declare abstract class BrowserController<Library extends CommonLibrary =
     isActive: boolean;
     activePages: number;
     private readonly closedPages;
+    private readonly pageTeardowns;
     totalPages: number;
     lastPageOpenedAt: number;
     private _activate;
@@ -82,9 +83,19 @@ export declare abstract class BrowserController<Library extends CommonLibrary =
      * Accounts for a page no longer being open. Callable from either side and safe to call twice:
      * the page's own `close` event, or the pool when it gives up on a close that never settles.
      * Tracked in a `WeakSet` rather than via `isClosed()`, because that reports the same event.
-     * @ignore
+     * @internal
      */
     registerPageClosed(page: NewPageResult): void;
+    /**
+     * Registers cleanup belonging to a single page: an anonymizing proxy server, an incognito
+     * context. It runs from `registerPageClosed`, so it happens whether the page closed on its own
+     * or the pool gave up on a close that never settled, and it runs at most once.
+     *
+     * Hanging it off the page's `close` event instead leaks it in exactly the case this controller
+     * now handles, because that event does not arrive for a page the browser never destroyed.
+     * @ignore
+     */
+    protected registerPageTeardown(page: NewPageResult, teardown: () => Promise<void>): void;
     setCookies(page: NewPageResult, cookies: Cookie[]): Promise<void>;
     getCookies(page: NewPageResult): Promise<Cookie[]>;
     /**

package/abstract-classes/browser-controller.js

@@ -88,6 +88,12 @@ class BrowserController extends tiny_typed_emitter_1.TypedEmitter {
             writable: true,
             value: new WeakSet()
         });
+        Object.defineProperty(this, "pageTeardowns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new WeakMap()
+        });
         Object.defineProperty(this, "totalPages", {
             enumerable: true,
             configurable: true,
@@ -205,13 +211,32 @@ class BrowserController extends tiny_typed_emitter_1.TypedEmitter {
      * Accounts for a page no longer being open. Callable from either side and safe to call twice:
      * the page's own `close` event, or the pool when it gives up on a close that never settles.
      * Tracked in a `WeakSet` rather than via `isClosed()`, because that reports the same event.
-     * @ignore
+     * @internal
      */
     registerPageClosed(page) {
         if (this.closedPages.has(page))
             return;
         this.closedPages.add(page);
         this.activePages--;
+        const teardown = this.pageTeardowns.get(page);
+        if (!teardown)
+            return;
+        this.pageTeardowns.delete(page);
+        teardown().catch((error) => {
+            logger_1.log.debug(`Could not clean up after a closed page.\nCause:${error.message}`, { id: this.id });
+        });
+    }
+    /**
+     * Registers cleanup belonging to a single page: an anonymizing proxy server, an incognito
+     * context. It runs from `registerPageClosed`, so it happens whether the page closed on its own
+     * or the pool gave up on a close that never settled, and it runs at most once.
+     *
+     * Hanging it off the page's `close` event instead leaks it in exactly the case this controller
+     * now handles, because that event does not arrive for a page the browser never destroyed.
+     * @ignore
+     */
+    registerPageTeardown(page, teardown) {
+        this.pageTeardowns.set(page, teardown);
     }
     async setCookies(page, cookies) {
         return this._setCookies(page, cookies);

package/browser-pool.js

@@ -604,7 +604,7 @@ class BrowserPool extends tiny_typed_emitter_1.TypedEmitter {
             let timeout;
             const finished = await Promise.race([
                 closing.then(() => true, (err) => {
-                    logger_1.log.warning(`Page close hook failed.\nCause:${err.message}`, {
+                    logger_1.log.warning(`Closing a page failed, releasing it from the pool anyway.\nCause:${err.message}`, {
                         id: browserController.id,
                         pageId,
                     });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@crawlee/browser-pool",
-    "version": "3.18.2-beta.3",
+    "version": "3.18.2-beta.5",
     "description": "Rotate multiple browsers using popular automation libraries such as Playwright or Puppeteer.",
     "engines": {
         "node": ">=16.0.0"
@@ -38,8 +38,8 @@
     "dependencies": {
         "@apify/log": "^2.4.0",
         "@apify/timeout": "^0.4.0",
-        "@crawlee/core": "3.18.2-beta.3",
-        "@crawlee/types": "3.18.2-beta.3",
+        "@crawlee/core": "3.18.2-beta.5",
+        "@crawlee/types": "3.18.2-beta.5",
         "fingerprint-generator": "^2.1.68",
         "fingerprint-injector": "^2.1.68",
         "lodash.merge": "^4.6.2",
@@ -70,5 +70,5 @@
             }
         }
     },
-    "gitHead": "feed328453d1967b36ccd45cc4531d44498915b8"
+    "gitHead": "d126d83399f7aa71bd0920d6a50b6bb9e6373790"
 }

package/playwright/playwright-controller.js

@@ -49,9 +49,9 @@ class PlaywrightController extends browser_controller_1.BrowserController {
         }
         try {
             const page = await this.browser.newPage(contextOptions);
-            page.once('close', async () => {
+            this.registerPageTeardown(page, close);
+            page.once('close', () => {
                 this.registerPageClosed(page);
-                await close();
             });
             if (this.launchContext.experimentalContainers) {
                 await page.goto('data:text/plain,tabid');

package/puppeteer/puppeteer-controller.js

@@ -55,17 +55,18 @@ class PuppeteerController extends browser_controller_1.BrowserController {
                     tryCancel();
                 }
                 */
-                page.once('close', async () => {
-                    this.registerPageClosed(page);
-                    try {
-                        await context.close();
-                    }
-                    catch (error) {
+                this.registerPageTeardown(page, async () => {
+                    // The proxy server is not chained behind the context close: that can hang on
+                    // the same target the page hung on, and the proxy runs in this process, so it
+                    // has to be reclaimed either way.
+                    const contextClosed = context.close().catch((error) => {
                         logger_1.log.exception(error, 'Failed to close context.');
-                    }
-                    finally {
-                        await close();
-                    }
+                    });
+                    await close();
+                    await contextClosed;
+                });
+                page.once('close', () => {
+                    this.registerPageClosed(page);
                 });
                 return page;
             }