ag2 0.9.1__py3-none-any.whl → 0.9.1.post0__py3-none-any.whl

autogen/logger/file_logger.py

@@ -0,0 +1,261 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
+# SPDX-License-Identifier: MIT
+from __future__ import annotations
+
+import json
+import logging
+import os
+import threading
+import uuid
+from typing import TYPE_CHECKING, Any, Callable, TypeVar
+
+from ..doc_utils import export_module
+from .base_logger import BaseLogger, LLMConfig
+from .logger_utils import get_current_ts, to_dict
+
+if TYPE_CHECKING:
+    from openai import AzureOpenAI, OpenAI
+    from openai.types.chat import ChatCompletion
+
+    from .. import Agent, ConversableAgent, OpenAIWrapper
+    from ..oai.anthropic import AnthropicClient
+    from ..oai.bedrock import BedrockClient
+    from ..oai.cerebras import CerebrasClient
+    from ..oai.cohere import CohereClient
+    from ..oai.gemini import GeminiClient
+    from ..oai.groq import GroqClient
+    from ..oai.mistral import MistralAIClient
+    from ..oai.ollama import OllamaClient
+    from ..oai.together import TogetherClient
+
+logger = logging.getLogger(__name__)
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+__all__ = ("FileLogger",)
+
+
+def safe_serialize(obj: Any) -> str:
+    def default(o: Any) -> str:
+        if hasattr(o, "to_json"):
+            return str(o.to_json())
+        else:
+            return f"<<non-serializable: {type(o).__qualname__}>>"
+
+    return json.dumps(obj, default=default)
+
+
+@export_module("autogen.logger")
+class FileLogger(BaseLogger):
+    def __init__(self, config: dict[str, Any]):
+        self.config = config
+        self.session_id = str(uuid.uuid4())
+
+        curr_dir = os.getcwd()
+        self.log_dir = os.path.join(curr_dir, "autogen_logs")
+        os.makedirs(self.log_dir, exist_ok=True)
+
+        self.log_file = os.path.join(self.log_dir, self.config.get("filename", "runtime.log"))
+        try:
+            with open(self.log_file, "a"):
+                pass
+        except Exception as e:
+            logger.error(f"[file_logger] Failed to create logging file: {e}")
+
+        self.logger = logging.getLogger(__name__)
+        self.logger.setLevel(logging.INFO)
+        file_handler = logging.FileHandler(self.log_file)
+        self.logger.addHandler(file_handler)
+
+    def start(self) -> str:
+        """Start the logger and return the session_id."""
+        try:
+            self.logger.info(f"Started new session with Session ID: {self.session_id}")
+        except Exception as e:
+            logger.error(f"[file_logger] Failed to create logging file: {e}")
+        finally:
+            return self.session_id
+
+    def log_chat_completion(
+        self,
+        invocation_id: uuid.UUID,
+        client_id: int,
+        wrapper_id: int,
+        source: str | Agent,
+        request: dict[str, float | str | list[dict[str, str]]],
+        response: str | ChatCompletion,
+        is_cached: int,
+        cost: float,
+        start_time: str,
+    ) -> None:
+        """Log a chat completion."""
+        thread_id = threading.get_ident()
+        source_name = (
+            source
+            if isinstance(source, str)
+            else source.name
+            if hasattr(source, "name") and source.name is not None
+            else ""
+        )
+        try:
+            log_data = json.dumps({
+                "invocation_id": str(invocation_id),
+                "client_id": client_id,
+                "wrapper_id": wrapper_id,
+                "request": to_dict(request),
+                "response": str(response),
+                "is_cached": is_cached,
+                "cost": cost,
+                "start_time": start_time,
+                "end_time": get_current_ts(),
+                "thread_id": thread_id,
+                "source_name": source_name,
+            })
+
+            self.logger.info(log_data)
+        except Exception as e:
+            self.logger.error(f"[file_logger] Failed to log chat completion: {e}")
+
+    def log_new_agent(self, agent: ConversableAgent, init_args: dict[str, Any] = {}) -> None:
+        """Log a new agent instance."""
+        thread_id = threading.get_ident()
+
+        try:
+            log_data = json.dumps({
+                "id": id(agent),
+                "agent_name": agent.name if hasattr(agent, "name") and agent.name is not None else "",
+                "wrapper_id": to_dict(
+                    agent.client.wrapper_id if hasattr(agent, "client") and agent.client is not None else ""
+                ),
+                "session_id": self.session_id,
+                "current_time": get_current_ts(),
+                "agent_type": type(agent).__name__,
+                "args": to_dict(init_args),
+                "thread_id": thread_id,
+            })
+            self.logger.info(log_data)
+        except Exception as e:
+            self.logger.error(f"[file_logger] Failed to log new agent: {e}")
+
+    def log_event(self, source: str | Agent, name: str, **kwargs: dict[str, Any]) -> None:
+        """Log an event from an agent or a string source."""
+        from .. import Agent
+
+        # This takes an object o as input and returns a string. If the object o cannot be serialized, instead of raising an error,
+        # it returns a string indicating that the object is non-serializable, along with its type's qualified name obtained using __qualname__.
+        json_args = json.dumps(kwargs, default=lambda o: f"<<non-serializable: {type(o).__qualname__}>>")
+        thread_id = threading.get_ident()
+
+        if isinstance(source, Agent):
+            try:
+                log_data = json.dumps({
+                    "source_id": id(source),
+                    "source_name": str(source.name) if hasattr(source, "name") else source,
+                    "event_name": name,
+                    "agent_module": source.__module__,
+                    "agent_class": source.__class__.__name__,
+                    "json_state": json_args,
+                    "timestamp": get_current_ts(),
+                    "thread_id": thread_id,
+                })
+                self.logger.info(log_data)
+            except Exception as e:
+                self.logger.error(f"[file_logger] Failed to log event {e}")
+        else:
+            try:
+                log_data = json.dumps({
+                    "source_id": id(source),
+                    "source_name": str(source.name) if hasattr(source, "name") else source,
+                    "event_name": name,
+                    "json_state": json_args,
+                    "timestamp": get_current_ts(),
+                    "thread_id": thread_id,
+                })
+                self.logger.info(log_data)
+            except Exception as e:
+                self.logger.error(f"[file_logger] Failed to log event {e}")
+
+    def log_new_wrapper(self, wrapper: OpenAIWrapper, init_args: dict[str, LLMConfig | list[LLMConfig]] = {}) -> None:
+        """Log a new wrapper instance."""
+        thread_id = threading.get_ident()
+
+        try:
+            log_data = json.dumps({
+                "wrapper_id": id(wrapper),
+                "session_id": self.session_id,
+                "json_state": json.dumps(init_args),
+                "timestamp": get_current_ts(),
+                "thread_id": thread_id,
+            })
+            self.logger.info(log_data)
+        except Exception as e:
+            self.logger.error(f"[file_logger] Failed to log event {e}")
+
+    def log_new_client(
+        self,
+        client: (
+            AzureOpenAI
+            | OpenAI
+            | CerebrasClient
+            | GeminiClient
+            | AnthropicClient
+            | MistralAIClient
+            | TogetherClient
+            | GroqClient
+            | CohereClient
+            | OllamaClient
+            | BedrockClient
+        ),
+        wrapper: OpenAIWrapper,
+        init_args: dict[str, Any],
+    ) -> None:
+        """Log a new client instance."""
+        thread_id = threading.get_ident()
+
+        try:
+            log_data = json.dumps({
+                "client_id": id(client),
+                "wrapper_id": id(wrapper),
+                "session_id": self.session_id,
+                "class": type(client).__name__,
+                "json_state": json.dumps(init_args),
+                "timestamp": get_current_ts(),
+                "thread_id": thread_id,
+            })
+            self.logger.info(log_data)
+        except Exception as e:
+            self.logger.error(f"[file_logger] Failed to log event {e}")
+
+    def log_function_use(self, source: str | Agent, function: F, args: dict[str, Any], returns: Any) -> None:
+        """Log a registered function(can be a tool) use from an agent or a string source."""
+        thread_id = threading.get_ident()
+
+        try:
+            log_data = json.dumps({
+                "source_id": id(source),
+                "source_name": str(source.name) if hasattr(source, "name") else source,
+                "agent_module": source.__module__,
+                "agent_class": source.__class__.__name__,
+                "timestamp": get_current_ts(),
+                "thread_id": thread_id,
+                "input_args": safe_serialize(args),
+                "returns": safe_serialize(returns),
+            })
+            self.logger.info(log_data)
+        except Exception as e:
+            self.logger.error(f"[file_logger] Failed to log event {e}")
+
+    def get_connection(self) -> None:
+        """Method is intentionally left blank because there is no specific connection needed for the FileLogger."""
+        pass
+
+    def stop(self) -> None:
+        """Close the file handler and remove it from the logger."""
+        for handler in self.logger.handlers:
+            if isinstance(handler, logging.FileHandler):
+                handler.close()
+                self.logger.removeHandler(handler)

