Autozones creation async with self.engine: which creates a nested context when the client is already used as a context manager. This causes the session lifecycle issues.

Author: vzucher

src/brightdata/client.py

@@ -368,6 +368,7 @@ async def get_account_info(self) -> AccountInfo:
             return self._account_info
 
         try:
+            # Engine context manager is idempotent, safe to enter multiple times
             async with self.engine:
                 async with self.engine.get_from_url(
                     f"{self.engine.BASE_URL}/zone/get_active_zones"
@@ -416,14 +417,44 @@ async def get_account_info(self) -> AccountInfo:
         except Exception as e:
             raise APIError(f"Unexpected error getting account info: {str(e)}")
 
+    def _run_async_with_cleanup(self, coro):
+        """
+        Run an async coroutine with proper cleanup.
+        
+        This helper ensures that the event loop stays open long enough
+        for all sessions and connectors to close properly, preventing
+        "Unclosed client session" warnings.
+        """
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            result = loop.run_until_complete(coro)
+            # Give pending tasks and cleanup handlers time to complete
+            # This is crucial for aiohttp session cleanup
+            loop.run_until_complete(asyncio.sleep(0.25))
+            return result
+        finally:
+            try:
+                # Cancel any remaining tasks
+                pending = asyncio.all_tasks(loop)
+                for task in pending:
+                    task.cancel()
+                # Run the loop once more to process cancellations
+                if pending:
+                    loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
+                # Final sleep to ensure all cleanup completes
+                loop.run_until_complete(asyncio.sleep(0.1))
+            finally:
+                loop.close()
+    
     def get_account_info_sync(self) -> AccountInfo:
         """Synchronous version of get_account_info()."""
-        return asyncio.run(self.get_account_info())
+        return self._run_async_with_cleanup(self.get_account_info())
 
     def test_connection_sync(self) -> bool:
         """Synchronous version of test_connection()."""
         try:
-            return asyncio.run(self.test_connection())
+            return self._run_async_with_cleanup(self.test_connection())
         except Exception:
             return False
 

src/brightdata/core/engine.py

@@ -3,6 +3,7 @@
 import asyncio
 import aiohttp
 import ssl
+import warnings
 from typing import Optional, Dict, Any
 from datetime import datetime, timezone
 from ..exceptions import APIError, AuthenticationError, NetworkError, TimeoutError, SSLError
@@ -16,6 +17,12 @@
 except ImportError:
     HAS_RATE_LIMITER = False
 
+# Suppress aiohttp ResourceWarnings for unclosed sessions
+# We properly manage session lifecycle in context managers, but Python's 
+# resource tracking may still emit warnings during rapid create/destroy cycles
+warnings.filterwarnings("ignore", category=ResourceWarning, message="unclosed.*<aiohttp")
+warnings.filterwarnings("ignore", category=ResourceWarning, message="unclosed.*<ssl.SSLSocket")
+
 
 class AsyncEngine:
     """
@@ -52,35 +59,81 @@ def __init__(
         self.timeout = aiohttp.ClientTimeout(total=timeout)
         self._session: Optional[aiohttp.ClientSession] = None
 
-        # Rate limiting
+        # Store rate limit config (create limiter per event loop in __aenter__)
         if rate_limit is None:
             rate_limit = self.DEFAULT_RATE_LIMIT
 
-        if HAS_RATE_LIMITER and rate_limit > 0:
-            self._rate_limiter: Optional[AsyncLimiter] = AsyncLimiter(
-                max_rate=rate_limit,
-                time_period=rate_period
-            )
-        else:
-            self._rate_limiter: Optional[AsyncLimiter] = None
+        self._rate_limit = rate_limit
+        self._rate_period = rate_period
+        self._rate_limiter: Optional[AsyncLimiter] = None
 
     async def __aenter__(self):
-        """Context manager entry."""
+        """Context manager entry - idempotent (safe to call multiple times)."""
+        # If session already exists, don't create a new one
+        # This handles nested context manager usage
+        if self._session is not None:
+            return self
+        
+        # Create connector with force_close=True to ensure proper cleanup
+        # This helps prevent "Unclosed connector" warnings
+        connector = aiohttp.TCPConnector(
+            limit=100,
+            limit_per_host=30,
+            force_close=True  # Force close connections on exit
+        )
+        
+        # Create session with the connector
         self._session = aiohttp.ClientSession(
+            connector=connector,
             timeout=self.timeout,
             headers={
                 "Authorization": f"Bearer {self.bearer_token}",
                 "Content-Type": "application/json",
                 "User-Agent": "brightdata-sdk/2.0.0",
             }
         )
+        
+        # Create rate limiter for this event loop (avoids reuse across loops)
+        if HAS_RATE_LIMITER and self._rate_limit > 0:
+            self._rate_limiter = AsyncLimiter(
+                max_rate=self._rate_limit,
+                time_period=self._rate_period
+            )
+        else:
+            self._rate_limiter = None
+        
         return self
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
-        """Context manager exit."""
+        """Context manager exit - ensures proper cleanup of resources."""
         if self._session:
-            await self._session.close()
+            # Store reference before clearing
+            session = self._session
             self._session = None
+            
+            # Close the session - this will also close the connector
+            await session.close()
+            
+            # Wait for underlying connections to close
+            # This is necessary to prevent "Unclosed client session" warnings
+            await asyncio.sleep(0.1)
+        
+        # Clear rate limiter
+        self._rate_limiter = None
+    
+    def __del__(self):
+        """Cleanup on garbage collection."""
+        # If session wasn't properly closed (shouldn't happen with proper usage),
+        # try to clean up to avoid warnings
+        if hasattr(self, '_session') and self._session:
+            try:
+                if not self._session.closed:
+                    # Can't use async here, so just close the connector directly
+                    if hasattr(self._session, '_connector') and self._session._connector:
+                        self._session._connector.close()
+            except:
+                # Silently ignore any errors during __del__
+                pass
 
     def request(
         self,

src/brightdata/core/zone_manager.py

@@ -47,10 +47,14 @@ async def ensure_required_zones(
         """
         Check if required zones exist and create them if they don't.
 
+        Note: Browser zones are NOT auto-created because they require additional
+        configuration parameters (like "start" value) that vary by use case.
+        Only unblocker and SERP zones are auto-created.
+
         Args:
             web_unlocker_zone: Web unlocker zone name
             serp_zone: SERP zone name (optional)
-            browser_zone: Browser zone name (optional)
+            browser_zone: Browser zone name (optional, but NOT auto-created)
 
         Raises:
             ZoneError: If zone creation or validation fails
@@ -75,10 +79,15 @@ async def ensure_required_zones(
                 zones_to_create.append((serp_zone, 'serp'))
                 logger.info(f"Need to create SERP zone: {serp_zone}")
 
-            # Check browser zone
+            # Browser zones are NOT auto-created because they require additional
+            # configuration (like "start" parameter) that we cannot provide automatically
             if browser_zone and browser_zone not in zone_names:
-                zones_to_create.append((browser_zone, 'browser'))
-                logger.info(f"Need to create browser zone: {browser_zone}")
+                logger.warning(
+                    f"Browser zone '{browser_zone}' does not exist. "
+                    f"Browser zones cannot be auto-created because they require "
+                    f"additional configuration parameters. Please create this zone "
+                    f"manually in the Bright Data dashboard."
+                )
 
             if not zones_to_create:
                 logger.info("All required zones already exist")