centralize logging

Author: miguelg719

stagehand/__init__.py

@@ -1,8 +1,11 @@
+"""Stagehand - Browser automation with AI"""
+
 from .agent import Agent
 from .client import Stagehand
-from .config import StagehandConfig, default_config
+from .config import StagehandConfig
 from .handlers.observe_handler import ObserveHandler
-from .logging import configure_logging
+from .llm import LLMClient
+from .logging import LogConfig, configure_logging, get_logger
 from .metrics import StagehandFunctionName, StagehandMetrics
 from .page import StagehandPage
 from .schemas import (
@@ -12,35 +15,34 @@
     AgentExecuteOptions,
     AgentExecuteResult,
     AgentProvider,
-    AvailableModel,
     ExtractOptions,
     ExtractResult,
     ObserveOptions,
     ObserveResult,
 )
 
-__version__ = "0.0.1"
+__version__ = "0.1.0"
 
 __all__ = [
     "Stagehand",
     "StagehandConfig",
-    "default_config",
     "StagehandPage",
     "Agent",
-    "configure_logging",
+    "AgentConfig",
+    "AgentExecuteOptions",
+    "AgentExecuteResult",
+    "AgentProvider",
     "ActOptions",
     "ActResult",
-    "AvailableModel",
     "ExtractOptions",
     "ExtractResult",
     "ObserveOptions",
     "ObserveResult",
-    "AgentConfig",
-    "AgentExecuteOptions",
-    "AgentExecuteResult",
-    "AgentProvider",
     "ObserveHandler",
-    "observe",
+    "LLMClient",
+    "configure_logging",
     "StagehandFunctionName",
     "StagehandMetrics",
+    "LogConfig",
+    "get_logger",
 ]

stagehand/agent/anthropic_cua.py