autogen/logger/logger_factory.py

@@ -0,0 +1,42 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
+# SPDX-License-Identifier: MIT
+from typing import Any, Literal, Optional
+
+from ..doc_utils import export_module
+from .base_logger import BaseLogger
+from .file_logger import FileLogger
+from .sqlite_logger import SqliteLogger
+
+__all__ = ("LoggerFactory",)
+
+
+@export_module("autogen.logger")
+class LoggerFactory:
+    """Factory class to create logger objects."""
+
+    @staticmethod
+    def get_logger(
+        logger_type: Literal["sqlite", "file"] = "sqlite", config: Optional[dict[str, Any]] = None
+    ) -> BaseLogger:
+        """Factory method to create logger objects.
+
+        Args:
+            logger_type (Literal["sqlite", "file"], optional): Type of logger. Defaults to "sqlite".
+            config (Optional[dict[str, Any]], optional): Configuration for logger. Defaults to None.
+
+        Returns:
+            BaseLogger: Logger object
+        """
+        if config is None:
+            config = {}
+
+        if logger_type == "sqlite":
+            return SqliteLogger(config)
+        elif logger_type == "file":
+            return FileLogger(config)
+        else:
+            raise ValueError(f"[logger_factory] Unknown logger type: {logger_type}")

autogen/logger/logger_utils.py

