full-stack-todo / src /utils /performance.py
umarwaqar's picture
pushing code
bbeedce
Raw History Blame Contribute Delete
5.34 kB
"""
Performance optimization utilities for the Todo application
"""
from functools import lru_cache
from typing import Optional
import time
class PerformanceMonitor:
"""Monitor and log performance metrics"""
def __init__(self):
self.metrics = {}
def record_metric(self, operation: str, duration: float):
"""Record a performance metric"""
if operation not in self.metrics:
self.metrics[operation] = {
'count': 0,
'total_time': 0,
'min_time': float('inf'),
'max_time': 0
}
self.metrics[operation]['count'] += 1
self.metrics[operation]['total_time'] += duration
self.metrics[operation]['min_time'] = min(self.metrics[operation]['min_time'], duration)
self.metrics[operation]['max_time'] = max(self.metrics[operation]['max_time'], duration)
def get_metrics(self, operation: Optional[str] = None):
"""Get performance metrics"""
if operation:
if operation in self.metrics:
metric = self.metrics[operation]
return {
'operation': operation,
'count': metric['count'],
'avg_time': metric['total_time'] / metric['count'],
'min_time': metric['min_time'],
'max_time': metric['max_time']
}
return None
return {
op: {
'count': m['count'],
'avg_time': m['total_time'] / m['count'],
'min_time': m['min_time'],
'max_time': m['max_time']
}
for op, m in self.metrics.items()
}
# Global performance monitor instance
performance_monitor = PerformanceMonitor()
def measure_performance(operation_name: str):
"""Decorator to measure function performance"""
def decorator(func):
def wrapper(*args, **kwargs):
start_time = time.time()
result = func(*args, **kwargs)
duration = time.time() - start_time
performance_monitor.record_metric(operation_name, duration)
# Log slow operations (> 1 second)
if duration > 1.0:
from ..utils.logger import logger
logger.warning(f"Slow operation detected: {operation_name} took {duration:.3f}s")
return result
return wrapper
return decorator
@lru_cache(maxsize=128)
def cache_user_lookup(user_id: int):
"""Cache user lookups to reduce database queries"""
# This is a placeholder - actual implementation would query the database
# The LRU cache will store the most recent 128 user lookups
pass
class QueryOptimizer:
"""Optimize database queries"""
@staticmethod
def get_optimized_task_query(db, user_id: int, filters: dict = None):
"""
Get optimized task query with eager loading
"""
from ..models.task import Task
query = db.query(Task).filter(Task.user_id == user_id)
# Apply filters if provided
if filters:
if 'status' in filters:
query = query.filter(Task.status == filters['status'])
if 'created_after' in filters:
query = query.filter(Task.created_at >= filters['created_after'])
if 'due_before' in filters:
query = query.filter(Task.due_date <= filters['due_before'])
# Order by created_at descending for better performance
query = query.order_by(Task.created_at.desc())
return query
@staticmethod
def batch_load_tasks(db, user_ids: list):
"""
Batch load tasks for multiple users to reduce queries
"""
from ..models.task import Task
tasks = db.query(Task).filter(Task.user_id.in_(user_ids)).all()
# Group tasks by user_id
tasks_by_user = {}
for task in tasks:
if task.user_id not in tasks_by_user:
tasks_by_user[task.user_id] = []
tasks_by_user[task.user_id].append(task)
return tasks_by_user
class ResponseOptimizer:
"""Optimize API responses"""
@staticmethod
def paginate_results(query, page: int = 1, page_size: int = 20):
"""
Paginate query results for better performance
"""
offset = (page - 1) * page_size
total = query.count()
items = query.offset(offset).limit(page_size).all()
return {
'items': items,
'total': total,
'page': page,
'page_size': page_size,
'total_pages': (total + page_size - 1) // page_size
}
@staticmethod
def compress_response(data: dict):
"""
Compress response data by removing null values
"""
return {k: v for k, v in data.items() if v is not None}
# Connection pooling configuration
DATABASE_POOL_CONFIG = {
'pool_size': 10, # Number of connections to maintain
'max_overflow': 20, # Maximum number of connections to create beyond pool_size
'pool_timeout': 30, # Seconds to wait before giving up on getting a connection
'pool_recycle': 3600, # Recycle connections after 1 hour
'pool_pre_ping': True # Verify connections before using them
}