Service Latency Percentile Metrics (Easy) — Practice with Code Visualizer

In production systems, understanding response time distributions is crucial for maintaining service quality and meeting Service Level Objectives (SLOs). Unlike average latency, which can be skewed by outliers, percentile metrics provide a more accurate picture of user experience and system health.

Percentiles divide a sorted dataset into 100 equal parts. The P-th percentile indicates the value below which P% of the observations fall. In the context of system monitoring:

P50 (Median Latency): The response time at the 50th percentile—half of all requests complete faster than this value
P95 (95th Percentile): The latency threshold below which 95% of requests are served—critical for SLO definitions
P99 (99th Percentile): The "long tail" latency that only 1% of requests exceed—essential for understanding worst-case user experience

Percentile Calculation with Linear Interpolation:

For a sorted dataset of n values and a target percentile p (expressed as a fraction between 0 and 1):

Calculate the rank position: $rank = p \times (n - 1)$
Identify the lower and upper indices: $lower = \lfloor rank \rfloor$ and $upper = \lceil rank \rceil$
Interpolate between adjacent values:

$$percentile = data[lower] + (rank - lower) \times (data[upper] - data[lower])$$

Your Task: Write a Python function that computes the P50, P95, and P99 latency percentiles from a collection of observed response times. The function should:

Return a dictionary with keys 'P50', 'P95', and 'P99', each containing the corresponding percentile value
Use linear interpolation when the percentile position falls between two data points
Round all output values to 4 decimal places
Return {'P50': 0.0, 'P95': 0.0, 'P99': 0.0} if the input list is empty

With 10 uniformly distributed latency measurements (10ms to 100ms in 10ms intervals):

• P50 Calculation: Position = 0.50 × 9 = 4.5. This falls between indices 4 (value 50) and 5 (value 60). Interpolating: 50 + 0.5 × (60 - 50) = 55.0ms

• P95 Calculation: Position = 0.95 × 9 = 8.55. This falls between indices 8 (value 90) and 9 (value 100). Interpolating: 90 + 0.55 × (100 - 90) = 95.5ms

• P99 Calculation: Position = 0.99 × 9 = 8.91. This falls between indices 8 (value 90) and 9 (value 100). Interpolating: 90 + 0.91 × (100 - 90) = 99.1ms

This indicates that 50% of requests complete within 55ms, 95% within 95.5ms, and 99% within 99.1ms.

A 20-sample dataset spanning 1ms to 20ms:

• P50: Position = 0.50 × 19 = 9.5 → Interpolate between indices 9 and 10 (values 10 and 11): 10 + 0.5 × 1 = 10.5ms

• P95: Position = 0.95 × 19 = 18.05 → Interpolate between indices 18 and 19 (values 19 and 20): 19 + 0.05 × 1 = 19.05ms

• P99: Position = 0.99 × 19 = 18.81 → Interpolate between indices 18 and 19: 19 + 0.81 × 1 = 19.81ms

The input latencies are unsorted, simulating real-world data collection. The function must first sort the values: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]. After sorting, the calculations proceed identically to Example 1, demonstrating that percentiles are order-invariant—they depend only on the distribution of values, not their arrival sequence.