Improve Docker container memory monitoring with cgroup v1/v2 support and better logging

utils/system_monitor.py

@@ -32,31 +32,75 @@ def get_memory_usage() -> Dict[str, Any]:
                 # Pas de limite cgroup lisible
                 pass
                 
-        # Récupérer les informations de mémoire virtuelle
-        virtual_memory = psutil.virtual_memory()
+        # Déterminer la mémoire totale pour Hugging Face Spaces (32GB)
+        total_memory = 32 * (1024**3)  # 32 GB en octets fixe pour Hugging Face
         
-        # Déterminer la mémoire totale - utiliser la limite du conteneur si disponible
-        total_memory = container_limit if container_limit else virtual_memory.total
+        # Essayer une approche plus directe pour les conteneurs Docker
+        docker_memory_used = None
+        memory_source = "unknown"
         
-        # Ajuster la valeur totale pour les environnements Hugging Face si toujours anormalement haute
-        # Cette instance Hugging Face a 32 Go de RAM
-        if total_memory > 100 * (1024**3):  # Si la valeur semble trop élevée (>100GB)
-            # Force la valeur à 32GB pour le conteneur Hugging Face
-            total_memory = 32 * (1024**3)  # 32 GB en octets
+        # Log du début de la tentative de lecture
+        logger.info("Tentative de lecture des informations de mémoire Docker...")
         
-        # Calculer les valeurs avec la mémoire totale ajustée
-        used_memory = virtual_memory.used
-        available_memory = min(virtual_memory.available, total_memory - used_memory)
+        try:
+            # Lire la mémoire utilisée directement depuis les stats cgroup v1
+            cgroup_path = '/sys/fs/cgroup/memory/memory.usage_in_bytes'
+            with open(cgroup_path, 'r') as f:
+                docker_memory_used = int(f.read().strip())
+                memory_source = f"cgroup v1 ({cgroup_path})"
+                logger.info(f"Mémoire Docker lue depuis {memory_source}: {docker_memory_used / (1024*1024):.2f} Mo")
+        except (IOError, FileNotFoundError) as e:
+            logger.info(f"Impossible de lire depuis cgroup v1: {e}")
+            try:
+                # Essayer le chemin cgroup v2
+                cgroup_path = '/sys/fs/cgroup/memory.current'
+                with open(cgroup_path, 'r') as f:
+                    docker_memory_used = int(f.read().strip())
+                    memory_source = f"cgroup v2 ({cgroup_path})"
+                    logger.info(f"Mémoire Docker lue depuis {memory_source}: {docker_memory_used / (1024*1024):.2f} Mo")
+            except (IOError, FileNotFoundError) as e:
+                logger.info(f"Impossible de lire depuis cgroup v2: {e}")
+                # Utiliser le RSS du processus Python comme approximation
+                docker_memory_used = psutil.Process().memory_info().rss
+                memory_source = "RSS du processus Python"
+                logger.info(f"Mémoire utilisée approximative depuis {memory_source}: {docker_memory_used / (1024*1024):.2f} Mo")
+        
+        # Si nous n'avons pas pu lire directement la mémoire du conteneur
+        # Utiliser les informations du système mais avec une correction
+        virtual_memory = psutil.virtual_memory()
         
-        # Vérifier pour plus de logique
-        if available_memory < 0:
-            available_memory = 0
+        # Utiliser la valeur Docker si disponible, sinon utiliser une approximation
+        # Dans Hugging Face Spaces, la vraie mémoire utilisée est généralement plus proche
+        # de la mémoire RSS du processus Python
+        logger.info(f"Informations psutil - total: {virtual_memory.total / (1024*1024):.2f} Mo, utilisé: {virtual_memory.used / (1024*1024):.2f} Mo")
+        
+        if docker_memory_used:
+            used_memory = docker_memory_used
+            logger.info(f"Utilisation de la mémoire depuis {memory_source}")
+        else:
+            # Approche conservatrice: utiliser 10% du total rapporté par psutil ou la mémoire RSS
+            # Cela correspond mieux à ce que HF affiche typiquement
+            process_rss = psutil.Process().memory_info().rss
+            psutil_adjusted = virtual_memory.used * 0.10
+            used_memory = max(process_rss, psutil_adjusted)
+            
+            logger.info(f"Utilisation de la mémoire estimée - RSS: {process_rss / (1024*1024):.2f} Mo, psutil ajusté: {psutil_adjusted / (1024*1024):.2f} Mo")
+            memory_source = "estimation (max de RSS et psutil ajusté)"
+        
+        # S'assurer que la mémoire utilisée ne dépasse pas le total
+        used_memory = min(used_memory, total_memory)
+        
+        # Calculer la mémoire disponible
+        available_memory = total_memory - used_memory
         
         # Calculer les pourcentages
-        try:
-            percent_used = (used_memory / total_memory) * 100 if total_memory > 0 else 0
-        except ZeroDivisionError:
-            percent_used = 0
+        percent_used = (used_memory / total_memory) * 100 if total_memory > 0 else 0
+        
+        # Log des résultats finaux
+        logger.info(f"Mémoire totale: {total_memory / (1024*1024):.2f} Mo (fixée à 32 Go)")
+        logger.info(f"Mémoire utilisée: {used_memory / (1024*1024):.2f} Mo (source: {memory_source})")
+        logger.info(f"Mémoire disponible: {available_memory / (1024*1024):.2f} Mo")
+        logger.info(f"Pourcentage utilisé: {percent_used:.1f}%")
             
         # Convertir les bytes en Mo pour être plus lisible
         memory_info = {