graph-crawler 5.4.1__tar.gz → 5.4.2__tar.gz

{graph_crawler-5.4.1 → graph_crawler-5.4.2}/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 5.4.2 — 2026-10
+
+### Fixed
+
+- **A frozen browser tab no longer holds the crawl until the crawl-level timeout** (Parser `WEB_GRAF_ISSUES.md` §6,
+  NEW-3-5). After `fetch_timeout` the playwright fetcher asked the tab for partial HTML (`page.content()`) and
+  provenance (`page.evaluate`) without any bound; a tab whose renderer is busy with page script never answers, so the
+  worker hung (`Crawl-level timeout … in_flight=1`, ~12 min idle per scan in production). Recovery is now bounded by
+  `TIMEOUT_RECOVERY_S` (5 s); an unresponsive tab is logged (`Browser tab frozen after fetch timeout`) and closed, the
+  pool opens a fresh one. A slow but alive tab still returns partial HTML as before.
+- **Worker-pool stall watchdog for browser drivers.** If no node finishes for
+  `2 × driver.fetch_timeout + node_enrich_timeout + 10 s`, stuck workers are cancelled (`Worker pool stalled`) and the
+  pool stops; with a non-empty frontier the stop is recorded as `stalled`. HTTP drivers are not affected.
+- Tests: `tests/test_new_3_5_stalled_browser_pool.py` (real Chromium part: `GC_TEST_REAL_BROWSER=1`).
+
 ## 5.4.1 — 2026-10
 
 ### Fixed

