oai-statsig-python-core 0.25.0rc9__tar.gz → 0.26.0__tar.gz

{oai_statsig_python_core-0.25.0rc9 → oai_statsig_python_core-0.26.0}/Cargo.lock

@@ -1722,7 +1722,7 @@ dependencies = [
 
 [[package]]
 name = "oai-statsig-grpc"
-version = "0.25.0-rc.9"
+version = "0.26.0"
 dependencies = [
  "async-trait",
  "chrono",
@@ -1737,7 +1737,7 @@ dependencies = [
 
 [[package]]
 name = "oai-statsig-rust"
-version = "0.25.0-rc.9"
+version = "0.26.0"
 dependencies = [
  "ahash",
  "arc-swap",
@@ -3012,7 +3012,7 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "statsig-node"
-version = "0.25.0-rc.9"
+version = "0.26.0"
 dependencies = [
  "async-trait",
  "napi",
@@ -3027,7 +3027,7 @@ dependencies = [
 
 [[package]]
 name = "statsig-pyo3"
-version = "0.25.0-rc.9"
+version = "0.26.0"
 dependencies = [
  "async-trait",
  "lazy_static",
@@ -3042,7 +3042,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_elixir"
-version = "0.25.0-rc.9"
+version = "0.26.0"
 dependencies = [
  "async-trait",
  "oai-statsig-rust",
@@ -3055,7 +3055,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_ffi"
-version = "0.25.0-rc.9"
+version = "0.26.0"
 dependencies = [
  "async-trait",
  "cbindgen",

{oai_statsig_python_core-0.25.0rc9 → oai_statsig_python_core-0.26.0}/Cargo.toml

@@ -26,7 +26,7 @@ exclude = [
 [workspace.package]
 edition = "2021"
 license = "ISC"
-version = "0.25.0-rc.9"
+version = "0.26.0"
 homepage = "https://statsig.com/"
 authors = ["Statsig", "Daniel Loomb <daniel@statsig.com>"]
 readme = "README.md"

{oai_statsig_python_core-0.25.0rc9 → oai_statsig_python_core-0.26.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oai_statsig_python_core
-Version: 0.25.0rc9
+Version: 0.26.0
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{oai_statsig_python_core-0.25.0rc9 → oai_statsig_python_core-0.26.0}/statsig-pyo3/tests/test_data_store.py

@@ -222,6 +222,12 @@ def test_data_store_usage_get(statsig_setup):
     assert gate.details.reason == "Adapter(DataStore):Recognized"
     assert gate.value == True
     assert gate.details.lcut == known_lcut
+
+    for _ in range(100):
+        if data_store.get_called_count >= 2:
+            break
+        sleep(0.05)
+
     assert data_store.get_called_count > 1
 
 

{oai_statsig_python_core-0.25.0rc9 → oai_statsig_python_core-0.26.0}/statsig-rust/Cargo.toml

@@ -44,7 +44,7 @@ serde_json = { version = "1.0.143", features = [
 ] }
 serde_with = "3.4.0"
 sha2 = "0.10.8"
-oai-statsig-grpc = { path = "../statsig-grpc", version = "0.25.0-rc.9", optional = true }
+oai-statsig-grpc = { path = "../statsig-grpc", version = "0.26.0", optional = true }
 simple_logger = { version = "5.0.0" }
 tempfile = "3.8.1"
 tokio = { version = "1.39.1", features = ["full"] }

{oai_statsig_python_core-0.25.0rc9 → oai_statsig_python_core-0.26.0}/statsig-rust/src/evaluation/evaluator.rs

@@ -166,21 +166,22 @@ fn new_layer_eval<'a>(
 ) -> Result<Recognition, StatsigErr> {
     let mut has_passed_rule = false;
     let mut passed = false;
-    let mut rule_id: Option<&'a InternedString> = Some(InternedString::default_rule_id_ref());
+    let mut rule_id = Some(InternedString::default_rule_id());
     let mut delegate_name: Option<InternedString> = None;
     let mut rule_ids: HashMap<InternedString, InternedString> = HashMap::new();
     let mut value: HashMap<String, Value> = HashMap::new();
     let mut group_name: Option<InternedString> = None;
     let mut is_experiment_group = false;
+    let mut is_experiment_active = false;
     let mut explicit_parameters: Option<ExplicitParameters> = None;
     let mut secondary_exposures: Vec<SecondaryExposure> = Vec::new();
     let mut undelegated_secondary_exposures: Vec<SecondaryExposure> = Vec::new();
 
     for rule in &spec.rules {
         evaluate_rule(ctx, rule)?;
-        secondary_exposures.append(&mut ctx.result.secondary_exposures);
-        undelegated_secondary_exposures.append(&mut ctx.result.secondary_exposures);
-        ctx.result.secondary_exposures.clear();
+        let rule_secondary_exposures = std::mem::take(&mut ctx.result.secondary_exposures);
+        secondary_exposures.extend(rule_secondary_exposures.iter().cloned());
+        undelegated_secondary_exposures.extend(rule_secondary_exposures);
 
         if ctx.result.unsupported {
             return Ok(Recognition::Recognized);
@@ -217,15 +218,21 @@ fn new_layer_eval<'a>(
                 continue;
             }
 
-            update_parameter_values(&mut value, &mut rule_ids, delegate_value, &rule.id);
+            let delegate_rule_id = ctx
+                .result
+                .rule_id
+                .clone()
+                .unwrap_or_else(InternedString::default_rule_id);
+            update_parameter_values(&mut value, &mut rule_ids, delegate_value, &delegate_rule_id);
 
             secondary_exposures.append(&mut ctx.result.secondary_exposures);
             ctx.result.secondary_exposures.clear();
             passed = ctx.result.bool_value;
             delegate_name = ctx.result.config_delegate.clone();
             group_name = ctx.result.group_name.clone();
-            rule_id = Some(&rule.id);
-            is_experiment_group = rule.is_experiment_group.unwrap_or(false);
+            rule_id = Some(delegate_rule_id);
+            is_experiment_group = ctx.result.is_experiment_group;
+            is_experiment_active = ctx.result.is_experiment_active;
             explicit_parameters = ctx.result.explicit_parameters.clone();
         } else {
             passed = ctx.result.bool_value;
@@ -247,10 +254,10 @@ fn new_layer_eval<'a>(
     ctx.result.bool_value = passed;
     ctx.result.config_delegate = delegate_name;
     ctx.result.group_name = group_name;
-    ctx.result.rule_id = rule_id.cloned();
+    ctx.result.rule_id = rule_id;
     ctx.result.json_value = Some(DynamicReturnable::from_map(value));
     ctx.result.is_experiment_group = is_experiment_group;
-    ctx.result.is_experiment_active = spec.is_active.unwrap_or(false);
+    ctx.result.is_experiment_active = is_experiment_active;
     ctx.result.explicit_parameters = explicit_parameters;
     ctx.result.secondary_exposures = secondary_exposures;
     ctx.result.undelegated_secondary_exposures = Some(undelegated_secondary_exposures);

{oai_statsig_python_core-0.25.0rc9 → oai_statsig_python_core-0.26.0}/statsig-rust/src/evaluation/evaluator_context.rs

@@ -72,7 +72,7 @@ impl<'a> EvaluatorContext<'a> {
 
     pub fn reset_result(&mut self) {
         self.nested_count = 0;
-        self.result = EvaluatorResult::default();
+        self.result.clear_for_reuse();
     }
 
     pub fn finalize_evaluation(&mut self, spec: &Spec, rule: Option<&Rule>) {

{oai_statsig_python_core-0.25.0rc9 → oai_statsig_python_core-0.26.0}/statsig-rust/src/evaluation/evaluator_result.rs

@@ -56,6 +56,33 @@ pub struct EvaluatorResult {
     pub parameter_rule_ids: Option<HashMap<InternedString, InternedString>>,
 }
 
+impl EvaluatorResult {
+    pub fn clear_for_reuse(&mut self) {
+        self.name = None;
+        self.bool_value = false;
+        self.unsupported = false;
+        self.is_experiment_group = false;
+        self.is_experiment_active = false;
+        self.is_in_layer = false;
+        self.id_type = None;
+        self.json_value = None;
+        self.rule_id = None;
+        self.rule_id_suffix = None;
+        self.group_name = None;
+        self.explicit_parameters = None;
+        self.config_delegate = None;
+        self.secondary_exposures.clear();
+        self.undelegated_secondary_exposures = None;
+        self.override_reason = None;
+        self.version = None;
+        self.sampling_rate = None;
+        self.forward_all_exposures = None;
+        self.override_config_name = None;
+        self.has_seen_analytical_gates = None;
+        self.parameter_rule_ids = None;
+    }
+}
+
 fn get_is_user_in_experiment(result: &EvaluatorResult) -> bool {
     result.is_experiment_group
         && result
@@ -731,3 +758,79 @@ fn create_suffixed_rule_id(
         None => rule_id.cloned().unwrap_or_default(),
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn clear_for_reuse_resets_fields_and_keeps_secondary_exposure_capacity() {
+        let mut result = EvaluatorResult {
+            name: Some(InternedString::from_str_ref("a_gate")),
+            bool_value: true,
+            unsupported: true,
+            is_experiment_group: true,
+            is_experiment_active: true,
+            is_in_layer: true,
+            id_type: Some(InternedString::from_str_ref("stableID")),
+            json_value: Some(DynamicReturnable::from_bool(true)),
+            rule_id: Some(InternedString::from_str_ref("rule")),
+            rule_id_suffix: Some("suffix"),
+            group_name: Some(InternedString::from_str_ref("group")),
+            explicit_parameters: Some(ExplicitParameters::from_vec(vec!["param".to_string()])),
+            config_delegate: Some(InternedString::from_str_ref("delegate")),
+            secondary_exposures: Vec::with_capacity(8),
+            undelegated_secondary_exposures: Some(vec![SecondaryExposure {
+                gate: InternedString::from_str_ref("undelegated_gate"),
+                gate_value: InternedString::from_bool(true),
+                rule_id: InternedString::from_str_ref("undelegated_rule"),
+            }]),
+            override_reason: Some("override"),
+            version: Some(1),
+            sampling_rate: Some(10),
+            forward_all_exposures: Some(true),
+            override_config_name: Some(InternedString::from_str_ref("override_config")),
+            has_seen_analytical_gates: Some(true),
+            parameter_rule_ids: Some(HashMap::from([(
+                InternedString::from_str_ref("param"),
+                InternedString::from_str_ref("rule"),
+            )])),
+        };
+
+        result.secondary_exposures.push(SecondaryExposure {
+            gate: InternedString::from_str_ref("gate"),
+            gate_value: InternedString::from_bool(false),
+            rule_id: InternedString::from_str_ref("rule"),
+        });
+        let secondary_exposure_capacity = result.secondary_exposures.capacity();
+
+        result.clear_for_reuse();
+
+        assert!(result.name.is_none());
+        assert!(!result.bool_value);
+        assert!(!result.unsupported);
+        assert!(!result.is_experiment_group);
+        assert!(!result.is_experiment_active);
+        assert!(!result.is_in_layer);
+        assert!(result.id_type.is_none());
+        assert!(result.json_value.is_none());
+        assert!(result.rule_id.is_none());
+        assert!(result.rule_id_suffix.is_none());
+        assert!(result.group_name.is_none());
+        assert!(result.explicit_parameters.is_none());
+        assert!(result.config_delegate.is_none());
+        assert!(result.secondary_exposures.is_empty());
+        assert_eq!(
+            result.secondary_exposures.capacity(),
+            secondary_exposure_capacity
+        );
+        assert!(result.undelegated_secondary_exposures.is_none());
+        assert!(result.override_reason.is_none());
+        assert!(result.version.is_none());
+        assert!(result.sampling_rate.is_none());
+        assert!(result.forward_all_exposures.is_none());
+        assert!(result.override_config_name.is_none());
+        assert!(result.has_seen_analytical_gates.is_none());
+        assert!(result.parameter_rule_ids.is_none());
+    }
+}

oai_statsig_python_core-0.26.0/statsig-rust/src/evaluation/user_agent_parsing/statsig_uaparser/__tests__/test_tokenizer_performance.rs

@@ -0,0 +1,399 @@
+use std::{
+    collections::VecDeque,
+    hint::black_box,
+    time::{Duration, Instant},
+};
+
+use memchr::memchr2;
+
+use super::{Token, TokenWindow, Tokenizer, TokenizerResult};
+
+const CORPUS: &str = include_str!("../../../../../tests/data/test_user_agents.txt");
+const EDGE_CASES: &[&str] = &[
+    "",
+    " ",
+    ";",
+    "  leading;;and  repeated;delimiters  ",
+    "Mozilla/5.0\t(Windows NT 10.0)\nChrome/134.0",
+    "机器人/1.0 (兼容; Android 14; 设备 🚀) crawler/2.0",
+    "Mözilla/5.0 (X11; Línux x86_64) Brøwser/1.2.3",
+    "e\u{301}/1.0; café/2.0; 東京/3.0",
+    "non\u{a0}breaking\u{a0}spaces/1.0; regular delimiter",
+    "quoted/1.0 (\"odd; value\") +bot/3.0",
+    ";;;;    ; ; trailing;",
+];
+
+#[test]
+fn memchr_window_preserves_legacy_tokenizer_results() {
+    for user_agent in corpus().into_iter().chain(EDGE_CASES.iter().copied()) {
+        assert_equivalent(user_agent);
+    }
+
+    let long_odd_input = format!(
+        "{}; {};{}  {}",
+        "é".repeat(400),
+        "token".repeat(100),
+        "🚀".repeat(200),
+        "tail".repeat(100)
+    );
+    assert_equivalent(&long_odd_input);
+}
+
+#[test]
+#[ignore = "manual benchmark; run with --release --ignored --nocapture"]
+fn benchmark_memchr_window_against_legacy_tokenizer() {
+    let corpus = corpus();
+    let samples = std::env::var("UA_BENCH_SAMPLES")
+        .ok()
+        .and_then(|value| value.parse().ok())
+        .unwrap_or(31);
+    let warmup = std::env::var("UA_BENCH_WARMUP")
+        .ok()
+        .and_then(|value| value.parse().ok())
+        .unwrap_or(5);
+
+    for _ in 0..warmup {
+        black_box(run_candidate(&corpus));
+        black_box(run_memchr_deque(&corpus));
+        black_box(run_std_array(&corpus));
+        black_box(run_legacy(&corpus));
+    }
+
+    let mut candidate = Vec::with_capacity(samples);
+    let mut memchr_deque = Vec::with_capacity(samples);
+    let mut std_array = Vec::with_capacity(samples);
+    let mut legacy = Vec::with_capacity(samples);
+    for sample in 0..samples {
+        match sample % 4 {
+            0 => {
+                candidate.push(measure(|| run_candidate(&corpus)));
+                memchr_deque.push(measure(|| run_memchr_deque(&corpus)));
+                std_array.push(measure(|| run_std_array(&corpus)));
+                legacy.push(measure(|| run_legacy(&corpus)));
+            }
+            1 => {
+                memchr_deque.push(measure(|| run_memchr_deque(&corpus)));
+                std_array.push(measure(|| run_std_array(&corpus)));
+                legacy.push(measure(|| run_legacy(&corpus)));
+                candidate.push(measure(|| run_candidate(&corpus)));
+            }
+            2 => {
+                std_array.push(measure(|| run_std_array(&corpus)));
+                legacy.push(measure(|| run_legacy(&corpus)));
+                candidate.push(measure(|| run_candidate(&corpus)));
+                memchr_deque.push(measure(|| run_memchr_deque(&corpus)));
+            }
+            _ => {
+                legacy.push(measure(|| run_legacy(&corpus)));
+                candidate.push(measure(|| run_candidate(&corpus)));
+                memchr_deque.push(measure(|| run_memchr_deque(&corpus)));
+                std_array.push(measure(|| run_std_array(&corpus)));
+            }
+        }
+    }
+
+    let candidate_stats = BenchStats::new(candidate, corpus.len());
+    let memchr_deque_stats = BenchStats::new(memchr_deque, corpus.len());
+    let std_array_stats = BenchStats::new(std_array, corpus.len());
+    let legacy_stats = BenchStats::new(legacy, corpus.len());
+
+    println!(
+        "user_agent_tokenizer_bench corpus={} samples={} warmup={}",
+        corpus.len(),
+        samples,
+        warmup
+    );
+    legacy_stats.print("legacy std::str::split");
+    memchr_deque_stats.print("memchr2 + VecDeque");
+    std_array_stats.print("std::split + array");
+    candidate_stats.print("memchr2 + array");
+    println!(
+        "median_saved_pct memchr_only={:.2}% array_only={:.2}% combined={:.2}%",
+        legacy_stats.saved_pct(&memchr_deque_stats),
+        legacy_stats.saved_pct(&std_array_stats),
+        legacy_stats.saved_pct(&candidate_stats),
+    );
+}
+
+fn corpus() -> Vec<&'static str> {
+    CORPUS
+        .lines()
+        .skip(1)
+        .filter_map(|line| line.split_once('|').map(|(user_agent, _)| user_agent))
+        .chain(EDGE_CASES.iter().copied())
+        .collect()
+}
+
+fn assert_equivalent(input: &str) {
+    let candidate = Tokenizer::run(input);
+    let memchr_deque =
+        Tokenizer::run_with_window(DequeWindow::new(TestAsciiDelimiterSplit::new(input)));
+    let std_array = Tokenizer::run_with_window(ArrayWindow::new(input.split([';', ' '])));
+    let legacy = Tokenizer::run_with_window(DequeWindow::new(input.split([';', ' '])));
+
+    assert_result_eq(&candidate, &legacy, input);
+    assert_result_eq(&memchr_deque, &legacy, input);
+    assert_result_eq(&std_array, &legacy, input);
+}
+
+fn assert_result_eq(candidate: &TokenizerResult<'_>, legacy: &TokenizerResult<'_>, input: &str) {
+    assert_eq!(candidate.position, legacy.position, "input: {input:?}");
+    assert_eq!(
+        candidate.tokens.len(),
+        legacy.tokens.len(),
+        "input: {input:?}"
+    );
+    for (candidate, legacy) in candidate.tokens.iter().zip(&legacy.tokens) {
+        assert_eq!(candidate.position, legacy.position, "input: {input:?}");
+        assert_eq!(candidate.tag, legacy.tag, "input: {input:?}");
+        assert_eq!(candidate.version, legacy.version, "input: {input:?}");
+    }
+    assert_token_eq(
+        candidate.possible_os_token.as_ref(),
+        legacy.possible_os_token.as_ref(),
+        input,
+    );
+    assert_token_eq(
+        candidate.possible_browser_token.as_ref(),
+        legacy.possible_browser_token.as_ref(),
+        input,
+    );
+    assert_eq!(candidate.linux_hint, legacy.linux_hint, "input: {input:?}");
+    assert_eq!(candidate.ios_hint, legacy.ios_hint, "input: {input:?}");
+    assert_eq!(candidate.macos_hint, legacy.macos_hint, "input: {input:?}");
+    assert_eq!(
+        candidate.windows_hint, legacy.windows_hint,
+        "input: {input:?}"
+    );
+    assert_eq!(
+        candidate.mobile_hint, legacy.mobile_hint,
+        "input: {input:?}"
+    );
+    assert_eq!(
+        candidate.safari_hint, legacy.safari_hint,
+        "input: {input:?}"
+    );
+    assert_eq!(
+        candidate.playstation_hint, legacy.playstation_hint,
+        "input: {input:?}"
+    );
+    assert_eq!(
+        candidate.huawei_hint, legacy.huawei_hint,
+        "input: {input:?}"
+    );
+    assert_eq!(
+        candidate.cfnetwork_hint, legacy.cfnetwork_hint,
+        "input: {input:?}"
+    );
+    assert_eq!(
+        candidate.crawler_hint, legacy.crawler_hint,
+        "input: {input:?}"
+    );
+    assert_eq!(
+        candidate.bot_detected, legacy.bot_detected,
+        "input: {input:?}"
+    );
+}
+
+fn assert_token_eq(candidate: Option<&Token<'_>>, legacy: Option<&Token<'_>>, input: &str) {
+    assert_eq!(
+        candidate.map(|token| (token.position, token.tag, token.version)),
+        legacy.map(|token| (token.position, token.tag, token.version)),
+        "input: {input:?}"
+    );
+}
+
+fn run_candidate(corpus: &[&str]) -> usize {
+    run(corpus, Tokenizer::run)
+}
+
+fn run_legacy(corpus: &[&str]) -> usize {
+    run(corpus, |user_agent| {
+        Tokenizer::run_with_window(DequeWindow::new(user_agent.split([';', ' '])))
+    })
+}
+
+fn run_memchr_deque(corpus: &[&str]) -> usize {
+    run(corpus, |user_agent| {
+        Tokenizer::run_with_window(DequeWindow::new(TestAsciiDelimiterSplit::new(user_agent)))
+    })
+}
+
+fn run_std_array(corpus: &[&str]) -> usize {
+    run(corpus, |user_agent| {
+        Tokenizer::run_with_window(ArrayWindow::new(user_agent.split([';', ' '])))
+    })
+}
+
+struct DequeWindow<'a, I> {
+    iter: I,
+    window: VecDeque<&'a str>,
+}
+
+impl<'a, I: Iterator<Item = &'a str>> DequeWindow<'a, I> {
+    fn new(mut iter: I) -> Self {
+        let mut window = VecDeque::new();
+        for _ in 0..4 {
+            if let Some(word) = iter.next() {
+                window.push_back(word);
+            }
+        }
+
+        Self { iter, window }
+    }
+}
+
+impl<'a, I: Iterator<Item = &'a str>> TokenWindow<'a> for DequeWindow<'a, I> {
+    #[allow(clippy::get_first)]
+    fn get_window(
+        &self,
+    ) -> (
+        Option<&'a str>,
+        Option<&'a str>,
+        Option<&'a str>,
+        Option<&'a str>,
+    ) {
+        (
+            self.window.get(0).copied(),
+            self.window.get(1).copied(),
+            self.window.get(2).copied(),
+            self.window.get(3).copied(),
+        )
+    }
+
+    fn slide_window_by(&mut self, n: usize) {
+        for _ in 0..n {
+            self.window.pop_front();
+            if let Some(word) = self.iter.next() {
+                self.window.push_back(word);
+            }
+        }
+    }
+
+    fn is_empty(&self) -> bool {
+        self.window.is_empty()
+    }
+}
+
+struct ArrayWindow<'a, I> {
+    iter: I,
+    window: [Option<&'a str>; 4],
+}
+
+impl<'a, I: Iterator<Item = &'a str>> ArrayWindow<'a, I> {
+    fn new(mut iter: I) -> Self {
+        let window = std::array::from_fn(|_| iter.next());
+        Self { iter, window }
+    }
+}
+
+impl<'a, I: Iterator<Item = &'a str>> TokenWindow<'a> for ArrayWindow<'a, I> {
+    fn get_window(
+        &self,
+    ) -> (
+        Option<&'a str>,
+        Option<&'a str>,
+        Option<&'a str>,
+        Option<&'a str>,
+    ) {
+        let [curr, next1, next2, next3] = self.window;
+        (curr, next1, next2, next3)
+    }
+
+    fn slide_window_by(&mut self, n: usize) {
+        for _ in 0..n {
+            self.window.rotate_left(1);
+            self.window[3] = self.iter.next();
+        }
+    }
+
+    fn is_empty(&self) -> bool {
+        self.window[0].is_none()
+    }
+}
+
+struct TestAsciiDelimiterSplit<'a> {
+    remainder: Option<&'a str>,
+}
+
+impl<'a> TestAsciiDelimiterSplit<'a> {
+    fn new(input: &'a str) -> Self {
+        Self {
+            remainder: Some(input),
+        }
+    }
+}
+
+impl<'a> Iterator for TestAsciiDelimiterSplit<'a> {
+    type Item = &'a str;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let remainder = self.remainder.take()?;
+        let Some(delimiter) = memchr2(b';', b' ', remainder.as_bytes()) else {
+            return Some(remainder);
+        };
+
+        let (word, rest) = remainder.split_at(delimiter);
+        self.remainder = Some(&rest[1..]);
+        Some(word)
+    }
+}
+
+fn run<'a>(
+    corpus: &'a [&'a str],
+    mut tokenize: impl FnMut(&'a str) -> TokenizerResult<'a>,
+) -> usize {
+    let mut checksum = 0;
+    for user_agent in corpus {
+        let result = black_box(tokenize(black_box(user_agent)));
+        checksum = black_box(
+            checksum
+                ^ result.tokens.len()
+                ^ result.position
+                ^ usize::from(result.bot_detected)
+                ^ usize::from(result.crawler_hint),
+        );
+    }
+    checksum
+}
+
+fn measure(mut run: impl FnMut() -> usize) -> Duration {
+    let start = Instant::now();
+    black_box(run());
+    start.elapsed()
+}
+
+struct BenchStats {
+    median: f64,
+    p95: f64,
+    median_ns_per_user_agent: f64,
+}
+
+impl BenchStats {
+    fn new(mut samples: Vec<Duration>, corpus_len: usize) -> Self {
+        samples.sort_unstable();
+        let median = percentile(&samples, 0.50).as_secs_f64() * 1_000.0;
+        let p95 = percentile(&samples, 0.95).as_secs_f64() * 1_000.0;
+        Self {
+            median,
+            p95,
+            median_ns_per_user_agent: median * 1_000_000.0 / corpus_len as f64,
+        }
+    }
+
+    fn print(&self, name: &str) {
+        println!(
+            "{name:<24} median={:>9.3}ms p95={:>9.3}ms median={:>9.1}ns/ua",
+            self.median, self.p95, self.median_ns_per_user_agent
+        );
+    }
+
+    fn saved_pct(&self, candidate: &Self) -> f64 {
+        (self.median - candidate.median) / self.median * 100.0
+    }
+}
+
+fn percentile(samples: &[Duration], percentile: f64) -> Duration {
+    let index = ((samples.len() - 1) as f64 * percentile).round() as usize;
+    samples[index]
+}