potential performance upgrade

Dockers/puppeteer-api/app/utils/browser_utils.py

@@ -12,42 +12,49 @@ async def wait_for_network_idle(page):
     await page.wait_for_load_state('networkidle')
 
 async def safe_browser_operation(url, operation_func):
-    """Safely perform browser operations with proper cleanup"""
+    """Safely perform browser operations with proper cleanup and timeouts"""
     browser = None
     context = None
     page = None
     playwright = None
 
     try:
-        # Get or create playwright instance
-        playwright = await async_playwright().start()
+        # Get or create playwright instance with timeout
+        playwright = await asyncio.wait_for(async_playwright().start(), timeout=30.0)
 
-        browser = await playwright.chromium.launch(
+        browser = await asyncio.wait_for(playwright.chromium.launch(
             headless=True,
-            args=['--no-sandbox', '--disable-setuid-sandbox'],
-        )
+            args=['--no-sandbox', '--disable-setuid-sandbox', '--max_old_space_size=256'],
+        ), timeout=30.0)
 
-        # Create context and page
-        context = await browser.new_context(
+        # Create context and page with timeout
+        context = await asyncio.wait_for(browser.new_context(
             user_agent=CUSTOM_USER_AGENT,
             viewport={'width': 1920, 'height': 1080},
             ignore_https_errors=True,
-        )
+        ), timeout=10.0)
 
-        page = await context.new_page()
-        page.set_default_timeout(30000)
+        page = await asyncio.wait_for(context.new_page(), timeout=10.0)
+        page.set_default_timeout(30000)  # 30 second timeout
 
         # Track page creation time for force cleanup
         page_creation_times[page] = time.time()
         active_pages.add(page)
 
-        # Call the operation function that uses the page
-        result = await operation_func(page)
+        # Call the operation function that uses the page with timeout
+        result = await asyncio.wait_for(operation_func(page), timeout=60.0)
 
         return result
 
+    except asyncio.TimeoutError as e:
+        print(f"Browser operation timeout for {url}: {e}")
+        return {
+            "status": "error",
+            "error": f"Operation timeout: {str(e)}",
+            "url": url
+        }
     except Exception as e:
-        print(f"Error during browser operation: {e}")
+        print(f"Error during browser operation for {url}: {e}")
         # Return error result instead of re-raising to allow graceful handling
         return {
             "status": "error",
@@ -55,7 +62,7 @@ async def safe_browser_operation(url, operation_func):
             "url": url
         }
     finally:
-        # Cleanup page tracking
+        # Cleanup page tracking with timeout
         if page:
             try:
                 # Remove from tracking
@@ -63,29 +70,38 @@ async def safe_browser_operation(url, operation_func):
                     active_pages.remove(page)
                 if page in page_creation_times:
                     del page_creation_times[page]
-                await page.close()
-            except Exception as e:
+                await asyncio.wait_for(page.close(), timeout=5.0)
+            except (asyncio.TimeoutError, Exception) as e:
                 print(f"Error closing page: {e}")
+                try:
+                    await page.close(force=True)
+                except:
+                    pass
 
-        # Ensure context is closed properly
+        # Ensure context is closed properly with timeout
         if context:
             try:
-                await context.close()
-            except Exception as e:
+                await asyncio.wait_for(context.close(), timeout=5.0)
+            except (asyncio.TimeoutError, Exception) as e:
                 print(f"Error closing context: {e}")
 
-        # Ensure browser is closed properly
+        # Ensure browser is closed properly with timeout
         if browser:
             try:
-                await browser.close()
+                await asyncio.wait_for(browser.close(), timeout=10.0)
+            except asyncio.TimeoutError:
+                try:
+                    await browser.close(force=True)
+                except:
+                    pass
             except Exception as e:
                 print(f"Error closing browser: {e}")
 
-        # Ensure playwright is closed properly - THIS IS THE KEY FIX
+        # Ensure playwright is closed properly with timeout - THIS IS THE KEY FIX
         if playwright:
             try:
-                await playwright.stop()
-            except Exception as e:
+                await asyncio.wait_for(playwright.stop(), timeout=10.0)
+            except (asyncio.TimeoutError, Exception) as e:
                 print(f"Error closing playwright: {e}")
 
 async def force_cleanup_old_pages():