Remove unused metrics, health check, and unit test files

Deleted obsolete `metrics.py`, `health.py`, and their related unit test files. These files are no longer relevant to the project, reducing unnecessary code and improving project maintainability.

Author: liornabat

main.py

@@ -3,7 +3,6 @@
 
 os.environ.setdefault("MQ_FILE_PATH", os.path.join(os.getcwd(), "mq_files/windows"))
 import signal
-import anyio
 from src.bindings.bindings import Bindings
 from src.common.log import get_logger
 from src.api.app import APIServer
@@ -35,19 +34,19 @@ async def main():
         logger.info("Starting KubeMQ - IBM MQ bindings")
         bindings = Bindings(config_path)
         bindings.init()
-        
+
         # Initialize and start the API server
         api_port = int(os.environ.get("API_PORT", "9000"))
         api_host = os.environ.get("API_HOST", "0.0.0.0")
         logger.info(f"Initializing API server on {api_host}:{api_port}")
         api_server = APIServer(bindings, host=api_host, port=api_port)
-        
+
         # Start bindings and API server
         await bindings.start()
         await api_server.start()
-        
+
         logger.info("KubeMQ - IBM MQ bindings and API server started successfully")
-        
+
         # Wait for shutdown signal instead of infinite loop
         await shutdown_event.wait()
 

pyproject.toml

