p50/p95 latency per endpoint

FxDart wins

Requirement

From raw request logs (data in the code), drop failed requests and compute p50 and p95 latency per endpoint: sort each endpoint's latencies and take the value at index round((n-1) * q / 100). Print a table sorted by worst p95 first, then call out the worst endpoint. Both versions must print the table under Expected output.

Expected output

Latency percentiles (successful requests only)
  /orders  p50 133 ms  p95 620 ms  (5 reqs)
  /search  p50 210 ms  p95 480 ms  (4 reqs)
  /users   p50  88 ms  p95 340 ms  (5 reqs)
Worst p95: /orders at 620 ms

Side by side

Native Dart

import 'package:collection/collection.dart';

class Req {
  final String endpoint;
  final int ms;
  final int status;
  const Req(this.endpoint, this.ms, this.status);
}

const reqs = [
  Req('/users', 82, 200),
  Req('/users', 74, 200),
  Req('/users', 96, 200),
  Req('/users', 340, 200),
  Req('/users', 88, 200),
  Req('/orders', 120, 200),
  Req('/orders', 145, 200),
  Req('/orders', 110, 200),
  Req('/orders', 620, 200),
  Req('/orders', 133, 200),
  Req('/search', 210, 200),
  Req('/search', 480, 200),
  Req('/search', 190, 200),
  Req('/search', 205, 200),
  Req('/orders', 30, 500),
  Req('/users', 12, 503),
];

void main() {
  final ok = reqs.where((r) => r.status == 200).toList();

final rows = <(String, int, int, int)>[];
  for (final e in ok.groupListsBy((r) => r.endpoint).entries) {
    final sorted = e.value.map((r) => r.ms).toList()..sort();
    int pct(int q) => sorted[((sorted.length - 1) * q / 100).round()];
    rows.add((e.key, pct(50), pct(95), sorted.length));
  }

final lines = rows.sortedBy<num>((r) => -r.$3).map((r) =>
      '  ${r.$1.padRight(8)} p50 ${'${r.$2}'.padLeft(3)} ms  '
      'p95 ${'${r.$3}'.padLeft(3)} ms  (${r.$4} reqs)');
  final worst = rows.reduce((a, b) => a.$3 >= b.$3 ? a : b);

print([
    'Latency percentiles (successful requests only)',
    ...lines,
    'Worst p95: ${worst.$1} at ${worst.$3} ms',
  ].join('\n'));
}

FxDart

import 'package:fxdart/fxdart.dart';

class Req {
  final String endpoint;
  final int ms;
  final int status;
  const Req(this.endpoint, this.ms, this.status);
}

void main() {
  final ok = fx(reqs).filter((r) => r.status == 200).toList();

final rows = fx(fx(ok).groupBy((r) => r.endpoint).entries).map((e) {
    final sorted = fx(e.value).map((r) => r.ms).sort((a, b) => a.compareTo(b)).toList();
    int pct(int q) => nth(((sorted.length - 1) * q / 100).round(), sorted)!;
    return (e.key, pct(50), pct(95), sorted.length);
  }).toList();

final lines = fx(rows).sortBy((r) => -r.$3).map((r) =>
      '  ${r.$1.padRight(8)} p50 ${'${r.$2}'.padLeft(3)} ms  '
      'p95 ${'${r.$3}'.padLeft(3)} ms  (${r.$4} reqs)');
  final worst = fx(rows).maxBy((r) => r.$3)!;

print(join('\n', [
    'Latency percentiles (successful requests only)',
    ...lines,
    'Worst p95: ${worst.$1} at ${worst.$3} ms',
  ]));
}

Why they differ

A percentile is "sort, then index" — in FxDart that is literally sortBy + nth, applied inside a groupBy → map pipeline that turns each endpoint group into a stats row; ranking the table and finding the worst endpoint reuse the same rows with sortBy and maxBy. The native version does the same math but through a mutable row list filled in a for loop, an in-place ..sort(), raw index access, and a reduce comparator for the maximum. Both are correct; the fxdart side keeps "group → summarize → rank" as three visible strokes instead of one loop doing all three at once.

Benchmark

Apple M1 Max, 32 GB RAM · Dart 3.12.2 (AOT-compiled) · 2026-08-24

N = 100

Time Tie

Native Dart 22 µs

FxDart 20 µs

Peak memory Tie

Native Dart 16.6 MB

FxDart 16.5 MB

N = 10,000

Time Tie

Native Dart 1.93 ms

FxDart 1.80 ms

Peak memory FxDart wins

Native Dart 18.1 MB

FxDart 17.3 MB

N = 1,000,000

Time Tie

Native Dart 204.7 ms

FxDart 209.7 ms

Peak memory Native wins

Native Dart 139.4 MB

FxDart 192.2 MB

Bars are medians of repeated timed iterations in fresh processes per side (small N is batched for timer resolution). Sides within 5% of each other — or within 0.6 ms, a difference no person can perceive — count as a tie; close relative races are re-measured up to 5 runs. In an app, anything under a few milliseconds is invisible to the user regardless of which bar is shorter. Memory is peak process RSS. The Dart VM and the dataset are identical on both sides, so the difference between the two bars is what the pipeline itself holds onto.