feat:

--ADDED performance matrix for db

main.py

@@ -8,7 +8,7 @@ import jwt
 from pydantic import BaseModel
 from psycopg2.extras import RealDictCursor
 import asyncio
-
+import time
 load_dotenv()
 app = FastAPI()
 
@@ -590,12 +590,205 @@ async def database_active_connections_monitor(websocket: WebSocket):
         )
 
 
+#TPS
+def get_database_tps(data: DatabaseRequest):
 
+    conn = None
+    cursor = None
 
+    try:
 
+        conn = psycopg2.connect(
+            host=data.host,
+            port=data.port,
+            dbname=data.dbname,
+            user=data.user,
+            password=data.password,
+            connect_timeout=3
+        )
 
+        conn.autocommit = True
+        cursor = conn.cursor()
 
+        # First sample
+        cursor.execute("""
+            SELECT
+                xact_commit + xact_rollback
+            FROM pg_stat_database
+            WHERE datname = %s;
+        """, (data.dbname,))
 
+        first_count = cursor.fetchone()[0]
+
+        start_time = time.monotonic()
+
+        time.sleep(1)
+
+        # Second sample
+        cursor.execute("""
+            SELECT
+                xact_commit + xact_rollback
+            FROM pg_stat_database
+            WHERE datname = %s;
+        """, (data.dbname,))
+
+        second_count = cursor.fetchone()[0]
+
+        end_time = time.monotonic()
+
+        elapsed_time = end_time - start_time
+
+        transactions = second_count - first_count
+
+        tps = round(
+            transactions / elapsed_time,
+            2
+        )
+
+        return {
+            "database_name": data.dbname,
+            "tps": tps
+        }
+
+    except psycopg2.Error as e:
+
+        return {
+            "database_name": data.dbname,
+            "tps": None,
+            "error": str(e)
+        }
+
+    finally:
+
+        if cursor:
+            cursor.close()
+
+        if conn:
+            conn.close()
+
+# CACHE HIT RATIO
+def get_cache_hit_ratio(data: DatabaseRequest):
+
+    conn = None
+    cursor = None
+
+    try:
+
+        conn = psycopg2.connect(
+            host=data.host,
+            port=data.port,
+            dbname=data.dbname,
+            user=data.user,
+            password=data.password,
+            connect_timeout=3
+        )
+
+        cursor = conn.cursor()
+
+        cursor.execute("""
+            SELECT
+                CASE
+                    WHEN (blks_hit + blks_read) = 0 THEN 0
+                    ELSE ROUND(
+                        (blks_hit::numeric /
+                        (blks_hit + blks_read)) * 100,
+                        2
+                    )
+                END AS cache_hit_ratio
+            FROM pg_stat_database
+            WHERE datname = %s;
+        """, (data.dbname,))
+
+        row = cursor.fetchone()
+
+        cache_hit_ratio = float(row[0]) if row else 0.0
+
+        return {
+            "database_name": data.dbname,
+            "cache_hit_ratio": cache_hit_ratio
+        }
+
+    except psycopg2.Error as e:
+
+        return {
+            "database_name": data.dbname,
+            "cache_hit_ratio": None,
+            "error": str(e)
+        }
+
+    finally:
+
+        if cursor:
+            cursor.close()
+
+        if conn:
+            conn.close()
+
+#TPS AND CACHE HIT RATIO WEB SOCKET
+@app.websocket("/ws/database/performance")
+async def database_performance_monitor(websocket: WebSocket):
+
+    await websocket.accept()
+
+    try:
+
+        raw_data = await websocket.receive_json()
+
+        data = DatabaseRequest(**raw_data)
+
+        while True:
+
+            try:
+
+                (
+                    tps_result,
+                    cache_hit_result
+                ) = await asyncio.wait_for(
+
+                    asyncio.gather(
+
+                        asyncio.to_thread(
+                            get_database_tps,
+                            data
+                        ),
+
+                        asyncio.to_thread(
+                            get_cache_hit_ratio,
+                            data
+                        )
+
+                    ),
+
+                    timeout=5
+                )
+
+                result = {
+                    "database_name": data.dbname,
+
+                    "tps": tps_result[
+                        "tps"
+                    ],
+
+                    "cache_hit_ratio": cache_hit_result[
+                        "cache_hit_ratio"
+                    ]
+                }
+
+            except asyncio.TimeoutError:
+
+                result = {
+                    "database_name": data.dbname,
+                    "tps": None,
+                    "cache_hit_ratio": None
+                }
+
+            await websocket.send_json(result)
+
+            await asyncio.sleep(2)
+
+    except WebSocketDisconnect:
+
+        print("Database performance WebSocket disconnected")
 
 
 if __name__ == "__main__":