File size: 5,024 Bytes
9eb915e |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 |
"""
utils/logger.py - Logging-Modul für den Dr. Franz Psychochatbot
Dieses Modul stellt Logging-Funktionalitäten bereit:
- Protokollierung von Aktivitäten
- Unterstützung beim Debugging
- Überwachung der Performance
"""
import logging
import os
import time
from datetime import datetime
from typing import Optional, Dict, Any
# Importieren der Konfiguration
import config
class Logger:
"""Klasse zur Verwaltung des Loggings"""
def __init__(self, log_level: str = config.LOG_LEVEL):
"""
Initialisiert den Logger
Args:
log_level: Das Log-Level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
"""
self.log_level = log_level
self.logger = self._setup_logger()
self.start_time = time.time()
self.interaction_count = 0
def _setup_logger(self) -> logging.Logger:
"""
Richtet den Logger ein
Returns:
Konfigurierter Logger
"""
# Log-Level aus String in Logging-Konstante umwandeln
numeric_level = getattr(logging, self.log_level.upper(), logging.INFO)
# Logger konfigurieren
logger = logging.getLogger("psychobot")
logger.setLevel(numeric_level)
# Handler für Konsolenausgabe
console_handler = logging.StreamHandler()
console_handler.setLevel(numeric_level)
# Formatter für lesbares Format
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
console_handler.setFormatter(formatter)
# Handler hinzufügen, falls noch nicht vorhanden
if not logger.handlers:
logger.addHandler(console_handler)
return logger
def log_startup(self) -> None:
"""Protokolliert den Start der Anwendung"""
self.logger.info(f"=== {config.CHATBOT_TITLE} gestartet ===")
self.logger.info(f"Verwende Modell: {config.MODEL_ID}")
self.logger.info(f"Debug-Modus: {config.DEBUG_MODE}")
self.logger.info(f"API-Token vorhanden: {bool(config.API_TOKEN)}")
def log_user_input(self, user_input: str) -> None:
"""
Protokolliert eine Nutzereingabe
Args:
user_input: Die Eingabe des Nutzers
"""
self.interaction_count += 1
self.logger.info(f"Nutzeranfrage #{self.interaction_count}: {user_input[:50]}...")
def log_bot_response(self, response: str, generation_time: float) -> None:
"""
Protokolliert eine Bot-Antwort
Args:
response: Die Antwort des Bots
generation_time: Die Zeit zur Generierung der Antwort in Sekunden
"""
self.logger.info(f"Bot-Antwort #{self.interaction_count}: {response[:50]}... (Generiert in {generation_time:.2f}s)")
def log_api_request(self, model_id: str, prompt_length: int) -> None:
"""
Protokolliert eine API-Anfrage
Args:
model_id: Die ID des verwendeten Modells
prompt_length: Die Länge des Prompts in Zeichen
"""
self.logger.debug(f"API-Anfrage an {model_id} mit Prompt-Länge: {prompt_length} Zeichen")
def log_api_response(self, status_code: int, response_time: float) -> None:
"""
Protokolliert eine API-Antwort
Args:
status_code: Der HTTP-Statuscode
response_time: Die Antwortzeit in Sekunden
"""
self.logger.debug(f"API-Antwort erhalten: Status {status_code}, Zeit: {response_time:.2f}s")
def log_error(self, error_type: str, error_message: str, details: Optional[Dict[str, Any]] = None) -> None:
"""
Protokolliert einen Fehler
Args:
error_type: Der Typ des Fehlers
error_message: Die Fehlermeldung
details: Optional, zusätzliche Details zum Fehler
"""
self.logger.error(f"FEHLER - {error_type}: {error_message}")
if details and config.DEBUG_MODE:
self.logger.error(f"Details: {details}")
def log_performance_stats(self) -> Dict[str, Any]:
"""
Protokolliert Performance-Statistiken
Returns:
Dictionary mit Performance-Statistiken
"""
uptime = time.time() - self.start_time
hours, remainder = divmod(uptime, 3600)
minutes, seconds = divmod(remainder, 60)
stats = {
"uptime": f"{int(hours)}h {int(minutes)}m {int(seconds)}s",
"interactions": self.interaction_count,
"interactions_per_hour": round(self.interaction_count / (uptime / 3600), 2) if uptime > 0 else 0
}
self.logger.info(f"Performance-Statistiken: Laufzeit {stats['uptime']}, "
f"{stats['interactions']} Interaktionen, "
f"{stats['interactions_per_hour']} Interaktionen/Stunde")
return stats
|