FileLogger

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)