Scaling Up without Breaking the Bank › Monitoring Usage and Catching Bottlenecks

## Using Claude Sonnet 4.5 for agent operations
import time
from collections import deque
from datetime import datetime, timedelta


class AgentMonitor:
    def __init__(self, window_minutes=5):
        self.window = timedelta(minutes=window_minutes)
        self.requests = deque()
        self.errors = deque()
        self.response_times = deque()

    def record_request(self, success=True, response_time=None):
        """Record a request and its outcome"""
        now = datetime.now()

        self.requests.append(now)
        if not success:
            self.errors.append(now)
        if response_time:
            self.response_times.append((now, response_time))

        # Clean old data outside the window
        self._clean_old_data(now)

    def _clean_old_data(self, now):
        """Remove data older than the monitoring window"""
        cutoff = now - self.window

        while self.requests and self.requests[0] < cutoff:
            self.requests.popleft()
        while self.errors and self.errors[0] < cutoff:
            self.errors.popleft()
        while self.response_times and self.response_times[0][0] < cutoff:
            self.response_times.popleft()

    def get_stats(self):
        """Get current statistics"""
        if not self.requests:
            return {
                "requests_per_minute": 0,
                "error_rate": 0,
                "avg_response_time": 0,
            }

        window_minutes = self.window.total_seconds() / 60
        requests_per_minute = len(self.requests) / window_minutes
        error_rate = (
            len(self.errors) / len(self.requests) if self.requests else 0
        )

        if self.response_times:
            avg_time = sum(t for _, t in self.response_times) / len(
                self.response_times
            )
        else:
            avg_time = 0

        return {
            "requests_per_minute": requests_per_minute,
            "error_rate": error_rate,
            "avg_response_time": avg_time,
        }


## Use the monitor
monitor = AgentMonitor(window_minutes=5)

## Process requests and record metrics
for query in queries:
    start = time.time()
    try:
        result = process_request(query)
        elapsed = time.time() - start
        monitor.record_request(success=True, response_time=elapsed)
    except Exception as e:
        elapsed = time.time() - start
        monitor.record_request(success=False, response_time=elapsed)
        print(f"Error: {e}")

## Check stats
stats = monitor.get_stats()
print(f"Requests/min: {stats['requests_per_minute']:.1f}")
print(f"Error rate: {stats['error_rate']:.1%}")
print(f"Avg response time: {stats['avg_response_time']:.2f}s")