{graph_crawler-5.4.1/graph_crawler.egg-info → graph_crawler-5.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graph-crawler
-Version: 5.4.1
+Version: 5.4.2
 Summary: Web crawler that builds a graph of a site. HTTP → TLS → browser escalation with pluggable browser engines.
 Author: 0-EternalJunior-0
 Maintainer: 0-EternalJunior-0

{graph_crawler-5.4.1 → graph_crawler-5.4.2}/graph_crawler/application/use_cases/crawling/crawl_coordinator.py

@@ -42,6 +42,7 @@ from graph_crawler.shared.constants import (
     BROWSER_PAGE_RAM_ESTIMATE_MB,
     BROWSER_RAM_BASELINE_MB,
     DEFAULT_BATCH_SIZE,
+    DEFAULT_NODE_ENRICH_TIMEOUT,
     MAX_PAGES_LIMIT,
 )
 from graph_crawler.shared.utils.cgroup_limits import (
@@ -85,6 +86,12 @@ logger = logging.getLogger(__name__)
 # Скільки секунд після crawl-level timeout даємо in-flight нодам дозавершитись.
 TIMEOUT_DRAIN_GRACE_S = 1.0
 
+# NEW-3-5: браузерний пул «завис», якщо жодна нода не завершилась за
+# 2 × fetch_timeout + enrich-таймаут + запас (найдовший законний шлях однієї ноди).
+STALL_FETCH_TIMEOUT_MULTIPLIER = 2.0
+STALL_GRACE_S = 10.0
+STALL_CHECK_INTERVAL_S = 5.0
+
 
 def _stats_for_log(stats: dict) -> dict:
     """Копія stats для логу без шумового ``redirect_deduped_scanned=0``.
@@ -425,6 +432,14 @@ class CrawlCoordinator:
             asyncio.create_task(self._worker_loop(i, state), name=f"crawl-worker-{i}")
             for i in range(pool_size)
         ]
+        stall_timeout = self._resolve_stall_timeout()
+        watchdog = (
+            asyncio.create_task(
+                self._stall_watchdog(workers, state, stall_timeout), name="crawl-stall-watchdog"
+            )
+            if stall_timeout
+            else None
+        )
         try:
             await self._await_workers(workers, state)
         except asyncio.CancelledError:
@@ -436,6 +451,9 @@ class CrawlCoordinator:
             await asyncio.gather(*workers, return_exceptions=True)
             raise
         finally:
+            if watchdog is not None:
+                watchdog.cancel()
+                await asyncio.gather(watchdog, return_exceptions=True)
             self._pool_state = None
 
         if state.stop_reason == "timeout":
@@ -444,6 +462,8 @@ class CrawlCoordinator:
             self.spider, "stop_reason", None
         ):
             self._record_stop(state.stop_reason, "limit")
+        if state.stop_reason == "stalled" and not self.scheduler.is_empty():
+            self._record_stop("stalled", "limit")
 
         logger.debug(
             "Worker pool finished: %d nodes processed, reason=%s, %.1fs",
@@ -457,7 +477,8 @@ class CrawlCoordinator:
     async def _await_workers(self, workers: list[asyncio.Task], state: PoolState) -> None:
         """Чекає воркерів; при crawl-level timeout скасовує in-flight (інакше ретраї тягнуть хвіст)."""
         if self.timeout is None or not self.start_time:
-            await asyncio.gather(*workers)
+            done, _ = await asyncio.wait(workers)
+            self._raise_worker_errors(done)
             return
         deadline = self.start_time + self.timeout + TIMEOUT_DRAIN_GRACE_S
         done, pending = await asyncio.wait(workers, timeout=max(0.0, deadline - time.time()))
@@ -478,10 +499,53 @@ class CrawlCoordinator:
             for task in pending:
                 task.cancel()
             await asyncio.gather(*pending, return_exceptions=True)
+        self._raise_worker_errors(done)
+
+    @staticmethod
+    def _raise_worker_errors(done: set[asyncio.Task]) -> None:
+        """Скасований сторожем простою воркер — не помилка; справжню помилку воркера прокидаємо."""
         for task in done:
             if not task.cancelled() and task.exception() is not None:
                 raise task.exception()
 
+    def _resolve_stall_timeout(self) -> float | None:
+        """Поріг «пул завис» (NEW-3-5): лише для браузерних драйверів, що мають ``fetch_timeout``."""
+        if not _is_js_heavy_driver(self.driver):
+            return None
+        fetch_timeout = getattr(self.driver, "fetch_timeout", None)
+        if isinstance(fetch_timeout, bool) or not isinstance(fetch_timeout, (int, float)):
+            return None
+        if fetch_timeout <= 0:
+            return None
+        enrich_timeout = (
+            getattr(self.config, "node_enrich_timeout", None) or DEFAULT_NODE_ENRICH_TIMEOUT
+        )
+        return STALL_FETCH_TIMEOUT_MULTIPLIER * fetch_timeout + enrich_timeout + STALL_GRACE_S
+
+    async def _stall_watchdog(
+        self, workers: list[asyncio.Task], state: PoolState, stall_timeout: float
+    ) -> None:
+        """Жодна нода не завершилась за ``stall_timeout`` — вкладки зависли: скасовуємо їх, фаза завершується."""
+        interval = min(STALL_CHECK_INTERVAL_S, stall_timeout / 4)
+        while not state.stop:
+            await asyncio.sleep(interval)
+            idle = time.monotonic() - state.last_progress_at
+            if state.in_flight == 0 or idle < stall_timeout:
+                continue
+            logger.warning(
+                "Worker pool stalled: no page finished for %.0fs (limit %.0fs), in_flight=%d, "
+                "queue=%d, stuck=%s - cancelling stuck workers",
+                idle,
+                stall_timeout,
+                state.in_flight,
+                self.scheduler.size() if hasattr(self.scheduler, "size") else 0,
+                list(state.in_flight_urls)[:5],
+            )
+            state.request_stop("stalled")
+            for task in workers:
+                task.cancel()
+            return
+
     def _resolve_worker_pool_size(self) -> int:
         """N воркерів: override з конфігу → конкурентність драйвера → кап для JS-heavy.
 

{graph_crawler-5.4.1 → graph_crawler-5.4.2}/graph_crawler/application/use_cases/crawling/worker_pool.py

@@ -15,6 +15,7 @@ from __future__ import annotations
 
 import asyncio
 import logging
+import time
 from collections import defaultdict
 from urllib.parse import urlsplit
 
@@ -119,6 +120,8 @@ class PoolState:
         self.stop = False
         self.stop_reason: str | None = None
         self.wakeup = asyncio.Event()
+        # NEW-3-5: час останньої завершеної ноди — сторож простою пулу.
+        self.last_progress_at = time.monotonic()
 
     def request_stop(self, reason: str) -> None:
         if not self.stop:
@@ -141,6 +144,7 @@ class PoolState:
         """Повертає True, якщо eviction-watermark просунувся."""
         self.in_flight -= 1
         self.completed += 1
+        self.last_progress_at = time.monotonic()
         if node_id:
             self.in_flight_node_ids.discard(node_id)
         self.in_flight_urls.pop(url, None)

{graph_crawler-5.4.1 → graph_crawler-5.4.2}/graph_crawler/infrastructure/transport/playwright/page_fetch.py

@@ -28,6 +28,7 @@ from graph_crawler.infrastructure.transport.core.redirect_utils import (
 )
 from graph_crawler.infrastructure.transport.playwright.context import BrowserContext
 from graph_crawler.infrastructure.transport.playwright.stages import BrowserStage
+from graph_crawler.shared.utils.best_effort import close_quietly
 from graph_crawler.shared.utils.shadow_dom import expose_shadow_roots
 
 logger = logging.getLogger(__name__)
@@ -49,6 +50,11 @@ logger = logging.getLogger(__name__)
 # =============================================================================
 PARTIAL_TIMEOUT_STATUS = 504
 
+# NEW-3-5: після fetch_timeout вкладку ще питають про частковий HTML і адресу; зависла вкладка
+# (скрипт сторінки тримає її) не відповідає ніколи — без ліміту воркер чекав до кінця фази.
+TIMEOUT_RECOVERY_S = 5.0
+FROZEN_PAGE_CLOSE_S = 3.0
+
 # ``page.content()`` серіалізує лише light DOM: вміст відкритих shadow root'ів (веб-компоненти,
 # Lit/Stencil/Salesforce LWC, вбудовані віджети цін) у HTML не потрапляє, і парсер «не бачить»
 # того, що бачить користувач. Якщо на сторінці є відкриті shadow root'и, серіалізуємо DOM
@@ -228,12 +234,7 @@ class PageFetcher:
                 timeout=float(self.fetch_timeout),
             )
         except asyncio.TimeoutError:
-            # Спробувати отримати частковий HTML що вже завантажився
-            partial_html = None
-            async with protect.suppress(
-                Exception, log=logger.debug, message="_fetch_with_page_impl"
-            ):
-                partial_html = await page.content()
+            partial_html, frozen = await self._partial_html_after_timeout(page, url)
             partial_html = self._drop_oversized_partial(partial_html, url)
 
             error_msg = f"Fetch timeout ({self.fetch_timeout}s) for {url}"
@@ -261,8 +262,18 @@ class PageFetcher:
             )
             # Навіть у fetch-timeout page.url може містити final URL.
             # Зберігаємо провенанс, щоб graph.handle_redirect() спрацював
