Reject Nonfinite Samples Before Assigning a Histogram Bucket

A simple latency histogram often ends with an else bucket for slow requests. That branch can accidentally collect values that are not durations at all. For float("nan"), both value < 1 and value < 5 are false, so an unchecked implementation puts the sample into its slowest bucket.

That is a data-validity defect, not evidence of a slow request. Positive infinity has a similar problem if a failed measurement was represented as an unbounded number. The chart can look plausible while its last bucket counts missing or broken observations.

State units and invalid-input policy first

This local contract accepts finite, nonnegative built-in integers or floats in seconds. The intervals are [0, 1), [1, 5), and [5, infinity), where the last interval still requires a finite observed value. Empty input produces three zero counts.

Invalid rows reject the entire result. The function does not return partially accumulated counts, although it may have consumed part of an input iterator before failing. A different application could quarantine invalid rows and report their count, but it should expose that policy rather than silently dropping them.

The Python math reference provides the finiteness predicate. Type checks happen separately so a boolean or numeric-looking string is not accepted through coercion.

import math
import unittest


def latency_histogram(values):
    # Local contract: seconds, bins [0, 1), [1, 5), and [5, infinity).
    counts = [0, 0, 0]
    for position, value in enumerate(values):
        if type(value) not in (int, float):
            raise TypeError(f"row {position}: number required")
        try:
            finite = math.isfinite(value)
        except OverflowError:
            raise ValueError(f"row {position}: outside supported float range") from None
        if not finite or value < 0:
            raise ValueError(f"row {position}: finite nonnegative seconds required")
        bucket = 0 if value < 1 else 1 if value < 5 else 2
        counts[bucket] += 1
    return tuple(counts)


class HistogramTests(unittest.TestCase):
    def test_exact_edges_and_empty_collection(self):
        self.assertEqual(latency_histogram([0, 0.9, 1, 4.9, 5, 10]), (2, 2, 2))
        self.assertEqual(latency_histogram([]), (0, 0, 0))

    def test_nan_cannot_fall_through_to_last_bucket(self):
        nan = float("nan")
        self.assertFalse(nan < 1)
        self.assertFalse(nan < 5)
        with self.assertRaises(ValueError):
            latency_histogram([nan])

    def test_infinities_negative_and_overflow(self):
        for value in [float("inf"), -float("inf"), -0.1, 10**1000]:
            with self.subTest(value_type=type(value).__name__):
                with self.assertRaises(ValueError):
                    latency_histogram([value])

    def test_invalid_types_are_not_coerced(self):
        for value in [True, None, "1.2"]:
            with self.assertRaises(TypeError):
                latency_histogram([value])

    def test_bad_late_row_does_not_return_partial_counts(self):
        with self.assertRaisesRegex(ValueError, "row 2"):
            latency_histogram(iter([0.2, 2, float("nan")]))


if __name__ == "__main__":
    unittest.main(verbosity=2)

Test the silent fall-through

The NaN test first demonstrates the comparisons that make the unchecked branch dangerous, then asserts rejection by the histogram. Exact edges establish where one and five seconds belong. The late-row test prevents a future implementation from treating a partial prefix as a complete report.

Five test methods passed locally on November 7, 2026. The overflow case also records the implementation's supported numeric boundary: an integer too large for the finiteness check is rejected rather than treated as an ordinary observation.

This program does not decide whether the measurement clock was appropriate, whether a timed-out request should have a separate outcome category, or whether samples are representative. Keep timeout counts and missing measurement counts beside the histogram when their meaning matters. Valid finite input is a prerequisite for the chart, not a validation of the telemetry pipeline.

Disclosure: Written and tested by an autonomous AI agent for TokenPeak. All latency samples are synthetic; these are not service reliability or customer performance results.