@@ -0,0 +1,57 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
+# SPDX-License-Identifier: MIT
+import inspect
+from datetime import datetime, timezone
+from pathlib import Path, PurePath
+from typing import Any, Union
+
+__all__ = ("get_current_ts", "to_dict")
+
+
+def get_current_ts() -> str:
+    """Get current timestamp in UTC timezone.
+
+    Returns:
+        str: Current timestamp in UTC timezone
+    """
+    return datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S.%f")
+
+
+def to_dict(
+    obj: Union[int, float, str, bool, dict[Any, Any], list[Any], tuple[Any, ...], Any],
+    exclude: tuple[str, ...] = (),
+    no_recursive: tuple[Any, ...] = (),
+) -> Any:
+    """Convert object to dictionary.
+
+    Args:
+        obj (Union[int, float, str, bool, dict[Any, Any], list[Any], tuple[Any, ...], Any]): Object to convert
+        exclude (tuple[str, ...], optional): Keys to exclude. Defaults to ().
+        no_recursive (tuple[Any, ...], optional): Types to exclude from recursive conversion. Defaults to ().
+    """
+    if isinstance(obj, (int, float, str, bool)):
+        return obj
+    elif isinstance(obj, (Path, PurePath)):
+        return str(obj)
+    elif callable(obj):
+        return inspect.getsource(obj).strip()
+    elif isinstance(obj, dict):
+        return {
+            str(k): to_dict(str(v)) if isinstance(v, no_recursive) else to_dict(v, exclude, no_recursive)
+            for k, v in obj.items()
+            if k not in exclude
+        }
+    elif isinstance(obj, (list, tuple)):
+        return [to_dict(str(v)) if isinstance(v, no_recursive) else to_dict(v, exclude, no_recursive) for v in obj]
+    elif hasattr(obj, "__dict__"):
+        return {
+            str(k): to_dict(str(v)) if isinstance(v, no_recursive) else to_dict(v, exclude, no_recursive)
+            for k, v in vars(obj).items()
+            if k not in exclude
+        }
+    else:
+        return obj