-            # для timeout-нод з JS-редіректом.
-            ft_final, ft_chain, ft_hops = await self._build_playwright_provenance(url, page, None)
+            # для timeout-нод з JS-редіректом. Завислу вкладку не питаємо (NEW-3-5).
+            ft_final, ft_chain, ft_hops = url, [], []
+            if not frozen:
+                try:
+                    ft_final, ft_chain, ft_hops = await asyncio.wait_for(
+                        self._build_playwright_provenance(url, page, None),
+                        timeout=TIMEOUT_RECOVERY_S,
+                    )
+                except asyncio.TimeoutError:
+                    frozen = True
+            if frozen:
+                await self._close_frozen_page(page, url)
             return self._finalize_response(
                 FetchResponse(
                     url=url,
@@ -282,6 +293,27 @@ class PageFetcher:
             logger.error(error_msg)
             return FetchResponse(url=url, html=None, status_code=None, headers={}, error=error_msg)
 
+    @staticmethod
+    async def _partial_html_after_timeout(page: Any, url: str) -> tuple[str | None, bool]:
+        """Частковий HTML після fetch_timeout і ознака «вкладка зависла» (не відповіла за ``TIMEOUT_RECOVERY_S``)."""
+        try:
+            return await asyncio.wait_for(page.content(), timeout=TIMEOUT_RECOVERY_S), False
+        except asyncio.TimeoutError:
+            logger.warning(
+                "Browser tab frozen after fetch timeout: page.content() did not answer in %.0fs for %s",
+                TIMEOUT_RECOVERY_S,
+                url,
+            )
+            return None, True
+        except Exception as e:  # noqa: BLE001 — сторінка закрилась/переходить
+            logger.debug("partial content after timeout unavailable for %s: %s", url, e)
+            return None, False
+
+    @staticmethod
+    async def _close_frozen_page(page: Any, url: str) -> None:
+        """Закрита вкладка не повертається в пул — пул відкриє нову замість завислої."""
+        await close_quietly(page.close(), name=f"frozen page {url}", timeout=FROZEN_PAGE_CLOSE_S)
+
     @staticmethod
     def _log_fetch_timeout(
         error_msg: str,

{graph_crawler-5.4.1 → graph_crawler-5.4.2/graph_crawler.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graph-crawler
-Version: 5.4.1
+Version: 5.4.2
 Summary: Web crawler that builds a graph of a site. HTTP → TLS → browser escalation with pluggable browser engines.
 Author: 0-EternalJunior-0
 Maintainer: 0-EternalJunior-0

{graph_crawler-5.4.1 → graph_crawler-5.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "graph-crawler"
-version = "5.4.1"
+version = "5.4.2"
 description = "Web crawler that builds a graph of a site. HTTP → TLS → browser escalation with pluggable browser engines."
 readme = "README.md"
 requires-python = ">=3.11"