@@ -8,7 +8,7 @@ dependencies = [
     "aiodebug>=2.3.0",
     "anyio>=4.7.0",
     "asyncer>=0.0.8",
-    "kubemq>=3.4.2",
+    "kubemq>=3.5.3",
     "loguru>=0.7.3",
     "pydantic>=2.10.4",
     "pymqi>=1.12.10",

requirements.txt

@@ -2,7 +2,7 @@ setuptools>=70.0.0
 aiodebug>=2.3.0
 anyio>=4.7.0
 asyncer>=0.0.8
-kubemq>=3.4.2
+kubemq>=3.5.3
 pydantic>=2.10.4
 pymqi>=1.12.10
 python-dotenv>=1.0.1

src/bindings/binding.py

@@ -8,7 +8,6 @@
 from src.kubemq.client import KubeMQClient
 from src.kubemq.config import Config as KubeMQConfig
 from src.ibm_mq.config import Config as IBMMQConfig
-from src.bindings.metrics import BindingMetricsCollector
 
 
 class Binding:
@@ -17,7 +16,6 @@ def __init__(self, config: BindingConfig):
         self.source: Connection | None = None
         self.target: Connection | None = None
         self.logger = get_logger(f"binding.{self.config.name}")
-        self.metrics_collector: BindingMetricsCollector | None = None
 
     def init(self):
         """
@@ -71,14 +69,6 @@ def init(self):
             msg = f"Error {target_err} initialization: {str(e)}"
             self.logger.error(msg)
             raise BindingConfigError(msg)
-            
-        # Initialize binding metrics collector
-        if self.source and self.target:
-            self.metrics_collector = BindingMetricsCollector(
-                self.config.name,
-                self.source.metrics,
-                self.target.metrics
-            )
 
     async def start(self):
         await self.target.start()
@@ -88,66 +78,55 @@ async def start(self):
     async def stop(self):
         await self.source.stop()
         await self.target.stop()
-        
-    def get_metrics(self) -> Dict[str, Any]:
-        """Get metrics from both source and target connections and aggregate them.
-        
-        Returns:
-            Dict containing aggregated metrics from source and target connections
-        """
-        if self.metrics_collector:
-            return self.metrics_collector.get_metrics()
-        
-        # Fallback if metrics collector is not initialized
-        metrics = {
-            "binding_name": self.config.name,
-            "binding_type": self.config.type.value,
-            "source": None,
-            "target": None
-        }
-        
-        if self.source:
-            metrics["source"] = self.source.get_metrics()
-            
-        if self.target:
-            metrics["target"] = self.target.get_metrics()
-            
-        return metrics
-        
-    async def check_health(self) -> Dict[str, Any]:
-        """Check health of both source and target connections.
-        
+
+    async def is_healthy(self) -> bool:
+        """Check if the binding is healthy.
+
         Returns:
-            Dict containing health information for the binding
+            bool: True if both source and target are healthy, False otherwise
         """
-        health = {
-            "binding_name": self.config.name,
-            "binding_type": self.config.type.value,
-            "status": "healthy",
-            "source": None,
-            "target": None
-        }
-        
         try:
-            if self.source:
-                source_health = await self.source.check_health()
-                health["source"] = source_health
-                if source_health["status"] != "healthy":
-                    health["status"] = "unhealthy"
+            source_healthy = await self.source.is_healthy() if self.source else False
+            target_healthy = await self.target.is_healthy() if self.target else False
+
+            return source_healthy and target_healthy
         except Exception as e:
-            self.logger.error(f"Error checking source health: {str(e)}")
-            health["status"] = "unhealthy"
-            health["source"] = {"status": "unhealthy", "error": str(e)}
-            
+            self.logger.error(f"Error checking binding health: {str(e)}")
+            return False
+
+    async def get_detailed_health(self) -> Dict[str, Any]:
+        """Get detailed health status including source and target.
+
+        Returns:
+            Dict containing health information for the binding and its components
+        """
         try:
-            if self.target:
-                target_health = await self.target.check_health()
-                health["target"] = target_health
-                if target_health["status"] != "healthy":
-                    health["status"] = "unhealthy"
+            # Check source health
+            source_healthy = await self.source.is_healthy() if self.source else False
+
+            # Check target health
+            target_healthy = await self.target.is_healthy() if self.target else False
+
+            # Determine binding health
+            binding_healthy = source_healthy and target_healthy
+
+            # Create health response
+            health = {
+                "binding_name": self.config.name,
+                "binding_type": self.config.type.value,
+                "is_healthy": binding_healthy,
+                "source": {"is_healthy": source_healthy},
+                "target": {"is_healthy": target_healthy},
+            }
+
+            return health
         except Exception as e:
-            self.logger.error(f"Error checking target health: {str(e)}")
-            health["status"] = "unhealthy"
-            health["target"] = {"status": "unhealthy", "error": str(e)}
-            
-        return health
+            self.logger.error(f"Error getting detailed health: {str(e)}")
+            return {
+                "binding_name": self.config.name,
+                "binding_type": self.config.type.value,
+                "is_healthy": False,
+                "error": str(e),
+                "source": {"is_healthy": False},
+                "target": {"is_healthy": False},
+            }

src/bindings/bindings.py

@@ -4,15 +4,13 @@
 from src.bindings.binding import Binding
 from src.bindings.config import BindingsConfig
 from src.common.log import get_logger
-from src.bindings.metrics import SystemMetricsCollector
 
 
 class Bindings:
     def __init__(self, config_path: str):
         self.logger = get_logger("binding_manager")
         self.config = BindingsConfig.load(config_path)
         self.bindings: List[Binding] = []
-        self.system_metrics = SystemMetricsCollector()
 
     def init(self):
         try:
@@ -21,10 +19,6 @@ def init(self):
                 new_binding = Binding(binding)
                 new_binding.init()
                 self.bindings.append(new_binding)
-                
-                # Add binding to system metrics if it has a metrics collector
-                if new_binding.metrics_collector:
-                    self.system_metrics.add_binding(new_binding.config.name, new_binding.metrics_collector)
         except Exception as e:
             raise Exception(f"Error initializing bindings: {str(e)}")
 
@@ -41,78 +35,55 @@ async def stop(self):
             tasks.append(binding.stop())
 
         await asyncio.gather(*tasks)
-        
-    def get_all_metrics(self) -> Dict[str, Any]:
-        """Get aggregated metrics from all bindings.
-        
+
+    async def is_healthy(self) -> bool:
+        """Check if all bindings are healthy.
+
         Returns:
-            Dict containing system-level metrics and metrics from all bindings
+            bool: True if all bindings are healthy, False otherwise
         """
-        # Use system metrics collector for aggregated metrics
-        return self.system_metrics.get_metrics()
-    
-    async def check_all_health(self) -> Dict[str, Any]:
-        """Check health of all bindings.
-        
+        for binding in self.bindings:
+            try:
+                if not await binding.is_healthy():
+                    return False
+            except Exception as e:
+                self.logger.error(
+                    f"Error checking health for binding {binding.config.name}: {str(e)}"
+                )
+                return False
+
+        return True
+
+    async def get_detailed_health_status(self) -> Dict[str, Any]:
+        """Get detailed health status for all bindings.
+
         Returns:
-            Dict containing health information for all bindings
+            Dict containing detailed health information for all bindings
         """
+        # Get overall system health
+        system_healthy = await self.is_healthy()
+
         health = {
             "bindings_count": len(self.bindings),
-            "overall_status": "healthy",
-            "bindings": {}
+            "is_healthy": system_healthy,
+            "bindings": {},
         }
-        
+
+        # Get health for each binding
         for binding in self.bindings:
             try:
-                binding_health = await binding.check_health()
+                binding_health = await binding.get_detailed_health()
                 health["bindings"][binding.config.name] = binding_health
-                
-                # Update overall status based on binding status
-                if binding_health["status"] == "unhealthy":
-                    health["overall_status"] = "unhealthy"
             except Exception as e:
-                self.logger.error(f"Error checking health for binding {binding.config.name}: {str(e)}")
+                self.logger.error(
+                    f"Error checking health for binding {binding.config.name}: {str(e)}"
+                )
                 health["bindings"][binding.config.name] = {
-                    "status": "unhealthy",
-                    "error": str(e)
+                    "binding_name": binding.config.name,
+                    "is_healthy": False,
+                    "error": str(e),
+                    "source": {"is_healthy": False},
+                    "target": {"is_healthy": False},
                 }
-                health["overall_status"] = "unhealthy"
-                
+
         return health
-        
-    async def get_binding_metrics(self, binding_name: str) -> Dict[str, Any]:
-        """Get metrics for a specific binding.
-        
-        Args:
-            binding_name: Name of the binding to get metrics for
-            
-        Returns:
-            Dict containing metrics for the specified binding or error if not found
-            
-        Raises:
-            ValueError: If binding with the specified name is not found
-        """
-        for binding in self.bindings:
-            if binding.config.name == binding_name:
-                return binding.get_metrics()
-                
-        raise ValueError(f"Binding with name '{binding_name}' not found")
-        
-    async def get_binding_health(self, binding_name: str) -> Dict[str, Any]:
-        """Check health for a specific binding.
-        
-        Args:
-            binding_name: Name of the binding to check health for
-            
-        Returns:
-            Dict containing health information for the specified binding
-            
-        Raises:
-            ValueError: If binding with the specified name is not found
-        """
-        for binding in self.bindings:
-            if binding.config.name == binding_name:
-                return await binding.check_health()
-                
-        raise ValueError(f"Binding with name '{binding_name}' not found")

src/bindings/connection.py

@@ -1,5 +1,4 @@
 from abc import ABC, abstractmethod
-from typing import Dict, Any
 
 
 class Connection(ABC):
@@ -20,19 +19,10 @@ async def send_message(self, message: bytes):
         pass
 
     @abstractmethod
-    async def check_health(self) -> Dict[str, Any]:
-        """Check the health of the connection.
-        
-        Returns:
-            Dict containing health status information
-        """
-        pass
+    async def is_healthy(self) -> bool:
+        """Check if the connection is healthy.
 
-    @abstractmethod
-    def get_metrics(self) -> Dict[str, Any]:
-        """Get all metrics for this connection.
-        
         Returns:
-            Dict containing all metrics data
+            bool: True if healthy, False otherwise
         """
         pass