Problem

You’re on-call for a fintech payments platform processing millions of API calls per minute. During an incident, you need to compute dashboard metrics from a raw log stream to quickly identify whether failures are spiking and which endpoints are slowing down.

Each log line is a space-separated record:

<timestamp_ms> <service> <endpoint> <status_code> <latency_ms>

Example: "1500 payments /refund 200 300"

Malformed lines (wrong token count or non-integer numeric fields) must be ignored.

Task

Implement extract_metrics(lines, window_start_ms, window_end_ms, k) that considers only valid lines whose timestamp_ms is within the inclusive window [window_start_ms, window_end_ms] and returns a dictionary with:

1. total_requests: number of valid requests in the window
2. error_rate: fraction of windowed requests with status_code >= 500
3. p95_latency_ms: the nearest-rank 95th percentile latency among windowed requests
   • Let m = total_requests. Sort latencies ascending.
   • rank = ceil(0.95 * m) (1-indexed), and p95 is the element at index rank - 1.
4. top_k_slowest_endpoints: list of up to k endpoints with the highest average latency (average over windowed requests for that endpoint)
   • Sort by average latency descending
   • Break ties by endpoint name ascending (lexicographic)

If total_requests == 0, return zeros and an empty list.

Examples

Example 1

• Input: lines = ["900 payments /charge 200 10", "1000 payments /charge 500 100", "1500 payments /refund 200 300", "1800 payments /charge 200 50", "2100 payments /charge 200 999"], window_start_ms = 1000, window_end_ms = 2000, k = 2
• Output: {'total_requests': 3, 'error_rate': 0.3333333333333333, 'p95_latency_ms': 300, 'top_k_slowest_endpoints': ['/refund', '/charge']}
• Explanation: Only timestamps 1000, 1500, 1800 count. Latencies [100, 300, 50] → sorted [50, 100, 300] → nearest-rank p95 is 300. Endpoint averages: /refund=300, /charge=(100+50)/2=75.

Example 2

• Input: lines = ["1000 payments /charge 200 10", "oops", "1200 payments /charge two 10"], window_start_ms = 1000, window_end_ms = 1300, k = 5
• Output: {'total_requests': 1, 'error_rate': 0.0, 'p95_latency_ms': 10, 'top_k_slowest_endpoints': ['/charge']}
• Explanation: Malformed lines are ignored; only one valid request remains.

Constraints

• 1 <= len(lines) <= 2 * 10^5
• 0 <= window_start_ms <= window_end_ms <= 10^13
• 0 <= status_code <= 999
• 0 <= latency_ms <= 10^7
• 1 <= k <= 100
• Ignore malformed lines and lines outside the inclusive window

Notes

• Tie-breaking for top_k_slowest_endpoints is part of the contract: if two endpoints have the same average latency, return the lexicographically smaller endpoint first.