160 lines
5.0 KiB
Python
160 lines
5.0 KiB
Python
"""
|
|
Logger utilities to prevent conflicts between different logging configurations.
|
|
"""
|
|
|
|
import hashlib
|
|
import json
|
|
from loguru import logger
|
|
import sys
|
|
<<<<<<< HEAD
|
|
import hashlib
|
|
import json
|
|
from typing import Any, Dict, Optional
|
|
=======
|
|
from typing import Any, Dict, List, Optional
|
|
>>>>>>> pr-421
|
|
|
|
|
|
def safe_logger_config(format_string: str, level: str = "INFO"):
|
|
"""
|
|
Safely configure logger without removing existing handlers.
|
|
This prevents conflicts with the main logging configuration.
|
|
|
|
Args:
|
|
format_string: Log format string
|
|
level: Log level
|
|
"""
|
|
try:
|
|
# Only add a new handler if we don't already have one with this format
|
|
existing_handlers = logger._core.handlers
|
|
for handler in existing_handlers:
|
|
if hasattr(handler, '_sink') and handler._sink == sys.stdout:
|
|
# Check if format is similar to avoid duplicates
|
|
if hasattr(handler, '_format') and handler._format == format_string:
|
|
return # Handler already exists with this format
|
|
|
|
# Add new handler only if needed
|
|
logger.add(
|
|
sys.stdout,
|
|
level=level,
|
|
format=format_string,
|
|
colorize=True
|
|
)
|
|
except Exception as e:
|
|
# If there's any error, just use the existing logger configuration
|
|
pass
|
|
|
|
|
|
def get_service_logger(service_name: str, format_string: str = None):
|
|
"""
|
|
Get a logger for a specific service without conflicting with main configuration.
|
|
|
|
Args:
|
|
service_name: Name of the service
|
|
format_string: Optional custom format string
|
|
|
|
Returns:
|
|
Logger instance
|
|
"""
|
|
if format_string:
|
|
safe_logger_config(format_string)
|
|
|
|
return logger.bind(service=service_name)
|
|
|
|
|
|
<<<<<<< HEAD
|
|
def _mask_user_id(user_id: Optional[str]) -> str:
|
|
"""Mask user ID for privacy in logs."""
|
|
if not user_id:
|
|
return "anonymous"
|
|
return hashlib.sha256(str(user_id).encode("utf-8")).hexdigest()[:12]
|
|
|
|
|
|
def emit_routing_event(
|
|
logger_instance,
|
|
flow_type: str,
|
|
*,
|
|
route_intent: str = "primary",
|
|
provider_selected: str,
|
|
model_selected: str,
|
|
preferred_provider: Optional[str] = None,
|
|
fallback_count: int = 0,
|
|
fallback_models_tried: Optional[list] = None,
|
|
tenant_user_id: Optional[str] = None,
|
|
extra: Optional[Dict[str, Any]] = None,
|
|
level: str = "info"
|
|
) -> None:
|
|
"""
|
|
Emit structured routing event for LLM provider selection.
|
|
|
|
Args:
|
|
logger_instance: Logger instance to use
|
|
flow_type: Type of flow (e.g., "sif_agent", "premium_tool")
|
|
route_intent: Route intent ("primary" or "fallback")
|
|
provider_selected: Selected provider name
|
|
model_selected: Selected model name
|
|
preferred_provider: Preferred provider (if any)
|
|
fallback_count: Number of fallback attempts made
|
|
fallback_models_tried: List of models tried as fallbacks
|
|
tenant_user_id: Tenant user ID (will be hashed)
|
|
extra: Additional fields to include
|
|
level: Log level to use
|
|
"""
|
|
payload: Dict[str, Any] = {
|
|
"flow_type": flow_type,
|
|
"route_intent": route_intent,
|
|
=======
|
|
def _mask_tenant_user_id(tenant_user_id: Optional[str]) -> Optional[str]:
|
|
"""Return a stable hash for a tenant user id so logs avoid exposing raw IDs."""
|
|
if not tenant_user_id:
|
|
return None
|
|
return hashlib.sha256(tenant_user_id.encode("utf-8")).hexdigest()[:12]
|
|
|
|
|
|
def emit_routing_event(
|
|
service_logger,
|
|
*,
|
|
flow_type: str,
|
|
route_intent: str,
|
|
provider_selected: Optional[str],
|
|
model_selected: Optional[str],
|
|
preferred_provider: Optional[str],
|
|
fallback_count: int = 0,
|
|
fallback_models_tried: Optional[List[str]] = None,
|
|
tenant_user_id: Optional[str] = None,
|
|
event_name: str = "llm_routing_event",
|
|
level: str = "INFO",
|
|
extra: Optional[Dict[str, Any]] = None,
|
|
) -> Dict[str, Any]:
|
|
"""Emit a standardized structured model-routing event for AI facades."""
|
|
payload: Dict[str, Any] = {
|
|
"event_name": event_name,
|
|
"flow_type": flow_type,
|
|
"route_intent": route_intent,
|
|
"flow_type/route_intent": f"{flow_type}/{route_intent}",
|
|
>>>>>>> pr-421
|
|
"provider_selected": provider_selected,
|
|
"model_selected": model_selected,
|
|
"preferred_provider": preferred_provider,
|
|
"fallback_count": fallback_count,
|
|
"fallback_models_tried": fallback_models_tried or [],
|
|
<<<<<<< HEAD
|
|
"tenant": _mask_user_id(tenant_user_id),
|
|
}
|
|
|
|
if extra:
|
|
payload.update(extra)
|
|
|
|
log_method = getattr(logger_instance, level.lower(), logger_instance.info)
|
|
log_method("[llm_routing] {}", json.dumps(payload, sort_keys=True, default=str))
|
|
=======
|
|
"tenant_user_id": _mask_tenant_user_id(tenant_user_id),
|
|
}
|
|
if extra:
|
|
payload.update(extra)
|
|
|
|
log_method = getattr(service_logger, level.lower(), service_logger.info)
|
|
log_method("{}", json.dumps(payload, sort_keys=True))
|
|
return payload
|
|
>>>>>>> pr-421
|