|
|
| """
|
| Performance monitoring script for the CVE RAG System
|
| """
|
|
|
| import time
|
| import asyncio
|
| import aiohttp
|
| import json
|
| import logging
|
| from typing import Dict, List
|
| from datetime import datetime
|
|
|
|
|
| logging.basicConfig(level=logging.INFO)
|
| logger = logging.getLogger(__name__)
|
|
|
| class PerformanceMonitor:
|
| """Monitor API performance and response times"""
|
|
|
| def __init__(self, api_url: str = "http://localhost:8000"):
|
| self.api_url = api_url
|
| self.session = None
|
|
|
| async def _get_session(self):
|
| """Get or create aiohttp session"""
|
| if self.session is None or self.session.closed:
|
| timeout = aiohttp.ClientTimeout(total=60)
|
| self.session = aiohttp.ClientSession(timeout=timeout)
|
| return self.session
|
|
|
| async def test_query_performance(self, query: str, use_large_model: bool = False) -> Dict:
|
| """Test query performance and return metrics"""
|
| start_time = time.time()
|
|
|
| try:
|
| session = await self._get_session()
|
|
|
| payload = {
|
| "query": query,
|
| "top_k": 10,
|
| "max_context_docs": 5,
|
| "use_large_model": use_large_model
|
| }
|
|
|
| async with session.post(f"{self.api_url}/api/v1/query", json=payload) as response:
|
| end_time = time.time()
|
| response_time = end_time - start_time
|
|
|
| if response.status == 200:
|
| data = await response.json()
|
| return {
|
| "status": "success",
|
| "response_time": response_time,
|
| "query": query,
|
| "model_used": data.get('model_used', 'unknown'),
|
| "processing_time": data.get('processing_time', 0),
|
| "results_count": len(data.get('search_results', [])),
|
| "response_length": len(data.get('response', ''))
|
| }
|
| else:
|
| error_text = await response.text()
|
| return {
|
| "status": "error",
|
| "response_time": response_time,
|
| "query": query,
|
| "error": f"{response.status}: {error_text}"
|
| }
|
|
|
| except Exception as e:
|
| end_time = time.time()
|
| return {
|
| "status": "error",
|
| "response_time": end_time - start_time,
|
| "query": query,
|
| "error": str(e)
|
| }
|
|
|
| async def test_search_performance(self, query: str) -> Dict:
|
| """Test search-only performance"""
|
| start_time = time.time()
|
|
|
| try:
|
| session = await self._get_session()
|
|
|
| payload = {
|
| "query": query,
|
| "top_k": 10
|
| }
|
|
|
| async with session.post(f"{self.api_url}/api/v1/search", json=payload) as response:
|
| end_time = time.time()
|
| response_time = end_time - start_time
|
|
|
| if response.status == 200:
|
| data = await response.json()
|
| return {
|
| "status": "success",
|
| "response_time": response_time,
|
| "query": query,
|
| "results_count": len(data)
|
| }
|
| else:
|
| error_text = await response.text()
|
| return {
|
| "status": "error",
|
| "response_time": response_time,
|
| "query": query,
|
| "error": f"{response.status}: {error_text}"
|
| }
|
|
|
| except Exception as e:
|
| end_time = time.time()
|
| return {
|
| "status": "error",
|
| "response_time": end_time - start_time,
|
| "query": query,
|
| "error": str(e)
|
| }
|
|
|
| async def test_health_check(self) -> Dict:
|
| """Test health check endpoint"""
|
| start_time = time.time()
|
|
|
| try:
|
| session = await self._get_session()
|
|
|
| async with session.get(f"{self.api_url}/api/v1/health") as response:
|
| end_time = time.time()
|
| response_time = end_time - start_time
|
|
|
| if response.status == 200:
|
| data = await response.json()
|
| return {
|
| "status": "success",
|
| "response_time": response_time,
|
| "health_status": data.get('status'),
|
| "gpu_available": data.get('gpu_available'),
|
| "vector_db_documents": data.get('vector_db_documents'),
|
| "model_loaded": data.get('model_loaded')
|
| }
|
| else:
|
| error_text = await response.text()
|
| return {
|
| "status": "error",
|
| "response_time": response_time,
|
| "error": f"{response.status}: {error_text}"
|
| }
|
|
|
| except Exception as e:
|
| end_time = time.time()
|
| return {
|
| "status": "error",
|
| "response_time": end_time - start_time,
|
| "error": str(e)
|
| }
|
|
|
| async def run_performance_tests(self) -> Dict:
|
| """Run comprehensive performance tests"""
|
| logger.info("Starting performance tests...")
|
|
|
|
|
| test_queries = [
|
| "What is CVE-2021-44228?",
|
| "Show me Microsoft vulnerabilities",
|
| "Find SQL injection vulnerabilities",
|
| "What are critical vulnerabilities from 2024?",
|
| "Summarize 5G related vulnerabilities"
|
| ]
|
|
|
| results = {
|
| "timestamp": datetime.now().isoformat(),
|
| "health_check": await self.test_health_check(),
|
| "search_tests": [],
|
| "query_tests": []
|
| }
|
|
|
|
|
| logger.info("Testing search performance...")
|
| for query in test_queries:
|
| result = await self.test_search_performance(query)
|
| results["search_tests"].append(result)
|
| await asyncio.sleep(1)
|
|
|
|
|
| logger.info("Testing full query performance...")
|
| for query in test_queries:
|
| result = await self.test_query_performance(query, use_large_model=False)
|
| results["query_tests"].append(result)
|
| await asyncio.sleep(2)
|
|
|
|
|
| search_times = [r["response_time"] for r in results["search_tests"] if r["status"] == "success"]
|
| query_times = [r["response_time"] for r in results["query_tests"] if r["status"] == "success"]
|
|
|
| if search_times:
|
| results["search_stats"] = {
|
| "avg_response_time": sum(search_times) / len(search_times),
|
| "min_response_time": min(search_times),
|
| "max_response_time": max(search_times),
|
| "success_rate": len(search_times) / len(results["search_tests"])
|
| }
|
|
|
| if query_times:
|
| results["query_stats"] = {
|
| "avg_response_time": sum(query_times) / len(query_times),
|
| "min_response_time": min(query_times),
|
| "max_response_time": max(query_times),
|
| "success_rate": len(query_times) / len(results["query_tests"])
|
| }
|
|
|
| return results
|
|
|
| async def close(self):
|
| """Close the session"""
|
| if self.session and not self.session.closed:
|
| await self.session.close()
|
|
|
| def main():
|
| """Main function"""
|
| async def run_tests():
|
| monitor = PerformanceMonitor()
|
| try:
|
| results = await monitor.run_performance_tests()
|
|
|
|
|
| print("\n" + "="*60)
|
| print("CVE RAG SYSTEM PERFORMANCE REPORT")
|
| print("="*60)
|
| print(f"Timestamp: {results['timestamp']}")
|
|
|
|
|
| health = results["health_check"]
|
| print(f"\nHealth Check: {health['status']}")
|
| if health['status'] == 'success':
|
| print(f" Response Time: {health['response_time']:.2f}s")
|
| print(f" System Status: {health['health_status']}")
|
| print(f" GPU Available: {health['gpu_available']}")
|
| print(f" Vector DB Documents: {health['vector_db_documents']}")
|
| print(f" Model Loaded: {health['model_loaded']}")
|
|
|
|
|
| if "search_stats" in results:
|
| stats = results["search_stats"]
|
| print(f"\nSearch Performance:")
|
| print(f" Average Response Time: {stats['avg_response_time']:.2f}s")
|
| print(f" Min Response Time: {stats['min_response_time']:.2f}s")
|
| print(f" Max Response Time: {stats['max_response_time']:.2f}s")
|
| print(f" Success Rate: {stats['success_rate']:.1%}")
|
|
|
|
|
| if "query_stats" in results:
|
| stats = results["query_stats"]
|
| print(f"\nFull Query Performance:")
|
| print(f" Average Response Time: {stats['avg_response_time']:.2f}s")
|
| print(f" Min Response Time: {stats['min_response_time']:.2f}s")
|
| print(f" Max Response Time: {stats['max_response_time']:.2f}s")
|
| print(f" Success Rate: {stats['success_rate']:.1%}")
|
|
|
|
|
| print(f"\nDetailed Results:")
|
| for i, result in enumerate(results["query_tests"]):
|
| status = "SUCCESS" if result["status"] == "success" else "ERROR"
|
| print(f" [{status}] {result['query']}: {result['response_time']:.2f}s")
|
| if result["status"] == "error":
|
| print(f" Error: {result['error']}")
|
|
|
|
|
| with open("performance_report.json", "w") as f:
|
| json.dump(results, f, indent=2)
|
| print(f"\nDetailed report saved to: performance_report.json")
|
|
|
| finally:
|
| await monitor.close()
|
|
|
| asyncio.run(run_tests())
|
|
|
| if __name__ == "__main__":
|
| main() |
