log_manager.py

"""Log manager compatibility shim.

LogManager now wraps WorkflowLogger for backward compatibility.
All timing helpers live inside WorkflowLogger; prefer using it directly.
"""

import time
from contextlib import contextmanager
from typing import Any, Dict, List

from entity.enums import CallStage, LogLevel
from utils.logger import WorkflowLogger


class LogManager:
    """Backward-compatible wrapper that delegates to ``WorkflowLogger``."""

    def __init__(self, logger: WorkflowLogger = None):
        self.logger = logger

    def get_logger(self) -> WorkflowLogger:
        """Return the underlying ``WorkflowLogger`` instance."""
        return self.logger

    # ================================================================
    # Timer context managers delegated to WorkflowLogger
    # ================================================================

    @contextmanager
    def node_timer(self, node_id: str):
        """Context manager that times node execution."""
        with self.logger.node_timer(node_id):
            yield

    @contextmanager
    def model_timer(self, node_id: str):
        """Context manager that times model invocations."""
        with self.logger.model_timer(node_id):
            yield

    @contextmanager
    def agent_timer(self, node_id: str):
        """Context manager that times agent invocations."""
        with self.logger.agent_timer(node_id):
            yield

    @contextmanager
    def human_timer(self, node_id: str):
        """Context manager that times human interactions."""
        with self.logger.human_timer(node_id):
            yield

    @contextmanager
    def tool_timer(self, node_id: str, tool_name: str):
        """Context manager that times tool invocations."""
        with self.logger.tool_timer(node_id, tool_name):
            yield

    @contextmanager
    def thinking_timer(self, node_id: str, stage: str):
        """Context manager that times thinking workflows."""
        with self.logger.thinking_timer(node_id, stage):
            yield

    @contextmanager
    def memory_timer(self, node_id: str, operation_type: str, stage: str):
        """Context manager that times memory operations."""
        with self.logger.memory_timer(node_id, operation_type, stage):
            yield

    @contextmanager
    def operation_timer(self, operation_name: str):
        """Context manager that times custom operations."""
        start_time = time.time()
        try:
            yield
        finally:
            end_time = time.time()
            duration = (end_time - start_time)
            self.logger._timers[operation_name] = duration

    # ================================================================
    # Logging methods delegated to WorkflowLogger
    # ================================================================

    def record_node_start(self, node_id: str, inputs: List[Dict[str, str]], node_type: str = None,
                          details: Dict[str, Any] = None) -> None:
        """Record the start of a node."""
        self.logger.enter_node(node_id, inputs, node_type, details)

    def record_node_end(self, node_id: str, output: str = None,
                        details: Dict[str, Any] = None) -> None:
        """Record the end of a node."""
        output_size = len(str(output)) if output is not None else 0
        duration = self.logger.get_timer(node_id)
        self.logger.exit_node(node_id, output, duration, output_size, details)

    def record_edge_process(self, from_node: str, to_node: str,
                            details: Dict[str, Any] = None) -> None:
        """Record an edge processing event."""
        self.logger.record_edge_process(from_node, to_node, details)

    def record_human_interaction(self, node_id: str, input_data: Any = None, output: Any = None,
                                 details: Dict[str, Any] = None) -> None:
        """Record a human interaction."""
        input_size = len(str(input_data)) if input_data is not None else 0
        output_size = len(str(output)) if output is not None else 0
        duration = self.logger.get_timer(f"human_{node_id}")
        call_details = {
            "input_size": input_size,
            "output_size": output_size,
            **(details or {})
        }
        self.logger.record_human_interaction(
            node_id, input_data, output, duration, call_details
        )

    def record_model_call(self, node_id: str, model_name: str,
                          input_data: Any = None, output: Any = None,
                          details: Dict[str, Any] = None,
                          stage: CallStage = CallStage.AFTER) -> None:
        """Record a model invocation."""
        input_size = len(str(input_data)) if input_data is not None else 0
        output_size = len(str(output)) if output is not None else 0
        duration = self.logger.get_timer(f"model_{node_id}")

        call_details = {
            "input_size": input_size,
            "output_size": output_size,
            **(details or {})
        }

        self.logger.record_model_call(
            node_id, model_name, input_data, output, duration, call_details, stage
        )

    def record_tool_call(self, node_id: str, tool_name: str,
                         success: bool | None = True, tool_result: Any = None,
                         details: Dict[str, Any] = None,
                         stage: CallStage = CallStage.AFTER) -> None:
        """Record a tool invocation."""
        duration = self.logger.get_timer(f"tool_{node_id}_{tool_name}")
        tool_details = {
            "result_size": len(str(tool_result)) if tool_result is not None else 0,
            **(details or {})
        }
        self.logger.record_tool_call(node_id, tool_name, tool_result, duration, success, tool_details, stage)

    def record_thinking_process(self, node_id: str, thinking_mode: str, thinking_result: str,
                                stage: str, details: Dict[str, Any] = None) -> None:
        """Record a thinking stage."""
        duration = self.logger.get_timer(f"thinking_{node_id}_{stage}")
        self.logger.record_thinking_process(node_id, thinking_mode, thinking_result, stage, duration, details)

    def record_memory_operation(self, node_id: str, operation_type: str,
                                stage: str, retrieved_memory: Any = None,
                                details: Dict[str, Any] = None) -> None:
        """Record a memory operation."""
        duration = self.logger.get_timer(f"memory_{node_id}_{operation_type}_{stage}")
        memory_details = {
            "result_size": len(str(retrieved_memory)) if retrieved_memory is not None else 0,
            **(details or {})
        }
        self.logger.record_memory_operation(node_id, retrieved_memory, operation_type, stage, duration, memory_details)

    def record_workflow_start(self, workflow_config: Dict[str, Any] = None) -> None:
        """Record the workflow start event."""
        self.logger.record_workflow_start(workflow_config)

    def record_workflow_end(self, success: bool = True,
                            details: Dict[str, Any] = None) -> None:
        """Record the workflow end event."""
        workflow_duration = (time.time() - self.logger.start_time.timestamp())
        self.logger.record_workflow_end(success, workflow_duration, details)

    def debug(self, message: str, node_id: str = None,
              details: Dict[str, Any] = None) -> None:
        """Record debug information."""
        self.logger.debug(message, node_id, details=details)

    def info(self, message: str, node_id: str = None,
             details: Dict[str, Any] = None) -> None:
        """Record general information."""
        self.logger.info(message, node_id, details=details)

    def warning(self, message: str, node_id: str = None,
                details: Dict[str, Any] = None) -> None:
        """Record warning information."""
        self.logger.warning(message, node_id, details=details)

    def error(self, message: str, node_id: str = None,
              details: Dict[str, Any] = None) -> None:
        """Record error information."""
        self.logger.error(message, node_id, details=details)

    def critical(self, message: str, node_id: str = None,
                 details: Dict[str, Any] = None) -> None:
        """Record critical error information."""
        self.logger.critical(message, node_id, details=details)

    def get_execution_summary(self) -> Dict[str, Any]:
        """Return the execution summary."""
        return self.logger.get_execution_summary()

    def get_all_logs(self) -> list:
        """Return all logs."""
        return self.logger.get_logs()

    def logs_to_dict(self) -> Dict[str, Any]:
        """Convert the logs to dictionary form."""
        return self.logger.to_dict()

    def save_logs(self, filepath: str) -> None:
        """Persist logs to a file."""
        self.logger.save_to_file(filepath)