vnai 2.0.2__py3-none-any.whl → 2.0.4__py3-none-any.whl

vnai/beam/pulse.py

@@ -1,31 +1,109 @@
-_B='status'
-_A='healthy'
-import threading,time
+# vnai/beam/pulse.py
+# System health and performance monitoring
+
+import threading
+import time
 from datetime import datetime
+
 class Monitor:
-	_instance=None;_lock=threading.Lock()
-	def __new__(A):
-		with A._lock:
-			if A._instance is None:A._instance=super(Monitor,A).__new__(A);A._instance._initialize()
-			return A._instance
-	def _initialize(A):A.health_status=_A;A.last_check=time.time();A.check_interval=300;A.error_count=0;A.warning_count=0;A.status_history=[];A._start_background_check()
-	def _start_background_check(A):
-		def B():
-			while True:
-				try:A.check_health()
-				except:pass
-				time.sleep(A.check_interval)
-		C=threading.Thread(target=B,daemon=True);C.start()
-	def check_health(A):
-		from vnai.beam.metrics import collector as F;from vnai.beam.quota import guardian as G;A.last_check=time.time();B=F.get_metrics_summary();C=B.get('error',0)>0;D=G.usage();E=D>80
-		if C and E:A.health_status='critical';A.error_count+=1
-		elif C or E:A.health_status='warning';A.warning_count+=1
-		else:A.health_status=_A
-		A.status_history.append({'timestamp':datetime.now().isoformat(),_B:A.health_status,'metrics':B,'resource_usage':D})
-		if len(A.status_history)>10:A.status_history=A.status_history[-10:]
-		return A.health_status
-	def report(A):
-		if time.time()-A.last_check>A.check_interval:A.check_health()
-		return{_B:A.health_status,'last_check':datetime.fromtimestamp(A.last_check).isoformat(),'error_count':A.error_count,'warning_count':A.warning_count,'history':A.status_history[-3:]}
-	def reset(A):A.health_status=_A;A.error_count=0;A.warning_count=0;A.status_history=[];A.last_check=time.time()
-monitor=Monitor()
+    """Monitors system health and performance"""
+    
+    _instance = None
+    _lock = threading.Lock()
+    
+    def __new__(cls):
+        with cls._lock:
+            if cls._instance is None:
+                cls._instance = super(Monitor, cls).__new__(cls)
+                cls._instance._initialize()
+            return cls._instance
+    
+    def _initialize(self):
+        """Initialize monitor"""
+        self.health_status = "healthy"
+        self.last_check = time.time()
+        self.check_interval = 300  # seconds
+        self.error_count = 0
+        self.warning_count = 0
+        self.status_history = []
+        
+        # Start background health check thread
+        self._start_background_check()
+    
+    def _start_background_check(self):
+        """Start background health check thread"""
+        def check_health():
+            while True:
+                try:
+                    self.check_health()
+                except:
+                    pass  # Don't let errors stop the monitor
+                time.sleep(self.check_interval)
+        
+        thread = threading.Thread(target=check_health, daemon=True)
+        thread.start()
+    
+    def check_health(self):
+        """Check system health status"""
+        from vnai.beam.metrics import collector
+        from vnai.beam.quota import guardian
+        
+        # Record check time
+        self.last_check = time.time()
+        
+        # Check metrics collector health
+        metrics_summary = collector.get_metrics_summary()
+        has_errors = metrics_summary.get("error", 0) > 0
+        
+        # Check resource usage
+        resource_usage = guardian.usage()
+        high_usage = resource_usage > 80  # Over 80% of rate limits
+        
+        # Determine health status
+        if has_errors and high_usage:
+            self.health_status = "critical"
+            self.error_count += 1
+        elif has_errors or high_usage:
+            self.health_status = "warning"
+            self.warning_count += 1
+        else:
+            self.health_status = "healthy"
+        
+        # Record health status
+        self.status_history.append({
+            "timestamp": datetime.now().isoformat(),
+            "status": self.health_status,
+            "metrics": metrics_summary,
+            "resource_usage": resource_usage
+        })
+        
+        # Keep history limited to last 10 entries
+        if len(self.status_history) > 10:
+            self.status_history = self.status_history[-10:]
+        
+        return self.health_status
+    
+    def report(self):
+        """Get health report"""
+        # Ensure we have a fresh check if last one is old
+        if time.time() - self.last_check > self.check_interval:
+            self.check_health()
+            
+        return {
+            "status": self.health_status,
+            "last_check": datetime.fromtimestamp(self.last_check).isoformat(),
+            "error_count": self.error_count,
+            "warning_count": self.warning_count,
+            "history": self.status_history[-3:],  # Last 3 entries
+        }
+    
+    def reset(self):
+        """Reset health monitor"""
+        self.health_status = "healthy"
+        self.error_count = 0
+        self.warning_count = 0
+        self.status_history = []
+        self.last_check = time.time()
+
+# Create singleton instance
+monitor = Monitor()