Scalability & Performance

import time
import numpy as np
import requests

def benchmark_endpoint(url, num_requests=1000):
    """Measure latency percentiles for an endpoint."""
    latencies = []

    for _ in range(num_requests):
        start = time.perf_counter()
        response = requests.get(url)
        end = time.perf_counter()
        latency_ms = (end - start) * 1000
        latencies.append(latency_ms)

    latencies = np.array(latencies)

    print(f"--- Latency Report ({num_requests} requests) ---")
    print(f"P50  (median): {np.percentile(latencies, 50):.1f} ms")
    print(f"P95:           {np.percentile(latencies, 95):.1f} ms")
    print(f"P99:           {np.percentile(latencies, 99):.1f} ms")
    print(f"P99.9:         {np.percentile(latencies, 99.9):.1f} ms")
    print(f"Max:           {np.max(latencies):.1f} ms")
    print(f"Throughput:     {num_requests / (np.sum(latencies) / 1000):.0f} req/s")

# Example usage
benchmark_endpoint("http://localhost:8080/api/health")

# Sample output:
# --- Latency Report (1000 requests) ---
# P50  (median): 12.3 ms
# P95:           45.7 ms
# P99:           123.4 ms
# P99.9:         456.2 ms
# Max:           892.1 ms
# Throughput:     847 req/s

import psycopg2
from psycopg2 import pool
import time

# WITHOUT connection pooling (slow)
def query_without_pool(query, n_queries=100):
    start = time.time()
    for _ in range(n_queries):
        # New connection for EVERY query (expensive!)
        conn = psycopg2.connect(
            host="localhost",
            database="mydb",
            user="user",
            password="pass"
        )
        cursor = conn.cursor()
        cursor.execute(query)
        cursor.fetchall()
        conn.close()  # Connection destroyed
    elapsed = time.time() - start
    print(f"Without pool: {elapsed:.2f}s for {n_queries} queries")

# WITH connection pooling (fast)
def query_with_pool(query, n_queries=100):
    # Create pool once (reuse connections)
    connection_pool = pool.SimpleConnectionPool(
        minconn=5,   # Minimum connections to keep open
        maxconn=20,  # Maximum connections allowed
        host="localhost",
        database="mydb",
        user="user",
        password="pass"
    )

    start = time.time()
    for _ in range(n_queries):
        conn = connection_pool.getconn()  # Borrow from pool
        cursor = conn.cursor()
        cursor.execute(query)
        cursor.fetchall()
        connection_pool.putconn(conn)     # Return to pool
    elapsed = time.time() - start
    print(f"With pool:    {elapsed:.2f}s for {n_queries} queries")
    connection_pool.closeall()

# Typical results:
# Without pool: 4.52s for 100 queries
# With pool:    0.31s for 100 queries  (~15x faster!)

from celery import Celery
import time

# Create a Celery app connected to Redis as broker
app = Celery("tasks", broker="redis://localhost:6379/0")

# Define a slow task that runs in the background
@app.task
def send_welcome_email(user_email):
    """Simulate sending an email (takes 3 seconds)."""
    time.sleep(3)  # Simulate SMTP delay
    print(f"Email sent to {user_email}")
    return True

@app.task
def process_uploaded_image(image_path):
    """Resize and optimize an uploaded image."""
    time.sleep(5)  # Simulate image processing
    print(f"Image processed: {image_path}")
    return True

# In your API handler (responds instantly!):
def register_user(user_data):
    # Save user to database (fast)
    user = save_to_db(user_data)

    # Queue email for background processing (instant)
    send_welcome_email.delay(user.email)

    # Return response immediately -- don't wait for email
    return {"status": "registered", "user_id": user.id}