@@ -243,7 +243,7 @@ async def run_task(
                 break
 
             if not agent_action and not task_completed:
-                self.logger.debug(
+                self.logger.info(
                     "Model did not request an action and task not marked complete. Ending task to prevent loop.",
                     category=StagehandFunctionName.AGENT,
                 )
@@ -290,7 +290,7 @@ def _process_provider_response(
                     block.model_dump() for block in response.content
                 ]
             except Exception as e:
-                self.logger.debug(
+                self.logger.error(
                     f"Could not model_dump response.content blocks: {e}",
                     category=StagehandFunctionName.AGENT,
                 )
@@ -337,7 +337,7 @@ def _convert_tool_use_to_agent_action(
             and tool_name != "goto"
             and tool_name != "navigate_back"
         ):
-            self.logger.debug(
+            self.logger.error(
                 f"Unsupported tool name from Anthropic: {tool_name}",
                 category=StagehandFunctionName.AGENT,
             )
@@ -501,7 +501,7 @@ def _convert_tool_use_to_agent_action(
                     )
                     action_type_str = "drag"  # Normalize
                 else:
-                    self.logger.debug(
+                    self.logger.error(
                         "Drag action missing valid start or end coordinates.",
                         category=StagehandFunctionName.AGENT,
                     )
@@ -559,7 +559,7 @@ def _convert_tool_use_to_agent_action(
                         )
                         action_type_str = "function"
                     else:
-                        self.logger.debug(
+                        self.logger.error(
                             "Goto action from Anthropic missing URL",
                             category=StagehandFunctionName.AGENT,
                         )
@@ -572,7 +572,7 @@ def _convert_tool_use_to_agent_action(
                     )
                     action_type_str = "function"
             else:
-                self.logger.debug(
+                self.logger.error(
                     f"Unsupported action type '{action_type_str}' from Anthropic computer tool.",
                     category=StagehandFunctionName.AGENT,
                 )
@@ -613,7 +613,7 @@ def _format_action_feedback(
                     self.format_screenshot(new_screenshot_base64)
                 )
             else:
-                self.logger.debug(
+                self.logger.error(
                     "Missing screenshot for computer tool feedback (empty string passed).",
                     category=StagehandFunctionName.AGENT,
                 )

stagehand/client.py

@@ -23,7 +23,7 @@
 from .config import StagehandConfig, default_config
 from .context import StagehandContext
 from .llm import LLMClient
-from .logging import StagehandLogger, default_log_handler
+from .logging import LogConfig, StagehandLogger, default_log_handler
 from .metrics import StagehandFunctionName, StagehandMetrics
 from .page import StagehandPage
 from .schemas import AgentConfig
@@ -159,12 +159,19 @@ def __init__(
         if self.env not in ["BROWSERBASE", "LOCAL"]:
             raise ValueError("env must be either 'BROWSERBASE' or 'LOCAL'")
 
-        # Initialize the centralized logger with the specified verbosity
-        self.on_log = self.config.logger or default_log_handler
-        self.logger = StagehandLogger(
-            verbose=self.verbose, external_logger=self.on_log, use_rich=use_rich_logging
+        # Create centralized log configuration
+        self.log_config = LogConfig(
+            verbose=self.verbose,
+            use_rich=use_rich_logging,
+            env=self.env,
+            external_logger=self.config.logger or default_log_handler,
+            quiet_dependencies=True,
         )
 
+        # Initialize the centralized logger with the LogConfig
+        self.on_log = self.log_config.external_logger
+        self.logger = StagehandLogger(config=self.log_config)
+
         # If using BROWSERBASE, session_id or creation params are needed
         if self.env == "BROWSERBASE":
             if not self.session_id:
@@ -393,17 +400,14 @@ def _get_lock_for_session(self) -> asyncio.Lock:
         """
         if self.session_id not in self._session_locks:
             self._session_locks[self.session_id] = asyncio.Lock()
-            self.logger.debug(f"Created lock for session {self.session_id}")
         return self._session_locks[self.session_id]
 
     async def __aenter__(self):
-        self.logger.debug("Entering Stagehand context manager (__aenter__)...")
         # Just call init() if not already done
         await self.init()
         return self
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
-        self.logger.debug("Exiting Stagehand context manager (__aexit__)...")
         await self.close()
 
     async def init(self):
@@ -463,7 +467,6 @@ async def init(self):
                 self._browser = await self._playwright.chromium.connect_over_cdp(
                     connect_url
                 )
-                self.logger.debug(f"Connected to remote browser: {self._browser}")
             except Exception as e:
                 self.logger.error(f"Failed to connect Playwright via CDP: {str(e)}")
                 await self.close()
@@ -769,7 +772,7 @@ async def _create_session(self):
 
         payload = {
             "modelName": self.model_name,
-            "verbose": self.verbose,
+            "verbose": self.log_config.get_remote_verbose(),
             "domSettleTimeoutMs": self.dom_settle_timeout_ms,
             "browserbaseSessionCreateParams": (
                 browserbase_session_create_params
@@ -850,10 +853,6 @@ async def _execute(self, method: str, payload: dict[str, Any]) -> Any:
         modified_payload = convert_dict_keys_to_camel_case(payload)
 
         client = self.httpx_client or httpx.AsyncClient(timeout=self.timeout_settings)
-        self.logger.debug(f"\n==== EXECUTING {method.upper()} ====")
-        self.logger.debug(f"URL: {self.api_url}/sessions/{self.session_id}/{method}")
-        self.logger.debug(f"Payload: {modified_payload}")
-        self.logger.debug(f"Headers: {headers}")
 
         async with client:
             try:
@@ -874,7 +873,6 @@ async def _execute(self, method: str, payload: dict[str, Any]) -> Any:
                             f"Request failed with status {response.status_code}: {error_message}"
                         )
 
-                    self.logger.debug("[STREAM] Processing server response")
                     result = None
 
                     async for line in response.aiter_lines():
@@ -903,9 +901,7 @@ async def _execute(self, method: str, payload: dict[str, Any]) -> Any:
                                     )
                                 elif status == "finished":
                                     result = message.get("data", {}).get("result")
-                                    self.logger.debug(
-                                        "[SYSTEM] Operation completed successfully"
-                                    )
+
                             elif msg_type == "log":
                                 # Process log message using _handle_log
                                 await self._handle_log(message)

stagehand/logging.py

@@ -11,6 +11,62 @@
 from rich.table import Table
 from rich.theme import Theme
 
+
+class LogConfig:
+    """
+    Centralized configuration for logging across Stagehand.
+    Manages log levels, formatting, and environment-specific settings.
+    """
+
+    def __init__(
+        self,
+        verbose: int = 1,
+        use_rich: bool = True,
+        env: str = "LOCAL",
+        external_logger: Optional[Callable] = None,
+        quiet_dependencies: bool = True,
+    ):
+        """
+        Initialize logging configuration.
+
+        Args:
+            verbose: Verbosity level (0=error, 1=info, 2=debug)
+            use_rich: Whether to use Rich for formatted output
+            env: Environment ("LOCAL" or "BROWSERBASE")
+            external_logger: Optional external logging callback
+            quiet_dependencies: Whether to quiet noisy dependencies
+        """
+        self.verbose = verbose
+        self.use_rich = use_rich
+        self.env = env
+        self.external_logger = external_logger
+        self.quiet_dependencies = quiet_dependencies
+
+    def get_remote_verbose(self) -> int:
+        """
+        Map local verbose levels to remote levels.
+        Since we now use the same 3-level system, this is a direct mapping.
+        """
+        return self.verbose
+
+    def get_python_log_level(self) -> int:
+        """Get the Python logging level based on verbose setting."""
+        level_map = {
+            0: logging.ERROR,
+            1: logging.INFO,
+            2: logging.DEBUG,
+        }
+        return level_map.get(self.verbose, logging.INFO)
+
+    def should_log(self, level: int) -> bool:
+        """Check if a message at the given level should be logged."""
+        # Always log errors (level 0)
+        if level == 0:
+            return True
+        # Otherwise check against verbose setting
+        return level <= self.verbose
+
+
 # Custom theme for Rich
 stagehand_theme = Theme(
     {
@@ -27,8 +83,25 @@
     }
 )
 
-# Create console instance with theme
-console = Console(theme=stagehand_theme)
+
+def get_console(use_rich: bool = True) -> Console:
+    """
+    Get a console instance based on whether Rich formatting is enabled.
+
+    Args:
+        use_rich: If True, returns a console with theme. If False, returns a plain console.
+
+    Returns:
+        Console instance configured appropriately
+    """
+    if use_rich:
+        return Console(theme=stagehand_theme)
+    else:
+        return Console(theme=None)
+
+
+# Create default console instance with theme (for backward compatibility)
+console = get_console(use_rich=True)
 
 # Setup logging with Rich handler
 logger = logging.getLogger(__name__)
@@ -77,6 +150,8 @@ def configure_logging(
 
     # Configure root logger with custom format
     if use_rich:
+        # Get a console with theme for Rich handler
+        rich_console = get_console(use_rich=True)
         # Use Rich handler for root logger
         logging.basicConfig(
             level=level,
@@ -86,7 +161,7 @@ def configure_logging(
                 RichHandler(
                     rich_tracebacks=True,
                     markup=True,
-                    console=console,
+                    console=rich_console,
                     show_time=False,
                     show_level=False,
                 )
@@ -127,6 +202,7 @@ def __init__(
         verbose: int = 1,
         external_logger: Optional[Callable] = None,
         use_rich: bool = True,
+        config: Optional[LogConfig] = None,
     ):
         """
         Initialize the logger with specified verbosity and optional external logger.
@@ -135,13 +211,27 @@ def __init__(
             verbose: Verbosity level (0=error only, 1=info, 2=debug)
             external_logger: Optional callback function for log events
             use_rich: Whether to use Rich for pretty output (default: True)
+            config: Optional LogConfig instance. If provided, overrides other parameters.
         """
-        self.verbose = verbose
-        self.external_logger = external_logger
-        self.use_rich = use_rich
-        self.console = console
+        if config:
+            self.verbose = config.verbose
+            self.external_logger = config.external_logger
+            self.use_rich = config.use_rich
+            self.config = config
+        else:
+            self.verbose = verbose
+            self.external_logger = external_logger
+            self.use_rich = use_rich
+            self.config = LogConfig(
+                verbose=verbose,
+                use_rich=use_rich,
+                external_logger=external_logger,
+            )
+
+        self.console = get_console(self.use_rich)
 
         # Map our verbosity levels to Python's logging levels
+        # Now using only 3 levels to match the remote Fastify server
         self.level_map = {
             0: logging.ERROR,  # Critical errors only
             1: logging.INFO,  # Standard information
@@ -152,7 +242,7 @@ def __init__(
         self.level_style = {0: "error", 1: "info", 2: "debug"}
 
         # Update logger level based on verbosity
-        self._set_verbosity(verbose)
+        self._set_verbosity(self.verbose)
 
     def _set_verbosity(self, level: int):
         """Set the logger verbosity level"""
@@ -560,6 +650,20 @@ def debug(
         self.log(message, level=2, category=category, auxiliary=auxiliary)
 
 
+def get_logger(name: str, config: LogConfig) -> StagehandLogger:
+    """
+    Factory function to get a configured logger instance for a module.
+
+    Args:
+        name: The name of the module requesting the logger
+        config: LogConfig instance with logging configuration
+
+    Returns:
+        StagehandLogger: Configured logger instance
+    """
+    return StagehandLogger(config=config)
+
+
 # Create a synchronous wrapper for the async default_log_handler
 def sync_log_handler(log_data: dict[str, Any]) -> None:
     """