467 lines
16 KiB
Python
467 lines
16 KiB
Python
import logging
|
||
import logging.handlers
|
||
import os
|
||
import sys
|
||
import time
|
||
import platform
|
||
import socket
|
||
from typing import Dict, Optional, Any
|
||
from datetime import datetime
|
||
from config.settings import (
|
||
LOG_DIR, LOG_SUBDIRS, LOG_LEVEL, LOG_FORMAT, LOG_DATE_FORMAT,
|
||
get_log_file, ensure_log_directories
|
||
)
|
||
|
||
# Dictionary zur Speicherung der konfigurierten Logger
|
||
_loggers: Dict[str, logging.Logger] = {}
|
||
|
||
# ANSI-Farbcodes für Log-Level
|
||
ANSI_COLORS = {
|
||
'RESET': '\033[0m',
|
||
'BOLD': '\033[1m',
|
||
'BLACK': '\033[30m',
|
||
'RED': '\033[31m',
|
||
'GREEN': '\033[32m',
|
||
'YELLOW': '\033[33m',
|
||
'BLUE': '\033[34m',
|
||
'MAGENTA': '\033[35m',
|
||
'CYAN': '\033[36m',
|
||
'WHITE': '\033[37m',
|
||
'BG_RED': '\033[41m',
|
||
'BG_GREEN': '\033[42m',
|
||
'BG_YELLOW': '\033[43m',
|
||
'BG_BLUE': '\033[44m'
|
||
}
|
||
|
||
# Emojis für verschiedene Log-Level und Kategorien
|
||
LOG_EMOJIS = {
|
||
'DEBUG': '🔍',
|
||
'INFO': 'ℹ️',
|
||
'WARNING': '⚠️',
|
||
'ERROR': '❌',
|
||
'CRITICAL': '🔥',
|
||
'app': '🖥️',
|
||
'scheduler': '⏱️',
|
||
'auth': '🔐',
|
||
'jobs': '🖨️',
|
||
'printers': '🔧',
|
||
'errors': '💥',
|
||
'user': '👤',
|
||
'kiosk': '📺'
|
||
}
|
||
|
||
# ASCII-Fallback für Emojis bei Encoding-Problemen
|
||
EMOJI_FALLBACK = {
|
||
'🔍': '[DEBUG]',
|
||
'ℹ️': '[INFO]',
|
||
'⚠️': '[WARN]',
|
||
'❌': '[ERROR]',
|
||
'🔥': '[CRIT]',
|
||
'🖥️': '[APP]',
|
||
'⏱️': '[SCHED]',
|
||
'🔐': '[AUTH]',
|
||
'🖨️': '[JOBS]',
|
||
'🔧': '[PRINT]',
|
||
'💥': '[ERR]',
|
||
'👤': '[USER]',
|
||
'📺': '[KIOSK]',
|
||
'🐞': '[BUG]',
|
||
'🚀': '[START]',
|
||
'📂': '[FOLDER]',
|
||
'📊': '[CHART]',
|
||
'💻': '[PC]',
|
||
'🌐': '[WEB]',
|
||
'📅': '[TIME]',
|
||
'📡': '[SIGNAL]',
|
||
'🧩': '[CONTENT]',
|
||
'📋': '[HEADER]',
|
||
'✅': '[OK]',
|
||
'📦': '[SIZE]'
|
||
}
|
||
|
||
def safe_emoji(emoji: str) -> str:
|
||
"""Gibt ein Emoji zurück oder einen ASCII-Fallback bei Encoding-Problemen."""
|
||
try:
|
||
# Erste Priorität: Teste, ob das Emoji dargestellt werden kann
|
||
test_encoding = sys.stdout.encoding or 'utf-8'
|
||
emoji.encode(test_encoding)
|
||
|
||
# Zweite Prüfung: Windows-spezifische cp1252-Codierung
|
||
if os.name == 'nt':
|
||
try:
|
||
emoji.encode('cp1252')
|
||
except UnicodeEncodeError:
|
||
# Wenn cp1252 fehlschlägt, verwende Fallback
|
||
return EMOJI_FALLBACK.get(emoji, '[?]')
|
||
|
||
return emoji
|
||
except (UnicodeEncodeError, LookupError, AttributeError):
|
||
return EMOJI_FALLBACK.get(emoji, '[?]')
|
||
|
||
# Prüfen, ob das Terminal ANSI-Farben unterstützt
|
||
def supports_color() -> bool:
|
||
"""Prüft, ob das Terminal ANSI-Farben unterstützt."""
|
||
if os.name == 'nt':
|
||
try:
|
||
import ctypes
|
||
kernel32 = ctypes.windll.kernel32
|
||
# Aktiviere VT100-Unterstützung unter Windows
|
||
kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)
|
||
|
||
# Setze Console-Output auf UTF-8 für bessere Emoji-Unterstützung
|
||
try:
|
||
kernel32.SetConsoleOutputCP(65001) # UTF-8
|
||
except:
|
||
pass
|
||
|
||
# Versuche UTF-8-Encoding für Emojis zu setzen
|
||
try:
|
||
import locale
|
||
locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')
|
||
except:
|
||
try:
|
||
# Fallback für deutsche Lokalisierung
|
||
locale.setlocale(locale.LC_ALL, 'de_DE.UTF-8')
|
||
except:
|
||
pass
|
||
|
||
return True
|
||
except:
|
||
return False
|
||
else:
|
||
return sys.stdout.isatty()
|
||
|
||
USE_COLORS = supports_color()
|
||
|
||
class ColoredFormatter(logging.Formatter):
|
||
"""Formatter, der Farben und Emojis für Logs hinzufügt."""
|
||
|
||
level_colors = {
|
||
'DEBUG': ANSI_COLORS['CYAN'],
|
||
'INFO': ANSI_COLORS['GREEN'],
|
||
'WARNING': ANSI_COLORS['YELLOW'],
|
||
'ERROR': ANSI_COLORS['RED'],
|
||
'CRITICAL': ANSI_COLORS['BG_RED'] + ANSI_COLORS['WHITE'] + ANSI_COLORS['BOLD']
|
||
}
|
||
|
||
def format(self, record):
|
||
try:
|
||
# Basis-Format erstellen
|
||
log_fmt = LOG_FORMAT
|
||
date_fmt = LOG_DATE_FORMAT
|
||
|
||
# Emoji dem Level und der Kategorie hinzufügen
|
||
level_name = record.levelname
|
||
category_name = record.name.split('.')[-1] if '.' in record.name else record.name
|
||
|
||
level_emoji = safe_emoji(LOG_EMOJIS.get(level_name, ''))
|
||
category_emoji = safe_emoji(LOG_EMOJIS.get(category_name, ''))
|
||
|
||
# Record-Objekt modifizieren (aber temporär)
|
||
original_levelname = record.levelname
|
||
original_name = record.name
|
||
|
||
# Emojis hinzufügen
|
||
record.levelname = f"{level_emoji} {level_name}"
|
||
record.name = f"{category_emoji} {category_name}"
|
||
|
||
# Farbe hinzufügen wenn unterstützt
|
||
if USE_COLORS:
|
||
level_color = self.level_colors.get(original_levelname, ANSI_COLORS['RESET'])
|
||
record.levelname = f"{level_color}{record.levelname}{ANSI_COLORS['RESET']}"
|
||
record.name = f"{ANSI_COLORS['BOLD']}{record.name}{ANSI_COLORS['RESET']}"
|
||
|
||
# Formatieren
|
||
result = super().format(record)
|
||
|
||
# Originale Werte wiederherstellen
|
||
record.levelname = original_levelname
|
||
record.name = original_name
|
||
|
||
return result
|
||
except (UnicodeEncodeError, UnicodeDecodeError, AttributeError) as e:
|
||
# Fallback bei Unicode-Problemen: Verwende nur ASCII-Text
|
||
original_levelname = record.levelname
|
||
original_name = record.name
|
||
|
||
# Emojis durch ASCII-Fallbacks ersetzen
|
||
level_fallback = EMOJI_FALLBACK.get(LOG_EMOJIS.get(original_levelname, ''), '[LOG]')
|
||
category_name = record.name.split('.')[-1] if '.' in record.name else record.name
|
||
category_fallback = EMOJI_FALLBACK.get(LOG_EMOJIS.get(category_name, ''), '[CAT]')
|
||
|
||
record.levelname = f"{level_fallback} {original_levelname}"
|
||
record.name = f"{category_fallback} {category_name}"
|
||
|
||
# Basis-Formatierung ohne Farben
|
||
result = super().format(record)
|
||
|
||
# Originale Werte wiederherstellen
|
||
record.levelname = original_levelname
|
||
record.name = original_name
|
||
|
||
return result
|
||
|
||
class DebugInfoFilter(logging.Filter):
|
||
"""Filter, der Debug-Informationen zu jedem Log-Eintrag hinzufügt."""
|
||
|
||
def __init__(self, add_hostname=True, add_process_info=True):
|
||
super().__init__()
|
||
self.add_hostname = add_hostname
|
||
self.add_process_info = add_process_info
|
||
self.hostname = socket.gethostname() if add_hostname else None
|
||
self.pid = os.getpid() if add_process_info else None
|
||
|
||
def filter(self, record):
|
||
# Debug-Informationen hinzufügen
|
||
if self.add_hostname and not hasattr(record, 'hostname'):
|
||
record.hostname = self.hostname
|
||
|
||
if self.add_process_info and not hasattr(record, 'pid'):
|
||
record.pid = self.pid
|
||
|
||
# Zusätzliche Infos für DEBUG-Level
|
||
if record.levelno == logging.DEBUG:
|
||
# Funktionsname und Zeilennummer hervorheben
|
||
if USE_COLORS:
|
||
record.funcName = f"{ANSI_COLORS['CYAN']}{record.funcName}{ANSI_COLORS['RESET']}"
|
||
record.lineno = f"{ANSI_COLORS['CYAN']}{record.lineno}{ANSI_COLORS['RESET']}"
|
||
|
||
return True
|
||
|
||
def setup_logging(debug_mode: bool = False):
|
||
"""
|
||
Initialisiert das Logging-System und erstellt alle erforderlichen Verzeichnisse.
|
||
|
||
Args:
|
||
debug_mode: Wenn True, wird das Log-Level auf DEBUG gesetzt
|
||
"""
|
||
ensure_log_directories()
|
||
|
||
# Log-Level festlegen
|
||
log_level = logging.DEBUG if debug_mode else getattr(logging, LOG_LEVEL)
|
||
|
||
# Root-Logger konfigurieren
|
||
root_logger = logging.getLogger()
|
||
root_logger.setLevel(log_level)
|
||
|
||
# Alle Handler entfernen
|
||
for handler in root_logger.handlers[:]:
|
||
root_logger.removeHandler(handler)
|
||
|
||
# Formatter erstellen (mit und ohne Farben)
|
||
colored_formatter = ColoredFormatter(LOG_FORMAT, LOG_DATE_FORMAT)
|
||
file_formatter = logging.Formatter(LOG_FORMAT, LOG_DATE_FORMAT)
|
||
|
||
# Filter für zusätzliche Debug-Informationen
|
||
debug_filter = DebugInfoFilter()
|
||
|
||
# Console Handler für alle Logs
|
||
console_handler = logging.StreamHandler()
|
||
console_handler.setLevel(log_level)
|
||
console_handler.setFormatter(colored_formatter)
|
||
console_handler.addFilter(debug_filter)
|
||
|
||
# Windows PowerShell UTF-8 Encoding-Unterstützung
|
||
if os.name == 'nt' and hasattr(console_handler.stream, 'reconfigure'):
|
||
try:
|
||
console_handler.stream.reconfigure(encoding='utf-8')
|
||
except:
|
||
pass
|
||
|
||
root_logger.addHandler(console_handler)
|
||
|
||
# File Handler für allgemeine App-Logs
|
||
app_log_file = get_log_file("app")
|
||
app_handler = logging.handlers.RotatingFileHandler(
|
||
app_log_file, maxBytes=10*1024*1024, backupCount=5, encoding='utf-8'
|
||
)
|
||
app_handler.setLevel(log_level)
|
||
app_handler.setFormatter(file_formatter)
|
||
root_logger.addHandler(app_handler)
|
||
|
||
# Wenn Debug-Modus aktiv, Konfiguration loggen
|
||
if debug_mode:
|
||
bug_emoji = safe_emoji("🐞")
|
||
root_logger.debug(f"{bug_emoji} Debug-Modus aktiviert - Ausführliche Logs werden generiert")
|
||
|
||
def get_logger(category: str) -> logging.Logger:
|
||
"""
|
||
Gibt einen konfigurierten Logger für eine bestimmte Kategorie zurück.
|
||
|
||
Args:
|
||
category: Log-Kategorie (app, scheduler, auth, jobs, printers, errors)
|
||
|
||
Returns:
|
||
logging.Logger: Konfigurierter Logger
|
||
"""
|
||
if category in _loggers:
|
||
return _loggers[category]
|
||
|
||
# Logger erstellen
|
||
logger = logging.getLogger(f"myp.{category}")
|
||
logger.setLevel(getattr(logging, LOG_LEVEL))
|
||
|
||
# Verhindere doppelte Logs durch Parent-Logger
|
||
logger.propagate = False
|
||
|
||
# Formatter erstellen (mit und ohne Farben)
|
||
colored_formatter = ColoredFormatter(LOG_FORMAT, LOG_DATE_FORMAT)
|
||
file_formatter = logging.Formatter(LOG_FORMAT, LOG_DATE_FORMAT)
|
||
|
||
# Filter für zusätzliche Debug-Informationen
|
||
debug_filter = DebugInfoFilter()
|
||
|
||
# Console Handler
|
||
console_handler = logging.StreamHandler()
|
||
console_handler.setLevel(getattr(logging, LOG_LEVEL))
|
||
console_handler.setFormatter(colored_formatter)
|
||
console_handler.addFilter(debug_filter)
|
||
|
||
# Windows PowerShell UTF-8 Encoding-Unterstützung
|
||
if os.name == 'nt' and hasattr(console_handler.stream, 'reconfigure'):
|
||
try:
|
||
console_handler.stream.reconfigure(encoding='utf-8')
|
||
except:
|
||
pass
|
||
|
||
logger.addHandler(console_handler)
|
||
|
||
# File Handler für spezifische Kategorie
|
||
log_file = get_log_file(category)
|
||
file_handler = logging.handlers.RotatingFileHandler(
|
||
log_file, maxBytes=10*1024*1024, backupCount=5, encoding='utf-8'
|
||
)
|
||
file_handler.setLevel(getattr(logging, LOG_LEVEL))
|
||
file_handler.setFormatter(file_formatter)
|
||
logger.addHandler(file_handler)
|
||
|
||
# Error-Logs zusätzlich in errors.log schreiben
|
||
if category != "errors":
|
||
error_log_file = get_log_file("errors")
|
||
error_handler = logging.handlers.RotatingFileHandler(
|
||
error_log_file, maxBytes=10*1024*1024, backupCount=5, encoding='utf-8'
|
||
)
|
||
error_handler.setLevel(logging.ERROR)
|
||
error_handler.setFormatter(file_formatter)
|
||
logger.addHandler(error_handler)
|
||
|
||
_loggers[category] = logger
|
||
return logger
|
||
|
||
def log_startup_info():
|
||
"""Loggt Startup-Informationen."""
|
||
app_logger = get_logger("app")
|
||
rocket_emoji = safe_emoji("🚀")
|
||
folder_emoji = safe_emoji("📂")
|
||
chart_emoji = safe_emoji("📊")
|
||
computer_emoji = safe_emoji("💻")
|
||
globe_emoji = safe_emoji("🌐")
|
||
calendar_emoji = safe_emoji("📅")
|
||
|
||
app_logger.info("=" * 50)
|
||
app_logger.info(f"{rocket_emoji} MYP (Manage Your Printers) wird gestartet...")
|
||
app_logger.info(f"{folder_emoji} Log-Verzeichnis: {LOG_DIR}")
|
||
app_logger.info(f"{chart_emoji} Log-Level: {LOG_LEVEL}")
|
||
app_logger.info(f"{computer_emoji} Betriebssystem: {platform.system()} {platform.release()}")
|
||
app_logger.info(f"{globe_emoji} Hostname: {socket.gethostname()}")
|
||
app_logger.info(f"{calendar_emoji} Startzeit: {datetime.now().strftime('%d.%m.%Y %H:%M:%S')}")
|
||
app_logger.info("=" * 50)
|
||
|
||
# Hilfsfunktionen für das Debugging
|
||
|
||
def debug_request(logger: logging.Logger, request):
|
||
"""
|
||
Loggt detaillierte Informationen über eine HTTP-Anfrage.
|
||
|
||
Args:
|
||
logger: Logger-Instanz
|
||
request: Flask-Request-Objekt
|
||
"""
|
||
if logger.level > logging.DEBUG:
|
||
return
|
||
|
||
web_emoji = safe_emoji("🌐")
|
||
signal_emoji = safe_emoji("📡")
|
||
puzzle_emoji = safe_emoji("🧩")
|
||
clipboard_emoji = safe_emoji("📋")
|
||
search_emoji = safe_emoji("🔍")
|
||
|
||
logger.debug(f"{web_emoji} HTTP-Anfrage: {request.method} {request.path}")
|
||
logger.debug(f"{signal_emoji} Remote-Adresse: {request.remote_addr}")
|
||
logger.debug(f"{puzzle_emoji} Inhaltstyp: {request.content_type}")
|
||
|
||
# Nur relevante Headers ausgeben
|
||
important_headers = ['User-Agent', 'Referer', 'X-Forwarded-For', 'Authorization']
|
||
headers = {k: v for k, v in request.headers.items() if k in important_headers}
|
||
if headers:
|
||
logger.debug(f"{clipboard_emoji} Wichtige Headers: {headers}")
|
||
|
||
# Request-Parameter (max. 1000 Zeichen)
|
||
if request.args:
|
||
args_str = str(request.args)
|
||
if len(args_str) > 1000:
|
||
args_str = args_str[:997] + "..."
|
||
logger.debug(f"{search_emoji} URL-Parameter: {args_str}")
|
||
|
||
def debug_response(logger: logging.Logger, response, duration_ms: float = None):
|
||
"""
|
||
Loggt detaillierte Informationen über eine HTTP-Antwort.
|
||
|
||
Args:
|
||
logger: Logger-Instanz
|
||
response: Flask-Response-Objekt
|
||
duration_ms: Verarbeitungsdauer in Millisekunden (optional)
|
||
"""
|
||
if logger.level > logging.DEBUG:
|
||
return
|
||
|
||
status_emoji = safe_emoji("✅") if response.status_code < 400 else safe_emoji("❌")
|
||
logger.debug(f"{status_emoji} HTTP-Antwort: {response.status_code}")
|
||
|
||
if duration_ms is not None:
|
||
timer_emoji = safe_emoji("⏱️")
|
||
logger.debug(f"{timer_emoji} Verarbeitungsdauer: {duration_ms:.2f} ms")
|
||
|
||
content_length = response.content_length or 0
|
||
if content_length > 0:
|
||
size_str = f"{content_length / 1024:.1f} KB" if content_length > 1024 else f"{content_length} Bytes"
|
||
package_emoji = safe_emoji("📦")
|
||
logger.debug(f"{package_emoji} Antwortgröße: {size_str}")
|
||
|
||
def measure_execution_time(func=None, logger=None, task_name=None):
|
||
"""
|
||
Dekorator, der die Ausführungszeit einer Funktion misst und loggt.
|
||
|
||
Args:
|
||
func: Die zu dekorierende Funktion
|
||
logger: Logger-Instanz (optional)
|
||
task_name: Name der Aufgabe für das Logging (optional)
|
||
|
||
Returns:
|
||
Dekorierte Funktion
|
||
"""
|
||
from functools import wraps
|
||
|
||
def decorator(f):
|
||
@wraps(f)
|
||
def wrapper(*args, **kwargs):
|
||
start_time = time.time()
|
||
result = f(*args, **kwargs)
|
||
end_time = time.time()
|
||
|
||
duration_ms = (end_time - start_time) * 1000
|
||
name = task_name or f.__name__
|
||
|
||
if logger:
|
||
timer_emoji = safe_emoji('⏱️')
|
||
if duration_ms > 1000: # Länger als 1 Sekunde
|
||
logger.warning(f"{timer_emoji} Langsame Ausführung: {name} - {duration_ms:.2f} ms")
|
||
else:
|
||
logger.debug(f"{timer_emoji} Ausführungszeit: {name} - {duration_ms:.2f} ms")
|
||
|
||
return result
|
||
return wrapper
|
||
|
||
if func:
|
||
return decorator(func)
|
||
return decorator |